@velajs/storage 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.2.0 (2026-07-04)
+
+- Rebuilt on vela 1.11 `defineModule` + `lazyProvider` (hand-rolled forRoot/forRootAsync deleted; public API byte-identical). Requires `@velajs/vela >=1.11.0`.
+
+
+## 0.1.0 (unreleased)
+
+- Initial release: edge-first, driver-based object/file storage for Vela.
+  - `StorageModule` (`forRoot` / `forRootAsync`) with multi-bucket named instances.
+  - `Storage` facade with capability-gating, retry/timeout/abort, and multipart orchestration.
+  - Drivers: in-memory, S3 / S3-compatible (aws4fetch SigV4), R2 native binding, R2 over HTTP + hybrid.
+  - Opt-in `storageSdkDriver()` bridge for `@storagesdk/adapters` (Node/Bun).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kauan Guesser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# @velajs/storage
+
+Edge-first, driver-based object/file storage for the [Vela](https://github.com/velajs/vela) framework.
+
+Runs on Cloudflare Workers, Deno, Bun, Node 20+, and Vercel Edge — **no AWS SDK, ever**. S3/R2
+requests are signed with [`aws4fetch`](https://github.com/mhart/aws4fetch) (`fetch` + Web Crypto),
+so the whole default path passes Vela's `edge-runtime-audit` gate.
+
+## Why not just wrap files-sdk / storagesdk?
+
+Both are great libraries, but their object-store adapters statically import the AWS SDK v3 (~500KB,
+breaks on Workers). `@velajs/storage` owns an **edge-native `StorageDriver` contract** and ships
+first-party drivers that sign with `aws4fetch`. You can still reach the wider ecosystem through the
+opt-in `storageSdkDriver()` bridge (`@velajs/storage/storagesdk`) on Node/Bun.
+
+## Install
+
+```sh
+pnpm add @velajs/storage
+```
+
+## Quick start
+
+```ts
+import { StorageModule, StorageService } from '@velajs/storage';
+import { s3Driver } from '@velajs/storage/drivers/s3';
+
+@Module({
+  imports: [
+    StorageModule.forRootAsync({
+      inject: [EnvService],
+      useFactory: (env) =>
+        s3Driver({
+          endpoint: 'https://s3.us-east-1.amazonaws.com',
+          region: 'us-east-1',
+          bucket: 'my-bucket',
+          credentials: { accessKeyId: env.get('AWS_KEY'), secretAccessKey: env.get('AWS_SECRET') },
+        }),
+    }),
+  ],
+})
+class AppModule {}
+```
+
+## Drivers
+
+| Driver | Import | Edge? | Presign |
+|---|---|---|---|
+| Memory (tests) | `@velajs/storage/drivers/memory` | ✅ | ❌ |
+| S3 / S3-compatible | `@velajs/storage/drivers/s3` | ✅ | ✅ |
+| R2 (native binding) | `@velajs/storage/drivers/r2` | ✅ | via hybrid |
+| R2 (HTTP + hybrid) | `@velajs/storage/drivers/r2-http` | ✅ | ✅ |
+| storagesdk bridge | `@velajs/storage/storagesdk` | Node/Bun only | depends on adapter |
+
+See the docs site for presigned uploads, the HTTP upload controller + browser client, middleware,
+multi-bucket, and the full capability matrix.

package/dist/base64.d.ts

@@ -0,0 +1,8 @@
+/** Encode bytes to standard base64. */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Decode standard base64 to bytes. */
+export declare function base64ToBytes(b64: string): Uint8Array;
+/** Encode a UTF-8 string to base64 (unicode-safe, unlike raw `btoa`). */
+export declare function utf8ToBase64(text: string): string;
+/** URL-safe base64 (base64url) without padding — used by SigV4 / policies. */
+export declare function bytesToBase64Url(bytes: Uint8Array): string;

package/dist/base64.js

@@ -0,0 +1,25 @@
+// Edge-safe base64 — NO `Buffer` (banned by the edge-runtime audit).
+// Uses `btoa`/`atob` over chunked `String.fromCharCode`, present on every
+// target runtime (Workers, Deno, Bun, Node 20+, browsers).
+// Chunk stays <= 0x8000 so the spread into String.fromCharCode never exceeds
+// the engine argument limit.
+const CHUNK = 0x8000;
+/** Encode bytes to standard base64. */ export function bytesToBase64(bytes) {
+    let binary = '';
+    for(let i = 0; i < bytes.length; i += CHUNK){
+        binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+    }
+    return btoa(binary);
+}
+/** Decode standard base64 to bytes. */ export function base64ToBytes(b64) {
+    const binary = atob(b64);
+    const out = new Uint8Array(binary.length);
+    for(let i = 0; i < binary.length; i++)out[i] = binary.charCodeAt(i);
+    return out;
+}
+/** Encode a UTF-8 string to base64 (unicode-safe, unlike raw `btoa`). */ export function utf8ToBase64(text) {
+    return bytesToBase64(new TextEncoder().encode(text));
+}
+/** URL-safe base64 (base64url) without padding — used by SigV4 / policies. */ export function bytesToBase64Url(bytes) {
+    return bytesToBase64(bytes).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}

package/dist/client/index.d.ts

@@ -0,0 +1,50 @@
+import type { UploadResult } from '../storage.types';
+import type { ListResponse } from '../http/protocol.types';
+import type { DeleteManyResult } from '../storage.types';
+export interface StorageClientOptions {
+    /** Base URL of the mounted controller, e.g. `/api/storage`. */
+    baseUrl: string;
+    /** Per-request headers (auth token/cookie). */
+    headers?: () => Record<string, string> | Promise<Record<string, string>>;
+    /** Override fetch (SSR/tests). */
+    fetch?: typeof fetch;
+    /** Files larger than this switch to multipart. Default 16 MiB. */
+    multipartThreshold?: number;
+}
+export interface ClientUploadOptions {
+    /** Object key. Defaults to the file's name. The server may override it. */
+    key?: string;
+    contentType?: string;
+    metadata?: Record<string, string>;
+    multipart?: boolean | {
+        partSize?: number;
+        concurrency?: number;
+    };
+    onProgress?: (p: {
+        loaded: number;
+        total: number;
+    }) => void;
+    signal?: AbortSignal;
+    /** Stable id enabling resume across reloads (multipart only). */
+    resumeKey?: string;
+}
+export declare class StorageClientError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status: number);
+    static from(res: Response): Promise<StorageClientError>;
+}
+export declare class StorageClient {
+    #private;
+    private readonly options;
+    constructor(options: StorageClientOptions);
+    upload(file: File | Blob, opts?: ClientUploadOptions): Promise<UploadResult>;
+    list(query?: {
+        prefix?: string;
+        cursor?: string;
+        limit?: number;
+        delimiter?: string;
+    }): Promise<ListResponse>;
+    delete(keys: string[]): Promise<DeleteManyResult>;
+    downloadUrl(key: string): Promise<string>;
+}

