@nylorun/runtime 0.15.1-beta → 0.16.0-beta

package/dist/blob/fs.js

@@ -0,0 +1,194 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, readdir, rename, rm, stat, unlink } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+import { Readable } from "node:stream";
+import { BlobRangeError, BlobTooLargeError, DEFAULT_CONTENT_TYPE, assertBlobKey, assertBlobPrefix, assertMaxBytes, assertRange, chunksOf, } from "./types.js";
+function isMissing(error) {
+    const code = error?.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+/**
+ * The `fs` adapter: objects as files under `root`, for embedding (`startEphemeralRuntime`, a
+ * Host without an Object store) and tests. `objects/<key>` holds the bytes, `meta/<key>.json`
+ * the content type; a write goes to `tmp/` first and is renamed into place, so a reader sees
+ * the old object or the new one, never part of one. A key cannot also be the directory of
+ * another key (`a` and `a/b`); the Runtime's keys never are.
+ */
+export function createFsBlobStore(options) {
+    const objects = join(options.root, "objects");
+    const metadata = join(options.root, "meta");
+    const tmp = join(options.root, "tmp");
+    const objectPath = (key) => join(objects, ...key.split("/"));
+    const metaPath = (key) => `${join(metadata, ...key.split("/"))}.json`;
+    async function readMeta(key) {
+        try {
+            const parsed = JSON.parse(await readFile(metaPath(key), "utf8"));
+            return { contentType: parsed.contentType ?? DEFAULT_CONTENT_TYPE };
+        }
+        catch {
+            return { contentType: DEFAULT_CONTENT_TYPE };
+        }
+    }
+    async function head(key) {
+        assertBlobKey(key);
+        let stats;
+        try {
+            stats = await stat(objectPath(key));
+        }
+        catch (error) {
+            if (isMissing(error))
+                return undefined;
+            throw error;
+        }
+        if (!stats.isFile())
+            return undefined;
+        const meta = await readMeta(key);
+        return { key, size: stats.size, contentType: meta.contentType, lastModified: stats.mtime };
+    }
+    return {
+        kind: "fs",
+        async put(key, body, put = {}) {
+            assertBlobKey(key);
+            assertMaxBytes(put.maxBytes);
+            put.signal?.throwIfAborted();
+            await mkdir(tmp, { recursive: true });
+            const id = randomUUID();
+            const dataTmp = join(tmp, id);
+            const metaTmp = join(tmp, `${id}.json`);
+            const hash = createHash("sha256");
+            let size = 0;
+            const file = await open(dataTmp, "wx", 0o600);
+            try {
+                try {
+                    for await (const chunk of chunksOf(body)) {
+                        put.signal?.throwIfAborted();
+                        size += chunk.byteLength;
+                        if (put.maxBytes !== undefined && size > put.maxBytes)
+                            throw new BlobTooLargeError(put.maxBytes);
+                        hash.update(chunk);
+                        await file.write(chunk);
+                    }
+                    await file.sync();
+                }
+                finally {
+                    await file.close();
+                }
+                const stored = { contentType: put.contentType ?? DEFAULT_CONTENT_TYPE };
+                await writeTmp(metaTmp, JSON.stringify(stored));
+                await mkdir(dirname(objectPath(key)), { recursive: true });
+                await mkdir(dirname(metaPath(key)), { recursive: true });
+                await rename(metaTmp, metaPath(key));
+                await rename(dataTmp, objectPath(key));
+            }
+            catch (error) {
+                await rm(dataTmp, { force: true });
+                await rm(metaTmp, { force: true });
+                throw error;
+            }
+            return { key, size, sha256: hash.digest("hex") };
+        },
+        async get(key, get = {}) {
+            assertBlobKey(key);
+            if (get.range)
+                assertRange(get.range);
+            get.signal?.throwIfAborted();
+            let file;
+            try {
+                file = await open(objectPath(key), "r");
+            }
+            catch (error) {
+                if (isMissing(error) || error?.code === "EISDIR")
+                    return undefined;
+                throw error;
+            }
+            try {
+                const stats = await file.stat();
+                if (!stats.isFile()) {
+                    await file.close();
+                    return undefined;
+                }
+                const meta = await readMeta(key);
+                const base = {
+                    key,
+                    size: stats.size,
+                    contentType: meta.contentType,
+                    lastModified: stats.mtime,
+                };
+                if (!get.range) {
+                    const stream = file.createReadStream({ autoClose: true });
+                    return { ...base, body: Readable.toWeb(stream) };
+                }
+                if (get.range.start >= stats.size)
+                    throw new BlobRangeError(get.range, stats.size);
+                const end = Math.min(get.range.end ?? stats.size - 1, stats.size - 1);
+                const stream = file.createReadStream({ start: get.range.start, end, autoClose: true });
+                return {
+                    ...base,
+                    body: Readable.toWeb(stream),
+                    range: { start: get.range.start, end },
+                };
+            }
+            catch (error) {
+                await file.close().catch(() => undefined);
+                throw error;
+            }
+        },
+        head,
+        async delete(key) {
+            assertBlobKey(key);
+            for (const path of [objectPath(key), metaPath(key)])
+                try {
+                    await unlink(path);
+                }
+                catch (error) {
+                    const code = error?.code;
+                    if (!isMissing(error) && code !== "EISDIR" && code !== "EPERM")
+                        throw error;
+                }
+        },
+        async *list(prefix) {
+            assertBlobPrefix(prefix);
+            // Walk the deepest directory the prefix names, then filter and sort: `a-b` sorts before
+            // `a/c`, so directory order is not key order.
+            const slash = prefix.lastIndexOf("/");
+            const start = slash < 0 ? objects : join(objects, ...prefix.slice(0, slash).split("/"));
+            const found = [];
+            const walk = async (directory) => {
+                let entries;
+                try {
+                    entries = await readdir(directory, { withFileTypes: true });
+                }
+                catch (error) {
+                    if (isMissing(error))
+                        return;
+                    throw error;
+                }
+                for (const entry of entries) {
+                    const path = join(directory, entry.name);
+                    if (entry.isDirectory())
+                        await walk(path);
+                    else if (entry.isFile()) {
+                        const key = relative(objects, path).split(sep).join("/");
+                        if (!key.startsWith(prefix))
+                            continue;
+                        const stats = await stat(path).catch(() => undefined);
+                        if (stats)
+                            found.push({ key, size: stats.size, lastModified: stats.mtime });
+                    }
+                }
+            };
+            await walk(start);
+            found.sort((left, right) => (left.key < right.key ? -1 : left.key > right.key ? 1 : 0));
+            yield* found;
+        },
+    };
+}
+async function writeTmp(path, text) {
+    const file = await open(path, "wx", 0o600);
+    try {
+        await file.writeFile(text, "utf8");
+    }
+    finally {
+        await file.close();
+    }
+}

package/dist/blob/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The `BlobStore` seam (`./types.ts`) and its adapters. A Host with an Object store
+ * (`StackConfig.objectStore`, from `NYLORUN_OBJECT_STORE_*`) passes an `s3` store to its Tenant
+ * (`TenantOpenHooks.blobs`); without one the Tenant keeps blobs on disk (`fs`, under
+ * `TenantPaths.blobs`). Tenant code reaches it as `TenantContext.blobs`.
+ */
+export * from "./types.js";
+export { createFsBlobStore, type FsBlobStoreOptions } from "./fs.js";
+export { createS3BlobStore, type S3BlobStore, type S3BlobStoreOptions } from "./s3.js";

package/dist/blob/index.js

@@ -0,0 +1,9 @@
+/**
+ * The `BlobStore` seam (`./types.ts`) and its adapters. A Host with an Object store
+ * (`StackConfig.objectStore`, from `NYLORUN_OBJECT_STORE_*`) passes an `s3` store to its Tenant
+ * (`TenantOpenHooks.blobs`); without one the Tenant keeps blobs on disk (`fs`, under
+ * `TenantPaths.blobs`). Tenant code reaches it as `TenantContext.blobs`.
+ */
+export * from "./types.js";
+export { createFsBlobStore } from "./fs.js";
+export { createS3BlobStore } from "./s3.js";

package/dist/blob/s3.d.ts

@@ -0,0 +1,42 @@
+import { type BlobStore } from "./types.js";
+export interface S3BlobStoreOptions {
+    /** The S3 endpoint, e.g. `http://rustfs:9000` or `https://s3.eu-west-1.amazonaws.com`. */
+    endpoint: string;
+    bucket: string;
+    /** The signing region. Default `us-east-1`, which RustFS accepts. */
+    region?: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    /**
+     * Path-style URLs (`<endpoint>/<bucket>/<key>`), which RustFS and most S3 servers expect.
+     * `false` uses virtual-hosted URLs (`<bucket>.<endpoint host>/<key>`). Default `true`.
+     */
+    forcePathStyle?: boolean;
+    /**
+     * A body longer than this is uploaded in parts of about this size (multipart upload); a
+     * shorter one in one request. At least 5 MiB, the S3 minimum. Default 8 MiB.
+     */
+    partSize?: number;
+    /** Attempts for a request that fails with a network error, 429 or 5xx. Default 3. */
+    attempts?: number;
+    /** Replaces the global `fetch` (tests). */
+    fetch?: typeof fetch;
+}
+/** The `s3` adapter, plus the one bucket operation the Runtime needs at boot. */
+export interface S3BlobStore extends BlobStore {
+    readonly kind: "s3";
+    /** Create the bucket unless it exists. The local stack's runtime calls it at boot. */
+    ensureBucket(): Promise<void>;
+}
+/**
+ * The `s3` adapter over the plain S3 API: PutObject, multipart upload, GetObject with Range,
+ * HeadObject, DeleteObject and ListObjectsV2, signed with SigV4 by aws4fetch (MIT, no
+ * dependencies, built on `fetch` and web streams). It uses no server's admin, KMS or lifecycle
+ * API (D35), so RustFS, S3, R2 or any S3 server sits behind it.
+ *
+ * Uploads stream: the body is counted and hashed as it arrives and sent in parts of
+ * `partSize`, so memory stays at about one part whatever the size, and a body that passes
+ * `maxBytes` aborts its multipart upload. Each request carries the SHA-256 of its payload,
+ * which the server checks. Downloads hand back the response's stream.
+ */
+export declare function createS3BlobStore(options: S3BlobStoreOptions): S3BlobStore;

package/dist/blob/s3.js

@@ -0,0 +1,366 @@
+import { createHash } from "node:crypto";
+import { AwsClient } from "aws4fetch";
+import { BlobRangeError, BlobStoreError, BlobTooLargeError, DEFAULT_CONTENT_TYPE, assertBlobKey, assertBlobPrefix, assertMaxBytes, assertRange, chunksOf, } from "./types.js";
+const MIN_PART_SIZE = 5 * 1024 * 1024;
+const DEFAULT_PART_SIZE = 8 * 1024 * 1024;
+function sha256Hex(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function concat(chunks, length) {
+    if (chunks.length === 1)
+        return chunks[0];
+    const out = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return out;
+}
+function decodeXml(text) {
+    return text
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
+        .replace(/&amp;/g, "&");
+}
+function escapeXml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** The text of the first `<name>` element in `xml`, decoded. */
+function tag(xml, name) {
+    const match = new RegExp(`<${name}>([\\s\\S]*?)</${name}>`).exec(xml);
+    return match ? decodeXml(match[1]) : undefined;
+}
+function blocks(xml, name) {
+    return [...xml.matchAll(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`, "g"))].map((m) => m[1]);
+}
+/**
+ * The `s3` adapter over the plain S3 API: PutObject, multipart upload, GetObject with Range,
+ * HeadObject, DeleteObject and ListObjectsV2, signed with SigV4 by aws4fetch (MIT, no
+ * dependencies, built on `fetch` and web streams). It uses no server's admin, KMS or lifecycle
+ * API (D35), so RustFS, S3, R2 or any S3 server sits behind it.
+ *
+ * Uploads stream: the body is counted and hashed as it arrives and sent in parts of
+ * `partSize`, so memory stays at about one part whatever the size, and a body that passes
+ * `maxBytes` aborts its multipart upload. Each request carries the SHA-256 of its payload,
+ * which the server checks. Downloads hand back the response's stream.
+ */
+export function createS3BlobStore(options) {
+    const endpoint = new URL(options.endpoint);
+    if (endpoint.protocol !== "http:" && endpoint.protocol !== "https:")
+        throw new TypeError("The S3 endpoint must be an http or https URL");
+    const base = endpoint.toString().replace(/\/+$/, "");
+    const pathStyle = options.forcePathStyle !== false;
+    const bucketUrl = pathStyle
+        ? `${base}/${options.bucket}`
+        : `${endpoint.protocol}//${options.bucket}.${endpoint.host}${endpoint.pathname.replace(/\/+$/, "")}`;
+    const partSize = Math.max(options.partSize ?? DEFAULT_PART_SIZE, MIN_PART_SIZE);
+    const attempts = Math.max(1, options.attempts ?? 3);
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const client = new AwsClient({
+        accessKeyId: options.accessKeyId,
+        secretAccessKey: options.secretAccessKey,
+        service: "s3",
+        region: options.region ?? "us-east-1",
+        retries: 0,
+    });
+    const objectUrl = (key, query) => {
+        const url = new URL(`${bucketUrl}/${key}`);
+        for (const [name, value] of Object.entries(query ?? {}))
+            url.searchParams.set(name, value);
+        return url.toString();
+    };
+    /** One signed request; retried on a network error, 429 or 5xx unless `once`. */
+    async function send(url, init, once = false) {
+        let lastError;
+        for (let attempt = 1; attempt <= (once ? 1 : attempts); attempt += 1) {
+            try {
+                const response = await fetchImpl(await client.sign(url, init));
+                if ((response.status >= 500 || response.status === 429) && attempt < attempts && !once) {
+                    await response.body?.cancel();
+                    await new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt));
+                    continue;
+                }
+                return response;
+            }
+            catch (error) {
+                if (init.signal?.aborted)
+                    throw error;
+                lastError = error;
+                if (attempt < (once ? 1 : attempts))
+                    await new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt));
+            }
+        }
+        throw new BlobStoreError(`The Object store is unreachable: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+    }
+    async function failure(response, what) {
+        const text = await response.text().catch(() => "");
+        const code = tag(text, "Code");
+        const message = tag(text, "Message");
+        return new BlobStoreError(`${what} failed: ${response.status}${code ? ` ${code}` : ""}${message ? `: ${message}` : ""}`, response.status, code);
+    }
+    /** PUT with the payload's SHA-256, which the server verifies. */
+    const putBytes = (url, bytes, headers, signal) => send(url, {
+        method: "PUT",
+        // fetch sends any ArrayBufferView; the DOM types want one over an ArrayBuffer.
+        body: bytes,
+        headers: { ...headers, "x-amz-content-sha256": sha256Hex(bytes) },
+        ...(signal ? { signal } : {}),
+    });
+    async function head(key) {
+        assertBlobKey(key);
+        const response = await send(objectUrl(key), { method: "HEAD" });
+        if (response.status === 404)
+            return undefined;
+        if (!response.ok)
+            throw await failure(response, `HEAD ${key}`);
+        return metaOf(key, response.headers, Number(response.headers.get("content-length") ?? 0));
+    }
+    function metaOf(key, headers, size) {
+        const modified = headers.get("last-modified");
+        return {
+            key,
+            size,
+            contentType: headers.get("content-type") ?? DEFAULT_CONTENT_TYPE,
+            lastModified: modified ? new Date(modified) : new Date(0),
+        };
+    }
+    async function putMultipart(key, first, rest, state, put) {
+        const signal = put.signal;
+        const created = await send(objectUrl(key, { uploads: "" }), {
+            method: "POST",
+            headers: { "content-type": put.contentType ?? DEFAULT_CONTENT_TYPE },
+            ...(signal ? { signal } : {}),
+        }, true);
+        if (!created.ok)
+            throw await failure(created, `CreateMultipartUpload ${key}`);
+        const uploadId = tag(await created.text(), "UploadId");
+        if (!uploadId)
+            throw new BlobStoreError(`CreateMultipartUpload ${key} returned no UploadId`);
+        const parts = [];
+        const uploadPart = async (bytes) => {
+            const number = parts.length + 1;
+            const response = await putBytes(objectUrl(key, { partNumber: String(number), uploadId }), bytes, {}, signal);
+            if (!response.ok)
+                throw await failure(response, `UploadPart ${number} of ${key}`);
+            await response.body?.cancel();
+            const etag = response.headers.get("etag");
+            if (!etag)
+                throw new BlobStoreError(`UploadPart ${number} of ${key} returned no ETag`);
+            parts.push({ number, etag });
+        };
+        try {
+            await uploadPart(first);
+            let buffered = [];
+            let length = 0;
+            for (;;) {
+                const next = await rest.next();
+                if (next.done)
+                    break;
+                const chunk = next.value;
+                signal?.throwIfAborted();
+                state.size += chunk.byteLength;
+                if (put.maxBytes !== undefined && state.size > put.maxBytes)
+                    throw new BlobTooLargeError(put.maxBytes);
+                state.hash.update(chunk);
+                buffered.push(chunk);
+                length += chunk.byteLength;
+                if (length >= partSize) {
+                    await uploadPart(concat(buffered, length));
+                    buffered = [];
+                    length = 0;
+                }
+            }
+            if (length > 0)
+                await uploadPart(concat(buffered, length));
+            const body = `<CompleteMultipartUpload>${parts
+                .map((part) => `<Part><PartNumber>${part.number}</PartNumber><ETag>${escapeXml(part.etag)}</ETag></Part>`)
+                .join("")}</CompleteMultipartUpload>`;
+            const completed = await send(objectUrl(key, { uploadId }), {
+                method: "POST",
+                body,
+                headers: { "content-type": "application/xml", "x-amz-content-sha256": sha256Hex(new TextEncoder().encode(body)) },
+                ...(signal ? { signal } : {}),
+            }, true);
+            // CompleteMultipartUpload may answer 200 with an error in the body.
+            const text = completed.ok ? await completed.text() : "";
+            if (!completed.ok)
+                throw await failure(completed, `CompleteMultipartUpload ${key}`);
+            if (/<Error>/.test(text))
+                throw new BlobStoreError(`CompleteMultipartUpload ${key} failed: ${tag(text, "Code") ?? "error"}: ${tag(text, "Message") ?? ""}`, completed.status, tag(text, "Code"));
+        }
+        catch (error) {
+            // Best effort: an upload left behind holds only parts, never an object.
+            await send(objectUrl(key, { uploadId }), { method: "DELETE" })
+                .then((response) => response.body?.cancel())
+                .catch(() => undefined);
+            throw error;
+        }
+    }
+    return {
+        kind: "s3",
+        async ensureBucket() {
+            const found = await send(bucketUrl, { method: "HEAD" });
+            if (found.ok)
+                return;
+            if (found.status !== 404)
+                throw await failure(found, `HEAD bucket ${options.bucket}`);
+            const region = options.region ?? "us-east-1";
+            const body = region === "us-east-1"
+                ? undefined
+                : `<CreateBucketConfiguration><LocationConstraint>${escapeXml(region)}</LocationConstraint></CreateBucketConfiguration>`;
+            const created = await send(bucketUrl, {
+                method: "PUT",
+                ...(body
+                    ? {
+                        body,
+                        headers: {
+                            "content-type": "application/xml",
+                            "x-amz-content-sha256": sha256Hex(new TextEncoder().encode(body)),
+                        },
+                    }
+                    : {}),
+            });
+            if (created.ok) {
+                await created.body?.cancel();
+                return;
+            }
+            const error = await failure(created, `CreateBucket ${options.bucket}`);
+            if (error.code === "BucketAlreadyOwnedByYou" || error.code === "BucketAlreadyExists")
+                return;
+            throw error;
+        },
+        async put(key, body, put = {}) {
+            assertBlobKey(key);
+            assertMaxBytes(put.maxBytes);
+            put.signal?.throwIfAborted();
+            const state = { size: 0, hash: createHash("sha256") };
+            const chunks = chunksOf(body)[Symbol.asyncIterator]();
+            // Buffer up to one part: a body that ends first goes in one PutObject.
+            const buffered = [];
+            let length = 0;
+            let ended = false;
+            try {
+                while (length < partSize) {
+                    const next = await chunks.next();
+                    if (next.done) {
+                        ended = true;
+                        break;
+                    }
+                    put.signal?.throwIfAborted();
+                    state.size += next.value.byteLength;
+                    if (put.maxBytes !== undefined && state.size > put.maxBytes)
+                        throw new BlobTooLargeError(put.maxBytes);
+                    state.hash.update(next.value);
+                    buffered.push(next.value);
+                    length += next.value.byteLength;
+                }
+                const first = concat(buffered, length);
+                if (ended) {
+                    const response = await putBytes(objectUrl(key), first, { "content-type": put.contentType ?? DEFAULT_CONTENT_TYPE }, put.signal);
+                    if (!response.ok)
+                        throw await failure(response, `PUT ${key}`);
+                    await response.body?.cancel();
+                }
+                else {
+                    await putMultipart(key, first, chunks, state, put);
+                }
+            }
+            catch (error) {
+                await chunks.return?.(undefined).catch(() => undefined);
+                throw error;
+            }
+            return { key, size: state.size, sha256: state.hash.digest("hex") };
+        },
+        async get(key, get = {}) {
+            assertBlobKey(key);
+            const range = get.range;
+            if (range)
+                assertRange(range);
+            const response = await send(objectUrl(key), {
+                method: "GET",
+                ...(range ? { headers: { range: `bytes=${range.start}-${range.end ?? ""}` } } : {}),
+                ...(get.signal ? { signal: get.signal } : {}),
+            });
+            if (response.status === 404) {
+                await response.body?.cancel();
+                return undefined;
+            }
+            if (response.status === 416 && range) {
+                await response.body?.cancel();
+                const total = /\/(\d+)$/.exec(response.headers.get("content-range") ?? "")?.[1];
+                throw new BlobRangeError(range, total !== undefined ? Number(total) : ((await head(key))?.size ?? 0));
+            }
+            if (!response.ok || !response.body)
+                throw await failure(response, `GET ${key}`);
+            const length = Number(response.headers.get("content-length") ?? 0);
+            if (response.status === 206) {
+                const match = /^bytes (\d+)-(\d+)\/(\d+|\*)$/.exec(response.headers.get("content-range") ?? "");
+                if (!match) {
+                    await response.body.cancel();
+                    throw new BlobStoreError(`GET ${key} answered 206 without a Content-Range`);
+                }
+                const size = match[3] === "*" ? ((await head(key))?.size ?? 0) : Number(match[3]);
+                return {
+                    ...metaOf(key, response.headers, size),
+                    body: response.body,
+                    range: { start: Number(match[1]), end: Number(match[2]) },
+                };
+            }
+            // 200: the whole object. A server that ignores Range sends it all too.
+            const meta = metaOf(key, response.headers, length);
+            if (!range)
+                return { ...meta, body: response.body };
+            if (range.start >= length) {
+                await response.body.cancel();
+                throw new BlobRangeError(range, length);
+            }
+            if (range.start !== 0) {
+                await response.body.cancel();
+                throw new BlobStoreError(`GET ${key} ignored the Range header`);
+            }
+            return { ...meta, body: response.body, range: { start: 0, end: length - 1 } };
+        },
+        head,
+        async delete(key) {
+            assertBlobKey(key);
+            const response = await send(objectUrl(key), { method: "DELETE" });
+            if (response.ok || response.status === 404) {
+                await response.body?.cancel();
+                return;
+            }
+            throw await failure(response, `DELETE ${key}`);
+        },
+        async *list(prefix) {
+            assertBlobPrefix(prefix);
+            let token;
+            do {
+                const url = new URL(bucketUrl);
+                url.searchParams.set("list-type", "2");
+                if (prefix !== "")
+                    url.searchParams.set("prefix", prefix);
+                if (token)
+                    url.searchParams.set("continuation-token", token);
+                const response = await send(url.toString(), { method: "GET" });
+                if (!response.ok)
+                    throw await failure(response, `ListObjectsV2 ${prefix}`);
+                const xml = await response.text();
+                for (const entry of blocks(xml, "Contents")) {
+                    const key = tag(entry, "Key");
+                    if (key === undefined)
+                        continue;
+                    const modified = tag(entry, "LastModified");
+                    yield {
+                        key,
+                        size: Number(tag(entry, "Size") ?? 0),
+                        lastModified: modified ? new Date(modified) : new Date(0),
+                    };
+                }
+                token = tag(xml, "IsTruncated") === "true" ? tag(xml, "NextContinuationToken") : undefined;
+            } while (token);
+        },
+    };
+}