@velajs/storage 0.3.1 → 0.3.2

package/dist/middleware/compression.d.ts

@@ -1,16 +0,0 @@
-import { type Middleware } from './wrap';
-export type CompressionFormat = 'gzip' | 'deflate' | 'deflate-raw';
-export interface CompressionOptions {
-    /** Stream format. Default `gzip`. */
-    format?: CompressionFormat;
-    /** What to do when `CompressionStream` is unavailable. Default `throw`. */
-    onUnavailable?: 'throw' | 'passthrough';
-}
-/**
- * Transparent gzip/deflate via Web Streams `CompressionStream` — fully
- * streaming, opaque mode (v1). The stored object is compressed and tagged
- * `vela-zip`; reads detect the tag and decompress, so pre-existing (untagged)
- * objects pass through unharmed. Range reads / presigned URLs are disabled
- * (the byte stream is not seekable and a direct URL would serve gzip).
- */
-export declare function compression(opts?: CompressionOptions): Middleware;

package/dist/middleware/compression.js

@@ -1,101 +0,0 @@
-import { byteLengthOf, toStream } from "../internal/body.js";
-import { createStoredFile } from "../internal/stored-file.js";
-import { StorageError } from "../storage.error.js";
-import { passthrough } from "./wrap.js";
-function stripVela(meta) {
-    if (!meta) return undefined;
-    const out = {};
-    for (const [k, v] of Object.entries(meta))if (!k.startsWith('vela-')) out[k] = v;
-    return Object.keys(out).length ? out : undefined;
-}
-/**
- * Transparent gzip/deflate via Web Streams `CompressionStream` — fully
- * streaming, opaque mode (v1). The stored object is compressed and tagged
- * `vela-zip`; reads detect the tag and decompress, so pre-existing (untagged)
- * objects pass through unharmed. Range reads / presigned URLs are disabled
- * (the byte stream is not seekable and a direct URL would serve gzip).
- */ export function compression(opts = {}) {
-    const format = opts.format ?? 'gzip';
-    const available = typeof CompressionStream !== 'undefined' && typeof DecompressionStream !== 'undefined';
-    if (!available && (opts.onUnavailable ?? 'throw') === 'throw') {
-        throw new StorageError('Unsupported', 'CompressionStream is not available in this runtime');
-    }
-    return (inner)=>{
-        if (!available) return inner; // passthrough mode
-        const decompressDownload = async (k, _o)=>{
-            const file = await inner.download(k);
-            const zip = file.metadata?.['vela-zip'];
-            if (!zip) return file; // untagged / legacy object
-            const plain = file.stream().pipeThrough(new DecompressionStream(zip));
-            const size = file.metadata?.['vela-size'] ? Number(file.metadata['vela-size']) : file.size;
-            return createStoredFile({
-                key: k,
-                name: file.name,
-                size,
-                type: file.metadata?.['vela-ct'] ?? file.type,
-                lastModified: file.lastModified,
-                etag: file.etag,
-                metadata: stripVela(file.metadata)
-            }, {
-                kind: 'stream',
-                stream: plain
-            });
-        };
-        return passthrough(inner, {
-            reportsUploadProgress: false,
-            supportsRange: false,
-            signedUrl: {
-                supported: false,
-                upload: false
-            },
-            async upload (k, body, o) {
-                const zipped = toStream(body).pipeThrough(new CompressionStream(format));
-                const metadata = {
-                    ...o?.metadata,
-                    'vela-zip': format
-                };
-                if (o?.contentType) metadata['vela-ct'] = o.contentType;
-                const known = byteLengthOf(body);
-                if (known != null) metadata['vela-size'] = String(known);
-                const r = await inner.upload(k, zipped, {
-                    ...o,
-                    metadata: inner.supportsMetadata ? metadata : undefined,
-                    contentType: 'application/octet-stream'
-                });
-                return {
-                    ...r,
-                    size: known ?? r.size,
-                    contentType: o?.contentType ?? 'application/octet-stream'
-                };
-            },
-            download: decompressDownload,
-            async head (k, o) {
-                const file = await inner.head(k, o);
-                if (!file.metadata?.['vela-zip']) return file;
-                const size = file.metadata['vela-size'] ? Number(file.metadata['vela-size']) : file.size;
-                return createStoredFile({
-                    key: k,
-                    name: file.name,
-                    size,
-                    type: file.metadata['vela-ct'] ?? file.type,
-                    lastModified: file.lastModified,
-                    etag: file.etag,
-                    metadata: stripVela(file.metadata)
-                }, {
-                    kind: 'lazy',
-                    fetch: async ()=>new Response((await decompressDownload(k)).stream())
-                });
-            },
-            url () {
-                throw new StorageError('Unsupported', 'compression: url() would serve compressed bytes');
-            },
-            signedUploadUrl () {
-                throw new StorageError('Unsupported', 'compression: signed uploads would store uncompressed');
-            }
-        }, [
-            'createMultipartUpload',
-            'resumeMultipartUpload',
-            'signedMultipart'
-        ]);
-    };
-}