package/dist/client/index.js

@@ -0,0 +1,243 @@
+// Browser upload client for @velajs/storage. Framework-agnostic, zero-dep.
+// Ships from the `./client` subpath (DOM code, not edge code). Talks to the
+// StorageController's JSON control-plane over fetch, and uploads bytes DIRECTLY
+// to the bucket via presigned URLs (XHR for progress; fetch has no upload
+// progress event). Wire types are imported type-only.
+const DEFAULT_MULTIPART_THRESHOLD = 16 * 1024 * 1024; // 16 MiB
+const DEFAULT_CONCURRENCY = 4;
+export class StorageClientError extends Error {
+    code;
+    status;
+    constructor(code, message, status){
+        super(message), this.code = code, this.status = status;
+        this.name = 'StorageClientError';
+    }
+    static async from(res) {
+        let code = 'upstream_error';
+        let message = `request failed: ${res.status}`;
+        try {
+            const body = await res.json();
+            if (body?.error) {
+                code = body.error.code;
+                message = body.error.message;
+            }
+        } catch  {
+        /* non-JSON body */ }
+        return new StorageClientError(code, message, res.status);
+    }
+}
+async function pool(items, limit, worker) {
+    let i = 0;
+    const run = async ()=>{
+        while(i < items.length){
+            const index = i++;
+            await worker(items[index], index);
+        }
+    };
+    await Promise.all(Array.from({
+        length: Math.min(Math.max(1, limit), items.length || 1)
+    }, run));
+}
+function xhrSend(o) {
+    return new Promise((resolve, reject)=>{
+        const xhr = new XMLHttpRequest();
+        xhr.open(o.method, o.url, true);
+        for (const [k, v] of Object.entries(o.headers ?? {}))xhr.setRequestHeader(k, v);
+        if (o.onProgress) {
+            xhr.upload.onprogress = (e)=>o.onProgress({
+                    loaded: e.loaded,
+                    total: e.total
+                });
+        }
+        xhr.onload = ()=>xhr.status >= 200 && xhr.status < 300 ? resolve({
+                status: xhr.status,
+                getHeader: (n)=>xhr.getResponseHeader(n)
+            }) : reject(new StorageClientError('upstream_error', `upload failed: ${xhr.status}`, xhr.status));
+        xhr.onerror = ()=>reject(new StorageClientError('upstream_error', 'network error', 0));
+        o.signal?.addEventListener('abort', ()=>xhr.abort(), {
+            once: true
+        });
+        xhr.send(o.body);
+    });
+}
+function loadSession(resumeKey, fingerprint) {
+    if (!resumeKey || typeof localStorage === 'undefined') return undefined;
+    try {
+        const raw = localStorage.getItem(`vela.storage.resume:${resumeKey}`);
+        if (!raw) return undefined;
+        const s = JSON.parse(raw);
+        return s.fingerprint === fingerprint ? s : undefined;
+    } catch  {
+        return undefined;
+    }
+}
+function saveSession(resumeKey, fingerprint, s) {
+    if (!resumeKey || typeof localStorage === 'undefined') return;
+    try {
+        localStorage.setItem(`vela.storage.resume:${resumeKey}`, JSON.stringify({
+            ...s,
+            fingerprint
+        }));
+    } catch  {
+    /* quota / private mode — resume is best-effort */ }
+}
+function clearSession(resumeKey) {
+    if (!resumeKey || typeof localStorage === 'undefined') return;
+    try {
+        localStorage.removeItem(`vela.storage.resume:${resumeKey}`);
+    } catch  {
+    /* ignore */ }
+}
+export class StorageClient {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    async upload(file, opts = {}) {
+        const threshold = this.options.multipartThreshold ?? DEFAULT_MULTIPART_THRESHOLD;
+        const multipart = opts.multipart === true || opts.multipart !== false && file.size > threshold;
+        return multipart ? this.#multipartUpload(file, opts) : this.#simpleUpload(file, opts);
+    }
+    list(query = {}) {
+        const qs = new URLSearchParams();
+        for (const [k, v] of Object.entries(query))if (v != null) qs.set(k, String(v));
+        return this.#json('GET', `/list?${qs.toString()}`);
+    }
+    delete(keys) {
+        return this.#json('POST', '/delete', {
+            keys
+        });
+    }
+    async downloadUrl(key) {
+        const r = await this.#json('POST', '/sign-download', {
+            key
+        });
+        return r.url;
+    }
+    // ---- internals ----
+    async #simpleUpload(file, opts) {
+        const key = opts.key ?? fileName(file);
+        const { upload } = await this.#json('POST', '/sign-upload', {
+            key,
+            contentType: opts.contentType ?? (file.type || undefined),
+            size: file.size,
+            metadata: opts.metadata
+        });
+        if (upload.method === 'PUT') {
+            await xhrSend({
+                method: 'PUT',
+                url: upload.url,
+                body: file,
+                headers: {
+                    'content-type': file.type || 'application/octet-stream',
+                    ...upload.headers
+                },
+                signal: opts.signal,
+                onProgress: opts.onProgress
+            });
+        } else {
+            const form = new FormData();
+            for (const [k, v] of Object.entries(upload.fields))form.append(k, v);
+            form.append('file', file); // 'file' must be last for an S3/R2 POST policy
+            await xhrSend({
+                method: 'POST',
+                url: upload.url,
+                body: form,
+                signal: opts.signal,
+                onProgress: opts.onProgress
+            });
+        }
+        return {
+            key,
+            size: file.size,
+            contentType: opts.contentType ?? (file.type || 'application/octet-stream')
+        };
+    }
+    async #multipartUpload(file, opts) {
+        const key = opts.key ?? fileName(file);
+        const fingerprint = `${fileName(file)}:${file.size}`;
+        const concurrency = typeof opts.multipart === 'object' && opts.multipart.concurrency || DEFAULT_CONCURRENCY;
+        let session = loadSession(opts.resumeKey, fingerprint);
+        if (!session) {
+            const created = await this.#json('POST', '/multipart/create', {
+                key,
+                contentType: opts.contentType ?? (file.type || undefined),
+                metadata: opts.metadata,
+                partSize: typeof opts.multipart === 'object' ? opts.multipart.partSize : undefined
+            });
+            session = {
+                key: created.key,
+                uploadId: created.uploadId,
+                partSize: created.partSize,
+                uploaded: {}
+            };
+        }
+        const partSize = session.partSize;
+        const count = Math.ceil(file.size / partSize) || 1;
+        const loaded = new Array(count + 1).fill(0);
+        for (const n of Object.keys(session.uploaded))loaded[Number(n)] = partBytes(Number(n), partSize, file.size);
+        const report = ()=>opts.onProgress?.({
+                loaded: loaded.reduce((a, b)=>a + b, 0),
+                total: file.size
+            });
+        const todo = Array.from({
+            length: count
+        }, (_, i)=>i + 1).filter((n)=>!session.uploaded[n]);
+        await pool(todo, concurrency, async (n)=>{
+            const blob = file.slice((n - 1) * partSize, Math.min(n * partSize, file.size));
+            const signed = await this.#json('POST', '/multipart/sign-part', {
+                key: session.key,
+                uploadId: session.uploadId,
+                partNumber: n
+            });
+            const res = await xhrSend({
+                method: 'PUT',
+                url: signed.url,
+                body: blob,
+                headers: signed.headers,
+                signal: opts.signal,
+                onProgress: (p)=>{
+                    loaded[n] = p.loaded;
+                    report();
+                }
+            });
+            const etag = res.getHeader('ETag') ?? res.getHeader('etag');
+            if (!etag) {
+                throw new StorageClientError('invalid_request', 'missing ETag on part upload (check bucket CORS ExposeHeaders: ETag)', res.status);
+            }
+            session.uploaded[n] = etag;
+            saveSession(opts.resumeKey, fingerprint, session);
+        });
+        const parts = Object.entries(session.uploaded).map(([n, etag])=>({
+                partNumber: Number(n),
+                etag
+            })).sort((a, b)=>a.partNumber - b.partNumber);
+        const result = await this.#json('POST', '/multipart/complete', {
+            key: session.key,
+            uploadId: session.uploadId,
+            parts
+        });
+        clearSession(opts.resumeKey);
+        return result;
+    }
+    async #json(method, path, body) {
+        const fetchImpl = this.options.fetch ?? fetch;
+        const res = await fetchImpl(this.options.baseUrl + path, {
+            method,
+            headers: {
+                'content-type': 'application/json',
+                ...await this.options.headers?.() ?? {}
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined
+        });
+        if (!res.ok) throw await StorageClientError.from(res);
+        return await res.json();
+    }
+}
+function fileName(file) {
+    return 'name' in file && typeof file.name === 'string' && file.name ? file.name : 'upload.bin';
+}
+function partBytes(partNumber, partSize, total) {
+    const start = (partNumber - 1) * partSize;
+    return Math.max(0, Math.min(partSize, total - start));
+}