package/dist/middleware/encryption.d.ts

@@ -1,14 +0,0 @@
-import { type Middleware } from './wrap';
-export interface EncryptionOptions {
-    /** A 256-bit AES-GCM key: a `CryptoKey` or 32 raw bytes. */
-    key: CryptoKey | Uint8Array;
-    /** How to treat objects that aren't valid ciphertext (legacy data). Default `throw`. */
-    onInvalid?: 'throw' | 'passthrough';
-}
-/**
- * Transparent client-side encryption via Web Crypto AES-GCM. v1 encrypts the
- * WHOLE object (buffered); the stored object is `IV(12) || ciphertext+tag`.
- * Range reads, presigned URLs, and multipart are disabled (a signed URL would
- * hand out ciphertext / accept plaintext, defeating the invariant).
- */
-export declare function encryption(opts: EncryptionOptions): Middleware;

package/dist/middleware/encryption.js

@@ -1,134 +0,0 @@
-import { toBytes } from "../internal/body.js";
-import { createStoredFile } from "../internal/stored-file.js";
-import { StorageError } from "../storage.error.js";
-import { passthrough } from "./wrap.js";
-const IV_BYTES = 12;
-// The Web Crypto typings pin BufferSource to ArrayBuffer-backed views; our byte
-// views are ArrayBufferLike-typed. They are ArrayBuffer-backed at runtime, so a
-// narrowing cast is safe and confined to this helper.
-const asBuf = (u)=>u;
-function stripVela(meta) {
-    if (!meta) return undefined;
-    const out = {};
-    for (const [k, v] of Object.entries(meta))if (!k.startsWith('vela-')) out[k] = v;
-    return Object.keys(out).length ? out : undefined;
-}
-async function importKey(key) {
-    if (key instanceof Uint8Array) {
-        return crypto.subtle.importKey('raw', key, {
-            name: 'AES-GCM'
-        }, false, [
-            'encrypt',
-            'decrypt'
-        ]);
-    }
-    return key;
-}
-/**
- * Transparent client-side encryption via Web Crypto AES-GCM. v1 encrypts the
- * WHOLE object (buffered); the stored object is `IV(12) || ciphertext+tag`.
- * Range reads, presigned URLs, and multipart are disabled (a signed URL would
- * hand out ciphertext / accept plaintext, defeating the invariant).
- */ export function encryption(opts) {
-    const keyPromise = importKey(opts.key);
-    return (inner)=>{
-        const decryptDownload = async (k, _o)=>{
-            const file = await inner.download(k);
-            const framed = new Uint8Array(await file.arrayBuffer());
-            if (framed.byteLength < IV_BYTES) {
-                if (opts.onInvalid === 'passthrough') return file;
-                throw new StorageError('Parse', `object too small to be encrypted: ${k}`);
-            }
-            const iv = framed.subarray(0, IV_BYTES);
-            const ciphertext = framed.subarray(IV_BYTES);
-            const key = await keyPromise;
-            let plain;
-            try {
-                plain = new Uint8Array(await crypto.subtle.decrypt({
-                    name: 'AES-GCM',
-                    iv: asBuf(iv)
-                }, key, asBuf(ciphertext)));
-            } catch (e) {
-                if (opts.onInvalid === 'passthrough') return file;
-                throw new StorageError('Provider', `decryption failed: ${k}`, {
-                    cause: e
-                });
-            }
-            return createStoredFile({
-                key: k,
-                name: file.name,
-                size: plain.byteLength,
-                type: file.metadata?.['vela-ct'] ?? file.type,
-                lastModified: file.lastModified,
-                etag: file.etag,
-                metadata: stripVela(file.metadata)
-            }, {
-                kind: 'bytes',
-                bytes: plain
-            });
-        };
-        return passthrough(inner, {
-            reportsUploadProgress: false,
-            supportsRange: false,
-            signedUrl: {
-                supported: false,
-                upload: false
-            },
-            async upload (k, body, o) {
-                const plaintext = await toBytes(body);
-                const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
-                const key = await keyPromise;
-                const ct = new Uint8Array(await crypto.subtle.encrypt({
-                    name: 'AES-GCM',
-                    iv
-                }, key, asBuf(plaintext)));
-                const framed = new Uint8Array(IV_BYTES + ct.byteLength);
-                framed.set(iv, 0);
-                framed.set(ct, IV_BYTES);
-                const metadata = {
-                    ...o?.metadata,
-                    'vela-enc': 'AES-GCM'
-                };
-                if (o?.contentType) metadata['vela-ct'] = o.contentType;
-                metadata['vela-size'] = String(plaintext.byteLength);
-                const r = await inner.upload(k, framed, {
-                    ...o,
-                    metadata: inner.supportsMetadata ? metadata : undefined,
-                    contentType: 'application/octet-stream'
-                });
-                return {
-                    ...r,
-                    size: plaintext.byteLength,
-                    contentType: o?.contentType ?? 'application/octet-stream'
-                };
-            },
-            download: decryptDownload,
-            async head (k, o) {
-                const file = await inner.head(k, o);
-                const size = file.metadata?.['vela-size'] ? Number(file.metadata['vela-size']) : file.size;
-                return createStoredFile({
-                    key: k,
-                    name: file.name,
-                    size,
-                    type: file.metadata?.['vela-ct'] ?? file.type,
-                    lastModified: file.lastModified,
-                    etag: file.etag,
-                    metadata: stripVela(file.metadata)
-                }, {
-                    kind: 'lazy',
-                    fetch: async ()=>new Response((await decryptDownload(k)).stream())
-                });
-            },
-            url () {
-                throw new StorageError('Unsupported', 'encryption: url() would expose ciphertext');
-            },
-            signedUploadUrl () {
-                throw new StorageError('Unsupported', 'encryption: signed uploads would store plaintext');
-            }
-        }, [
-            'createMultipartUpload',
-            'resumeMultipartUpload',
-            'signedMultipart'
-        ]);
-    };
-}

package/dist/middleware/failover.d.ts

@@ -1,18 +0,0 @@
-import type { StorageDriver } from '../storage.types';
-import { type Middleware } from './wrap';
-export interface FailoverOptions {
-    /** Decide whether an error should trigger failover. Default: transient errors. */
-    shouldFailover?: (error: unknown) => boolean;
-    onFailover?: (info: {
-        from: number;
-        to: number;
-        error: unknown;
-    }) => void;
-}
-/**
- * Read-failover across a primary + fallbacks. Reads try each driver in order
- * until one succeeds; writes and presigning go to the primary only (avoids
- * partial/divergent writes). Capabilities are the intersection so the facade
- * never routes a feature to a driver that can't serve it.
- */
-export declare function failover(fallbacks: StorageDriver[], opts?: FailoverOptions): Middleware;

package/dist/middleware/failover.js

@@ -1,52 +0,0 @@
-import { StorageError } from "../storage.error.js";
-import { passthrough } from "./wrap.js";
-function isTransient(error) {
-    return error instanceof StorageError ? error.retryable : true;
-}
-function intersectCapabilities(chain) {
-    return {
-        supportsRange: chain.every((d)=>!!d.supportsRange),
-        supportsDelimiter: chain.every((d)=>!!d.supportsDelimiter),
-        supportsMetadata: chain.every((d)=>!!d.supportsMetadata),
-        supportsCacheControl: chain.every((d)=>!!d.supportsCacheControl),
-        supportsServerSideCopy: chain.every((d)=>!!d.supportsServerSideCopy)
-    };
-}
-/**
- * Read-failover across a primary + fallbacks. Reads try each driver in order
- * until one succeeds; writes and presigning go to the primary only (avoids
- * partial/divergent writes). Capabilities are the intersection so the facade
- * never routes a feature to a driver that can't serve it.
- */ export function failover(fallbacks, opts = {}) {
-    const should = opts.shouldFailover ?? isTransient;
-    return (primary)=>{
-        const chain = [
-            primary,
-            ...fallbacks
-        ];
-        const read = async (fn)=>{
-            let lastError;
-            for(let i = 0; i < chain.length; i++){
-                try {
-                    return await fn(chain[i]);
-                } catch (e) {
-                    lastError = e;
-                    if (!should(e) || i === chain.length - 1) throw e;
-                    opts.onFailover?.({
-                        from: i,
-                        to: i + 1,
-                        error: e
-                    });
-                }
-            }
-            throw lastError;
-        };
-        return passthrough(primary, {
-            ...intersectCapabilities(chain),
-            download: (k, o)=>read((d)=>d.download(k, o)),
-            head: (k, o)=>read((d)=>d.head(k, o)),
-            exists: (k, o)=>read((d)=>d.exists(k, o)),
-            list: (o)=>read((d)=>d.list(o))
-        });
-    };
-}