package/dist/decorators/inject-storage.decorator.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Inject the {@link StorageService} for a named bucket.
+ *
+ * ```ts
+ * class UploadService {
+ *   constructor(
+ *     @InjectStorage() private readonly uploads: StorageService,          // default bucket
+ *     @InjectStorage('backups') private readonly backups: StorageService, // named bucket
+ *   ) {}
+ * }
+ * ```
+ *
+ * The default bucket resolves the `StorageService` class token directly (so
+ * plain `@Inject(StorageService)` and `Test.overrideProvider(StorageService)`
+ * keep working); named buckets resolve their per-name token.
+ */
+export declare function InjectStorage(name?: string): ParameterDecorator;

package/dist/decorators/inject-storage.decorator.js

@@ -0,0 +1,21 @@
+import { Inject } from "@velajs/vela";
+import { StorageService } from "../storage.service.js";
+import { DEFAULT_STORAGE_NAME, storageToken } from "../storage.tokens.js";
+/**
+ * Inject the {@link StorageService} for a named bucket.
+ *
+ * ```ts
+ * class UploadService {
+ *   constructor(
+ *     @InjectStorage() private readonly uploads: StorageService,          // default bucket
+ *     @InjectStorage('backups') private readonly backups: StorageService, // named bucket
+ *   ) {}
+ * }
+ * ```
+ *
+ * The default bucket resolves the `StorageService` class token directly (so
+ * plain `@Inject(StorageService)` and `Test.overrideProvider(StorageService)`
+ * keep working); named buckets resolve their per-name token.
+ */ export function InjectStorage(name = DEFAULT_STORAGE_NAME) {
+    return Inject(name === DEFAULT_STORAGE_NAME ? StorageService : storageToken(name));
+}