package/dist/middleware/retry.d.ts

@@ -1,14 +0,0 @@
-import type { RetryOptions } from '../storage.types';
-import { type Middleware } from './wrap';
-export interface RetryMiddlewareOptions {
-    /** Default retry policy for driver operations. Per-call `opts.retries` wins. */
-    retries?: RetryOptions;
-}
-/**
- * Retry transient failures at the driver level. Reads and idempotent ops
- * always retry; an upload retries only when its body is replayable (not a
- * one-shot stream). Note: the `Storage` facade also retries per
- * `OperationOptions.retries` — use this middleware when driving a driver
- * directly, or set the facade's retries to 0 to avoid compounding.
- */
-export declare function retry(opts?: RetryMiddlewareOptions): Middleware;

package/dist/middleware/retry.js

@@ -1,47 +0,0 @@
-import { isStream } from "../internal/body.js";
-import { runWithRetry } from "../internal/retry.js";
-import { passthrough } from "./wrap.js";
-/**
- * Retry transient failures at the driver level. Reads and idempotent ops
- * always retry; an upload retries only when its body is replayable (not a
- * one-shot stream). Note: the `Storage` facade also retries per
- * `OperationOptions.retries` — use this middleware when driving a driver
- * directly, or set the facade's retries to 0 to avoid compounding.
- */ export function retry(opts = {}) {
-    const base = opts.retries ?? 3;
-    const run = (o, fn)=>runWithRetry(fn, {
-            retries: o?.retries ?? base,
-            timeout: o?.timeout,
-            signal: o?.signal
-        });
-    return (inner)=>passthrough(inner, {
-            download: (k, o)=>run(o, (s)=>inner.download(k, {
-                        ...o,
-                        signal: s
-                    })),
-            head: (k, o)=>run(o, (s)=>inner.head(k, {
-                        ...o,
-                        signal: s
-                    })),
-            exists: (k, o)=>run(o, (s)=>inner.exists(k, {
-                        ...o,
-                        signal: s
-                    })),
-            list: (o)=>run(o, (s)=>inner.list({
-                        ...o,
-                        signal: s
-                    })),
-            delete: (k, o)=>run(o, (s)=>inner.delete(k, {
-                        ...o,
-                        signal: s
-                    })),
-            copy: (f, t, o)=>run(o, (s)=>inner.copy(f, t, {
-                        ...o,
-                        signal: s
-                    })),
-            upload: (k, b, o)=>isStream(b) ? inner.upload(k, b, o) : run(o, (s)=>inner.upload(k, b, {
-                        ...o,
-                        signal: s
-                    }))
-        });
-}

package/dist/middleware/versioning.d.ts

@@ -1,36 +0,0 @@
-import type { StorageDriver } from '../storage.types';
-import { type Middleware } from './wrap';
-export interface VersionInfo {
-    versionId: string;
-    key: string;
-    size: number;
-    lastModified?: number;
-}
-/** Extra surface a versioning-wrapped driver exposes (reached via {@link unwrapVersioning}). */
-export interface Versioned {
-    listVersions(key: string): Promise<VersionInfo[]>;
-    restore(key: string, versionId: string): Promise<void>;
-    deleteVersion(key: string, versionId: string): Promise<void>;
-}
-export declare const VERSIONED: unique symbol;
-export interface VersioningOptions {
-    /** Prefix under which prior versions are stored. Default `.vela-versions/`. */
-    prefix?: string;
-    versionId?: () => string;
-    /** Keep at most this many versions per key (prunes oldest). */
-    maxVersions?: number;
-    /** Hide the version prefix from `list()`. Default true. */
-    hideFromList?: boolean;
-    /** On delete: snapshot first (default) or purge all versions. */
-    onDelete?: 'snapshot' | 'purge';
-}
-/**
- * Keeps prior versions on overwrite via key-suffixing (no external manifest →
- * no read-modify-write race). Snapshots are cheap when the base driver
- * `supportsServerSideCopy`. Direct presigned uploads bypass snapshotting, so
- * `signedUploadUrl` throws. Reach `listVersions`/`restore`/`deleteVersion` via
- * {@link unwrapVersioning}.
- */
-export declare function versioning(opts?: VersioningOptions): Middleware;
-/** Retrieve the {@link Versioned} surface from a versioning-wrapped driver (or `undefined`). */
-export declare function unwrapVersioning(driver: StorageDriver): Versioned | undefined;

package/dist/middleware/versioning.js

@@ -1,89 +0,0 @@
-import { StorageError } from "../storage.error.js";
-import { passthrough } from "./wrap.js";
-export const VERSIONED = Symbol.for('vela.storage.versioned');
-/**
- * Keeps prior versions on overwrite via key-suffixing (no external manifest →
- * no read-modify-write race). Snapshots are cheap when the base driver
- * `supportsServerSideCopy`. Direct presigned uploads bypass snapshotting, so
- * `signedUploadUrl` throws. Reach `listVersions`/`restore`/`deleteVersion` via
- * {@link unwrapVersioning}.
- */ export function versioning(opts = {}) {
-    const prefix = opts.prefix ?? '.vela-versions/';
-    let seq = 0;
-    const vid = opts.versionId ?? (()=>`${Date.now().toString(36)}-${(seq++).toString(36)}`);
-    const vkey = (key, id)=>`${prefix}${key}/${id}`;
-    const isVersion = (key)=>key.startsWith(prefix);
-    const listVersions = async (inner, key)=>{
-        const res = await inner.list({
-            prefix: `${prefix}${key}/`
-        });
-        return res.items.map((item)=>({
-                versionId: item.key.slice(item.key.lastIndexOf('/') + 1),
-                key: item.key,
-                size: item.size,
-                lastModified: item.lastModified
-            }));
-    };
-    const snapshot = async (inner, key)=>{
-        if (!await inner.exists(key)) return;
-        const id = vid();
-        if (inner.supportsServerSideCopy) {
-            await inner.copy(key, vkey(key, id));
-        } else {
-            const current = await inner.download(key);
-            await inner.upload(vkey(key, id), current.stream(), {
-                contentType: current.type
-            });
-        }
-        if (opts.maxVersions) {
-            const versions = (await listVersions(inner, key)).sort((a, b)=>a.versionId < b.versionId ? -1 : 1);
-            for (const v of versions.slice(0, Math.max(0, versions.length - opts.maxVersions))){
-                await inner.delete(v.key);
-            }
-        }
-    };
-    return (inner)=>{
-        const driver = passthrough(inner, {
-            async upload (k, b, o) {
-                await snapshot(inner, k);
-                return inner.upload(k, b, o);
-            },
-            async copy (f, t, o) {
-                await snapshot(inner, t);
-                return inner.copy(f, t, o);
-            },
-            async delete (k, o) {
-                if (opts.onDelete !== 'purge') await snapshot(inner, k);
-                await inner.delete(k, o);
-                if (opts.onDelete === 'purge') {
-                    for (const v of (await listVersions(inner, k)))await inner.delete(v.key);
-                }
-            },
-            list: opts.hideFromList === false ? undefined : async (o)=>{
-                const res = await inner.list(o);
-                return {
-                    items: res.items.filter((i)=>!isVersion(i.key)),
-                    prefixes: res.prefixes?.filter((p)=>!isVersion(p)),
-                    cursor: res.cursor
-                };
-            },
-            signedUploadUrl () {
-                throw new StorageError('Unsupported', 'versioning: direct uploads bypass snapshots');
-            }
-        });
-        const versioned = {
-            listVersions: (key)=>listVersions(inner, key),
-            async restore (key, versionId) {
-                await snapshot(inner, key);
-                await inner.copy(vkey(key, versionId), key);
-            },
-            deleteVersion: (key, versionId)=>inner.delete(vkey(key, versionId))
-        };
-        return Object.assign(driver, {
-            [VERSIONED]: versioned
-        });
-    };
-}
-/** Retrieve the {@link Versioned} surface from a versioning-wrapped driver (or `undefined`). */ export function unwrapVersioning(driver) {
-    return driver[VERSIONED];
-}