package/dist/drivers/memory/index.d.ts

@@ -0,0 +1,16 @@
+import type { StorageDriver } from '../../storage.types';
+export interface MemoryEntry {
+    bytes: Uint8Array;
+    contentType: string;
+    cacheControl?: string;
+    metadata?: Record<string, string>;
+    etag: string;
+    lastModified: number;
+}
+export interface MemoryDriverOptions {
+    /** Pre-seed the store with `{ key: bytes|string }`. */
+    initial?: Record<string, Uint8Array | string>;
+}
+export type MemoryDriver = StorageDriver<Map<string, MemoryEntry>>;
+/** In-memory storage driver — the test/dev workhorse and reference impl. */
+export declare function memoryDriver(options?: MemoryDriverOptions): MemoryDriver;

package/dist/drivers/memory/index.js

@@ -0,0 +1,202 @@
+import { concatChunks, toBytes } from "../../internal/body.js";
+import { createStoredFile } from "../../internal/stored-file.js";
+import { StorageError } from "../../storage.error.js";
+// FNV-1a 64-bit content hash — deterministic, edge-safe (BigInt, no node:crypto).
+// Memory is a dev/test driver; the ETag never interoperates with real S3 ETags.
+const FNV_OFFSET = 0xcbf29ce484222325n;
+const FNV_PRIME = 0x100000001b3n;
+const U64 = 0xffffffffffffffffn;
+function contentEtag(bytes) {
+    let h = FNV_OFFSET;
+    for (const b of bytes){
+        h ^= BigInt(b);
+        h = h * FNV_PRIME & U64;
+    }
+    return `"${h.toString(16).padStart(16, '0')}"`;
+}
+function makeEntry(bytes, opts) {
+    return {
+        bytes,
+        contentType: opts?.contentType ?? 'application/octet-stream',
+        cacheControl: opts?.cacheControl,
+        metadata: opts?.metadata,
+        etag: contentEtag(bytes),
+        lastModified: Date.now()
+    };
+}
+/** In-memory storage driver — the test/dev workhorse and reference impl. */ export function memoryDriver(options) {
+    const store = new Map();
+    const encoder = new TextEncoder();
+    for (const [key, value] of Object.entries(options?.initial ?? {})){
+        const bytes = typeof value === 'string' ? encoder.encode(value) : value;
+        store.set(key, makeEntry(bytes));
+    }
+    const toStored = (key, entry, bytes)=>createStoredFile({
+            key,
+            size: bytes.byteLength,
+            type: entry.contentType,
+            lastModified: entry.lastModified,
+            etag: entry.etag,
+            metadata: entry.metadata
+        }, {
+            kind: 'bytes',
+            bytes
+        });
+    const mustGet = (key)=>{
+        const e = store.get(key);
+        if (!e) throw new StorageError('NotFound', `object not found: ${key}`);
+        return e;
+    };
+    return {
+        name: 'memory',
+        raw: store,
+        supportsRange: true,
+        supportsDelimiter: true,
+        supportsMetadata: true,
+        supportsCacheControl: true,
+        supportsServerSideCopy: true,
+        reportsUploadProgress: false,
+        signedUrl: {
+            supported: false,
+            upload: false
+        },
+        async upload (key, body, opts) {
+            const bytes = await toBytes(body);
+            const entry = makeEntry(bytes, opts);
+            store.set(key, entry);
+            return {
+                key,
+                size: bytes.byteLength,
+                contentType: entry.contentType,
+                etag: entry.etag,
+                lastModified: entry.lastModified
+            };
+        },
+        async download (key, opts) {
+            const entry = mustGet(key);
+            if (opts?.range) {
+                const start = opts.range.start;
+                const end = opts.range.end ?? entry.bytes.byteLength - 1;
+                return toStored(key, entry, entry.bytes.subarray(start, end + 1));
+            }
+            return toStored(key, entry, entry.bytes);
+        },
+        async head (key) {
+            const entry = mustGet(key);
+            return toStored(key, entry, entry.bytes);
+        },
+        async exists (key) {
+            return store.has(key);
+        },
+        async delete (key) {
+            store.delete(key);
+        },
+        async deleteMany (keys) {
+            for (const k of keys)store.delete(k);
+            return {
+                deleted: keys
+            };
+        },
+        async copy (from, to) {
+            const e = mustGet(from);
+            store.set(to, {
+                ...e,
+                bytes: e.bytes.slice(),
+                lastModified: Date.now()
+            });
+        },
+        async move (from, to) {
+            const e = mustGet(from);
+            store.set(to, e);
+            store.delete(from);
+        },
+        async list (opts) {
+            const prefix = opts?.prefix ?? '';
+            const delimiter = opts?.delimiter;
+            const limit = opts?.limit ?? 1000;
+            const start = opts?.cursor ? Number.parseInt(opts.cursor, 10) : 0;
+            const matched = [
+                ...store.keys()
+            ].filter((k)=>k.startsWith(prefix)).sort();
+            if (delimiter) {
+                const prefixes = new Set();
+                const direct = [];
+                for (const k of matched){
+                    const rest = k.slice(prefix.length);
+                    const idx = rest.indexOf(delimiter);
+                    if (idx === -1) direct.push(k);
+                    else prefixes.add(prefix + rest.slice(0, idx + delimiter.length));
+                }
+                const page = direct.slice(start, start + limit);
+                const cursor = start + limit < direct.length ? String(start + limit) : undefined;
+                return {
+                    items: page.map((k)=>toStored(k, mustGet(k), mustGet(k).bytes)),
+                    prefixes: start === 0 && prefixes.size ? [
+                        ...prefixes
+                    ].sort() : undefined,
+                    cursor
+                };
+            }
+            const page = matched.slice(start, start + limit);
+            const cursor = start + limit < matched.length ? String(start + limit) : undefined;
+            return {
+                items: page.map((k)=>toStored(k, mustGet(k), mustGet(k).bytes)),
+                cursor
+            };
+        },
+        async url (key) {
+            throw new StorageError('Unsupported', 'memory driver cannot mint URLs');
+        },
+        async signedUploadUrl () {
+            throw new StorageError('Unsupported', 'memory driver cannot presign uploads');
+        },
+        async createMultipartUpload (key, opts) {
+            const uploadId = crypto.randomUUID();
+            const parts = new Map();
+            return {
+                key,
+                uploadId,
+                async uploadPart (partNumber, body) {
+                    const bytes = await toBytes(body);
+                    parts.set(partNumber, bytes);
+                    return {
+                        partNumber,
+                        etag: contentEtag(bytes),
+                        size: bytes.byteLength
+                    };
+                },
+                async complete (uploaded) {
+                    const ordered = [
+                        ...uploaded
+                    ].sort((a, b)=>a.partNumber - b.partNumber).map((p)=>{
+                        const bytes = parts.get(p.partNumber);
+                        if (!bytes) throw new StorageError('InvalidRequest', `missing part ${p.partNumber}`);
+                        return bytes;
+                    });
+                    const all = concatChunks(ordered);
+                    const entry = makeEntry(all, opts);
+                    store.set(key, entry);
+                    return {
+                        key,
+                        size: all.byteLength,
+                        contentType: entry.contentType,
+                        etag: entry.etag,
+                        lastModified: entry.lastModified
+                    };
+                },
+                async abort () {
+                    parts.clear();
+                },
+                async listParts () {
+                    return [
+                        ...parts.entries()
+                    ].sort((a, b)=>a[0] - b[0]).map(([partNumber, bytes])=>({
+                            partNumber,
+                            etag: contentEtag(bytes),
+                            size: bytes.byteLength
+                        }));
+                }
+            };
+        }
+    };
+}