package/dist/middleware/wrap.d.ts

@@ -1,11 +0,0 @@
-import type { StorageDriver } from '../storage.types';
-/** A driver middleware: wraps a driver, returns a driver. */
-export type Middleware = (inner: StorageDriver) => StorageDriver;
-/**
- * Build a driver that delegates to `inner`, applying `over` overrides and
- * omitting the methods in `omit`. Explicit delegation (not spread) keeps
- * class-based drivers' `this`. Optional methods are forwarded only when the
- * inner driver has them (so `presence == capability` is preserved), unless
- * omitted (e.g. a body-transforming middleware suppresses multipart/presign).
- */
-export declare function passthrough(inner: StorageDriver, over?: Partial<StorageDriver>, omit?: ReadonlyArray<keyof StorageDriver>): StorageDriver;

package/dist/middleware/wrap.js

@@ -1,46 +0,0 @@
-/**
- * Build a driver that delegates to `inner`, applying `over` overrides and
- * omitting the methods in `omit`. Explicit delegation (not spread) keeps
- * class-based drivers' `this`. Optional methods are forwarded only when the
- * inner driver has them (so `presence == capability` is preserved), unless
- * omitted (e.g. a body-transforming middleware suppresses multipart/presign).
- */ export function passthrough(inner, over = {}, omit = []) {
-    const omitted = new Set(omit);
-    const has = (k)=>!omitted.has(k);
-    const d = {
-        name: over.name ?? inner.name,
-        raw: inner.raw,
-        reportsUploadProgress: over.reportsUploadProgress ?? inner.reportsUploadProgress,
-        supportsRange: over.supportsRange ?? inner.supportsRange,
-        supportsDelimiter: over.supportsDelimiter ?? inner.supportsDelimiter,
-        supportsMetadata: over.supportsMetadata ?? inner.supportsMetadata,
-        supportsCacheControl: over.supportsCacheControl ?? inner.supportsCacheControl,
-        supportsServerSideCopy: over.supportsServerSideCopy ?? inner.supportsServerSideCopy,
-        signedUrl: over.signedUrl ?? inner.signedUrl,
-        upload: over.upload ?? ((k, b, o)=>inner.upload(k, b, o)),
-        download: over.download ?? ((k, o)=>inner.download(k, o)),
-        head: over.head ?? ((k, o)=>inner.head(k, o)),
-        exists: over.exists ?? ((k, o)=>inner.exists(k, o)),
-        delete: over.delete ?? ((k, o)=>inner.delete(k, o)),
-        copy: over.copy ?? ((f, t, o)=>inner.copy(f, t, o)),
-        list: over.list ?? ((o)=>inner.list(o)),
-        url: over.url ?? ((k, o)=>inner.url(k, o)),
-        signedUploadUrl: over.signedUploadUrl ?? ((k, o)=>inner.signedUploadUrl(k, o))
-    };
-    if (has('deleteMany') && (over.deleteMany || inner.deleteMany)) {
-        d.deleteMany = over.deleteMany ?? ((ks, o)=>inner.deleteMany(ks, o));
-    }
-    if (has('move') && (over.move || inner.move)) {
-        d.move = over.move ?? ((f, t, o)=>inner.move(f, t, o));
-    }
-    if (has('createMultipartUpload') && (over.createMultipartUpload || inner.createMultipartUpload)) {
-        d.createMultipartUpload = over.createMultipartUpload ?? ((k, o)=>inner.createMultipartUpload(k, o));
-    }
-    if (has('resumeMultipartUpload') && (over.resumeMultipartUpload || inner.resumeMultipartUpload)) {
-        d.resumeMultipartUpload = over.resumeMultipartUpload ?? ((k, u)=>inner.resumeMultipartUpload(k, u));
-    }
-    if (has('signedMultipart') && (over.signedMultipart || inner.signedMultipart)) {
-        d.signedMultipart = over.signedMultipart ?? inner.signedMultipart;
-    }
-    return d;
-}

package/dist/object-key.d.ts

@@ -1,17 +0,0 @@
-/**
- * True when `key` is a safe object key:
- * - non-empty, not longer than 1024 bytes (S3's limit)
- * - no leading `/`
- * - no `.` / `..` path segments (traversal)
- * - no control characters
- * - no backslashes (Windows-style separators)
- */
-export declare function isSafeKey(key: string): boolean;
-/** Return `key` if safe, else throw `StorageError('InvalidKey')`. */
-export declare function sanitizeKey(key: string): string;
-/** Normalize a prefix: drop leading/trailing slashes, collapse to '' when empty. */
-export declare function normalizePrefix(prefix: string | undefined): string;
-/** Join a normalized prefix and a key with a single '/'. */
-export declare function joinKey(prefix: string, key: string): string;
-/** Strip a normalized prefix from a stored key (for surfacing to callers). */
-export declare function stripPrefix(prefix: string, key: string): string;

package/dist/object-key.js

@@ -1,42 +0,0 @@
-import { StorageError } from "./storage.error.js";
-// Object-key hygiene shared by the facade (prefix scoping) and the HTTP
-// controller (post-authorize re-sanitization). The rules block the classic
-// traversal / injection footguns without being so strict that legitimate
-// keys (nested "folders", dots, spaces) are rejected.
-// Control characters: C0 range (0x00-0x1F) plus DEL (0x7F).
-const CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
-/**
- * True when `key` is a safe object key:
- * - non-empty, not longer than 1024 bytes (S3's limit)
- * - no leading `/`
- * - no `.` / `..` path segments (traversal)
- * - no control characters
- * - no backslashes (Windows-style separators)
- */ export function isSafeKey(key) {
-    if (typeof key !== 'string' || key.length === 0 || key.length > 1024) return false;
-    if (key.startsWith('/')) return false;
-    if (key.includes('\\')) return false;
-    if (CONTROL_CHARS.test(key)) return false;
-    for (const segment of key.split('/')){
-        if (segment === '.' || segment === '..') return false;
-    }
-    return true;
-}
-/** Return `key` if safe, else throw `StorageError('InvalidKey')`. */ export function sanitizeKey(key) {
-    if (!isSafeKey(key)) {
-        throw new StorageError('InvalidKey', `unsafe object key: ${JSON.stringify(key)}`);
-    }
-    return key;
-}
-/** Normalize a prefix: drop leading/trailing slashes, collapse to '' when empty. */ export function normalizePrefix(prefix) {
-    if (!prefix) return '';
-    return prefix.replace(/^\/+/, '').replace(/\/+$/, '');
-}
-/** Join a normalized prefix and a key with a single '/'. */ export function joinKey(prefix, key) {
-    return prefix ? `${prefix}/${key}` : key;
-}
-/** Strip a normalized prefix from a stored key (for surfacing to callers). */ export function stripPrefix(prefix, key) {
-    if (!prefix) return key;
-    const withSlash = `${prefix}/`;
-    return key.startsWith(withSlash) ? key.slice(withSlash.length) : key;
-}