sealkeep 0.8.1 → 0.11.0

package/dist/src/byte-stream.d.ts

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import { type FileHandle } from "node:fs/promises";
+import { Readable } from "node:stream";
+/**
+ * One deliberately small I/O window for archive copies. Providers may keep a
+ * part of their own (normally 8 MiB), but reading a multi-gigabyte file never
+ * creates a buffer proportional to the file.
+ */
+export declare const ARCHIVE_IO_CHUNK_BYTES: number;
+export declare const LEGACY_BUFFER_LIMIT_BYTES: number;
+export declare const MAX_FRAME_METADATA_BYTES: number;
+export type ByteStream = AsyncIterable<Buffer>;
+export type ByteDigest = {
+    bytes: number;
+    sha256Hex: string;
+    sha256Base64: string;
+};
+/**
+ * Applies a token-bucket style ceiling to a byte stream. One normal archive
+ * I/O chunk may leave immediately; sustained transfer then follows the chosen
+ * rate. The source is pulled only after the delay, so provider/file
+ * backpressure propagates all the way upstream instead of buffering ahead.
+ */
+export declare function paceByteStream(chunks: ByteStream, bytesPerSecond: number, options?: {
+    signal?: AbortSignal;
+    burstBytes?: number;
+    now?: () => number;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}): ByteStream;
+/** A connected provider that makes no byte progress is not allowed to hold a
+ * queue lease, index build, or scratch reservation forever. This is an idle
+ * interval, reset after every yielded chunk, rather than a total-size limit. */
+export declare const DEFAULT_REMOTE_READ_IDLE_MS = 60000;
+/**
+ * Opens and consumes a provider stream under one progress watchdog.
+ *
+ * The derived signal reaches the control-plane request, provider fetch, and
+ * body iterator. Promise.race is still intentional: an injected or broken
+ * iterator may ignore AbortSignal, and its caller must nevertheless settle.
+ */
+export declare function byteStreamWithIdleTimeout(openStream: (signal: AbortSignal) => Promise<ByteStream>, options?: {
+    signal?: AbortSignal;
+    idleMs?: number;
+}): ByteStream;
+/** Positional reads let one open descriptor be hashed and then uploaded. */
+export declare function fileHandleChunks(handle: FileHandle, options?: {
+    start?: number;
+    end?: number;
+    chunkBytes?: number;
+    signal?: AbortSignal;
+}): AsyncGenerator<Buffer>;
+/** Opens a file for the lifetime of the iterator and always closes it. */
+export declare function fileChunks(path: string, options?: {
+    start?: number;
+    end?: number;
+    chunkBytes?: number;
+    signal?: AbortSignal;
+}): AsyncGenerator<Buffer>;
+export declare function digestChunks(chunks: ByteStream, onProgress?: (bytes: number) => void): Promise<ByteDigest>;
+export declare function digestFile(path: string, signal?: AbortSignal): Promise<ByteDigest>;
+/**
+ * Writes an iterator without a stream-wide Buffer. The caller chooses the
+ * partial pathname and owns rename/cleanup; fsync makes the later rename a
+ * durability boundary instead of merely a namespace change.
+ */
+export declare function writeChunksToFile(path: string, chunks: ByteStream, options?: {
+    mode?: number;
+    signal?: AbortSignal;
+    exclusive?: boolean;
+    sync?: boolean;
+    expectedBytes?: number;
+    onProgress?: (bytes: number) => void;
+}): Promise<ByteDigest>;
+/** A compatibility door for small injected/test clients; it refuses large files. */
+export declare function collectChunks(chunks: ByteStream, limitBytes?: number, onProgress?: (bytes: number) => void): Promise<Buffer>;
+/** Converts a successful fetch body to the same iterator used for files. */
+export declare function responseBodyChunks(response: Response): AsyncGenerator<Buffer>;
+/** Node fetch needs duplex=half when an iterator is used as a request body. */
+export declare function requestBody(chunks: ByteStream): Readable;
+export declare function concatStreams(streams: Iterable<ByteStream>): AsyncGenerator<Buffer>;
+export declare function oneChunk(chunk: Uint8Array): AsyncGenerator<Buffer>;
+/** Bounded zero-copy views over an already-buffered compatibility object. */
+export declare function bufferChunks(buffer: Buffer, chunkBytes?: number): AsyncGenerator<Buffer>;
+/** Updates a digest while leaving the byte stream otherwise untouched. */
+export declare function tapDigest(chunks: ByteStream, hash: ReturnType<typeof createHash>, onBytes?: (bytes: number) => void): AsyncGenerator<Buffer>;
+/**
+ * Removes the managed VLA1 envelope frame while downloading. Only the small,
+ * explicitly bounded JSON header is retained; ciphertext is yielded as soon
+ * as the header ends. Legacy/plain objects pass through byte-for-byte.
+ */
+export declare function unframeChunks(chunks: ByteStream, magic?: Buffer<ArrayBuffer>, maxMetadataBytes?: number): AsyncGenerator<Buffer>;

package/dist/src/byte-stream.js

@@ -0,0 +1,385 @@
+import { createHash } from "node:crypto";
+import { open } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { fail, SealkeepError } from "./errors.js";
+/**
+ * One deliberately small I/O window for archive copies. Providers may keep a
+ * part of their own (normally 8 MiB), but reading a multi-gigabyte file never
+ * creates a buffer proportional to the file.
+ */
+export const ARCHIVE_IO_CHUNK_BYTES = 1024 * 1024;
+export const LEGACY_BUFFER_LIMIT_BYTES = 64 * 1024 * 1024;
+export const MAX_FRAME_METADATA_BYTES = 16 * 1024 * 1024;
+/**
+ * Applies a token-bucket style ceiling to a byte stream. One normal archive
+ * I/O chunk may leave immediately; sustained transfer then follows the chosen
+ * rate. The source is pulled only after the delay, so provider/file
+ * backpressure propagates all the way upstream instead of buffering ahead.
+ */
+export function paceByteStream(chunks, bytesPerSecond, options = {}) {
+    if (!Number.isFinite(bytesPerSecond) || bytesPerSecond <= 0)
+        throw new Error("Upload byte rate must be positive");
+    const burst = Math.max(0, options.burstBytes ?? ARCHIVE_IO_CHUNK_BYTES);
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? (async (ms, signal) => {
+        signal?.throwIfAborted();
+        await new Promise((resolve, reject) => {
+            let timer;
+            const aborted = () => {
+                if (timer)
+                    clearTimeout(timer);
+                signal?.removeEventListener("abort", aborted);
+                reject(abortError(signal));
+            };
+            timer = setTimeout(() => { signal?.removeEventListener("abort", aborted); resolve(); }, ms);
+            signal?.addEventListener("abort", aborted, { once: true });
+        });
+    });
+    return {
+        async *[Symbol.asyncIterator]() {
+            const started = now();
+            let sent = 0;
+            for await (const chunk of chunks) {
+                options.signal?.throwIfAborted();
+                const charged = Math.max(0, sent + chunk.length - burst);
+                const dueAt = started + charged / bytesPerSecond * 1_000;
+                const delay = dueAt - now();
+                if (delay > 0)
+                    await sleep(delay, options.signal);
+                yield chunk;
+                sent += chunk.length;
+            }
+        },
+    };
+}
+/** A connected provider that makes no byte progress is not allowed to hold a
+ * queue lease, index build, or scratch reservation forever. This is an idle
+ * interval, reset after every yielded chunk, rather than a total-size limit. */
+export const DEFAULT_REMOTE_READ_IDLE_MS = 60_000;
+function remoteReadTimeout(idleMs) {
+    return new SealkeepError("storage_read_timeout", `Stored archive reading made no progress for ${Math.max(1, Math.round(idleMs / 1_000))} seconds. The partial copy was stopped and can be retried safely.`, { retryable: true, idleMs });
+}
+/**
+ * Opens and consumes a provider stream under one progress watchdog.
+ *
+ * The derived signal reaches the control-plane request, provider fetch, and
+ * body iterator. Promise.race is still intentional: an injected or broken
+ * iterator may ignore AbortSignal, and its caller must nevertheless settle.
+ */
+export function byteStreamWithIdleTimeout(openStream, options = {}) {
+    const idleMs = options.idleMs ?? DEFAULT_REMOTE_READ_IDLE_MS;
+    if (!Number.isFinite(idleMs) || idleMs <= 0)
+        throw new Error("Remote archive idle timeout must be positive");
+    return {
+        async *[Symbol.asyncIterator]() {
+            const controller = new AbortController();
+            const abortFromParent = () => controller.abort(options.signal?.reason ?? new DOMException("The archive transfer was cancelled", "AbortError"));
+            if (options.signal?.aborted)
+                abortFromParent();
+            else
+                options.signal?.addEventListener("abort", abortFromParent, { once: true });
+            let timer;
+            let iterator;
+            let complete = false;
+            let idleDeadline = Date.now() + idleMs;
+            const waitForProgress = async (work) => {
+                if (controller.signal.aborted)
+                    throw abortError(controller.signal);
+                let onAbort;
+                timer = setTimeout(() => controller.abort(remoteReadTimeout(idleMs)), Math.max(1, idleDeadline - Date.now()));
+                const aborted = new Promise((_resolve, reject) => {
+                    onAbort = () => reject(abortError(controller.signal));
+                    controller.signal.addEventListener("abort", onAbort, { once: true });
+                });
+                try {
+                    return await Promise.race([work, aborted]);
+                }
+                finally {
+                    if (timer)
+                        clearTimeout(timer);
+                    timer = undefined;
+                    if (onAbort)
+                        controller.signal.removeEventListener("abort", onAbort);
+                }
+            };
+            try {
+                const source = await waitForProgress(openStream(controller.signal));
+                iterator = source[Symbol.asyncIterator]();
+                for (;;) {
+                    const item = await waitForProgress(iterator.next());
+                    if (item.done) {
+                        complete = true;
+                        break;
+                    }
+                    const chunk = Buffer.isBuffer(item.value) ? item.value : Buffer.from(item.value);
+                    // Empty iterator churn is not byte progress and must not keep a job
+                    // alive forever. A positive chunk resets the budget only when the
+                    // consumer asks for the next one, so its own processing time is not
+                    // charged to the provider.
+                    if (chunk.length === 0)
+                        continue;
+                    yield chunk;
+                    idleDeadline = Date.now() + idleMs;
+                }
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+                options.signal?.removeEventListener("abort", abortFromParent);
+                if (!complete) {
+                    if (!controller.signal.aborted)
+                        controller.abort(new DOMException("Archive stream consumer stopped", "AbortError"));
+                    if (iterator?.return) {
+                        try {
+                            void iterator.return().catch(() => undefined);
+                        }
+                        catch { /* a malformed custom iterator cannot replace the primary failure */ }
+                    }
+                }
+            }
+        },
+    };
+}
+function abortError(signal) {
+    if (!signal?.aborted)
+        return null;
+    if (signal.reason instanceof Error)
+        return signal.reason;
+    const error = new Error("The archive transfer was cancelled");
+    error.name = "AbortError";
+    return error;
+}
+/** Positional reads let one open descriptor be hashed and then uploaded. */
+export async function* fileHandleChunks(handle, options = {}) {
+    const chunkBytes = options.chunkBytes ?? ARCHIVE_IO_CHUNK_BYTES;
+    if (!Number.isInteger(chunkBytes) || chunkBytes <= 0)
+        throw new Error("Archive stream chunk size must be a positive integer");
+    let position = options.start ?? 0;
+    const end = options.end ?? Number.POSITIVE_INFINITY;
+    while (position < end) {
+        const cancelled = abortError(options.signal);
+        if (cancelled)
+            throw cancelled;
+        const wanted = Math.min(chunkBytes, end - position);
+        const buffer = Buffer.allocUnsafe(wanted);
+        const { bytesRead } = await handle.read(buffer, 0, wanted, position);
+        if (bytesRead === 0)
+            break;
+        position += bytesRead;
+        yield bytesRead === buffer.length ? buffer : buffer.subarray(0, bytesRead);
+    }
+}
+/** Opens a file for the lifetime of the iterator and always closes it. */
+export async function* fileChunks(path, options = {}) {
+    const handle = await open(path, "r");
+    try {
+        yield* fileHandleChunks(handle, options);
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function digestChunks(chunks, onProgress) {
+    const hash = createHash("sha256");
+    let bytes = 0;
+    for await (const value of chunks) {
+        const chunk = value;
+        hash.update(chunk);
+        bytes += chunk.length;
+        onProgress?.(bytes);
+    }
+    const digest = hash.digest();
+    return { bytes, sha256Hex: digest.toString("hex"), sha256Base64: digest.toString("base64") };
+}
+export async function digestFile(path, signal) {
+    return digestChunks(fileChunks(path, { signal }));
+}
+/**
+ * Writes an iterator without a stream-wide Buffer. The caller chooses the
+ * partial pathname and owns rename/cleanup; fsync makes the later rename a
+ * durability boundary instead of merely a namespace change.
+ */
+export async function writeChunksToFile(path, chunks, options = {}) {
+    if (options.expectedBytes !== undefined
+        && (!Number.isSafeInteger(options.expectedBytes) || options.expectedBytes < 0)) {
+        fail("ciphertext_integrity_failed", "The archive record has no valid exact ciphertext length, so no staging file was opened.", { expectedBytes: options.expectedBytes });
+    }
+    const handle = await open(path, options.exclusive === false ? "w" : "wx", options.mode ?? 0o600);
+    const hash = createHash("sha256");
+    let bytes = 0;
+    const iterator = chunks[Symbol.asyncIterator]();
+    let complete = false;
+    const next = async () => {
+        const cancelled = abortError(options.signal);
+        if (cancelled)
+            throw cancelled;
+        if (!options.signal)
+            return iterator.next();
+        let onAbort;
+        const aborted = new Promise((_resolve, reject) => {
+            onAbort = () => reject(abortError(options.signal));
+            options.signal.addEventListener("abort", onAbort, { once: true });
+        });
+        try {
+            return await Promise.race([iterator.next(), aborted]);
+        }
+        finally {
+            if (onAbort)
+                options.signal.removeEventListener("abort", onAbort);
+        }
+    };
+    try {
+        for (;;) {
+            const item = await next();
+            if (item.done) {
+                complete = true;
+                break;
+            }
+            const cancelled = abortError(options.signal);
+            if (cancelled)
+                throw cancelled;
+            const chunk = item.value;
+            if (options.expectedBytes !== undefined && chunk.length > options.expectedBytes - bytes) {
+                fail("ciphertext_integrity_failed", `The archive source sent more than its recorded ${options.expectedBytes} ciphertext bytes; the excess was refused before it reached disk.`, { expectedBytes: options.expectedBytes, receivedAtLeast: bytes + chunk.length });
+            }
+            hash.update(chunk);
+            bytes += chunk.length;
+            options.onProgress?.(bytes);
+            let written = 0;
+            while (written < chunk.length) {
+                const result = await handle.write(chunk, written, chunk.length - written, null);
+                if (result.bytesWritten <= 0)
+                    throw new Error(`Could not finish writing archive staging file ${path}`);
+                written += result.bytesWritten;
+            }
+        }
+        if (options.expectedBytes !== undefined && bytes !== options.expectedBytes) {
+            fail("ciphertext_integrity_failed", `The archive source ended after ${bytes} ciphertext bytes; its record requires ${options.expectedBytes}.`, { expectedBytes: options.expectedBytes, receivedBytes: bytes });
+        }
+        if (options.sync !== false)
+            await handle.sync();
+    }
+    finally {
+        if (!complete && typeof iterator.return === "function") {
+            // Do not let an iterator that ignored AbortSignal strand the caller too.
+            // Production HTTP streams receive the same signal and cancel promptly;
+            // this best-effort return releases cooperative injected/custom sources.
+            void iterator.return().catch(() => undefined);
+        }
+        await handle.close();
+    }
+    const digest = hash.digest();
+    return { bytes, sha256Hex: digest.toString("hex"), sha256Base64: digest.toString("base64") };
+}
+/** A compatibility door for small injected/test clients; it refuses large files. */
+export async function collectChunks(chunks, limitBytes = LEGACY_BUFFER_LIMIT_BYTES, onProgress) {
+    const held = [];
+    let bytes = 0;
+    for await (const value of chunks) {
+        const chunk = value;
+        bytes += chunk.length;
+        onProgress?.(bytes);
+        if (bytes > limitBytes) {
+            throw new Error(`This client only accepts buffered transfers, and the archive exceeds the ${limitBytes}-byte safety limit`);
+        }
+        held.push(chunk);
+    }
+    return Buffer.concat(held, bytes);
+}
+/** Converts a successful fetch body to the same iterator used for files. */
+export async function* responseBodyChunks(response) {
+    if (!response.body)
+        return;
+    for await (const value of response.body) {
+        yield Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    }
+}
+/** Node fetch needs duplex=half when an iterator is used as a request body. */
+export function requestBody(chunks) {
+    return Readable.from(chunks);
+}
+export async function* concatStreams(streams) {
+    for (const stream of streams)
+        yield* stream;
+}
+export async function* oneChunk(chunk) {
+    yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+}
+/** Bounded zero-copy views over an already-buffered compatibility object. */
+export async function* bufferChunks(buffer, chunkBytes = ARCHIVE_IO_CHUNK_BYTES) {
+    if (!Number.isInteger(chunkBytes) || chunkBytes <= 0)
+        throw new Error("Buffer chunk size must be a positive integer");
+    for (let at = 0; at < buffer.length; at += chunkBytes)
+        yield buffer.subarray(at, Math.min(buffer.length, at + chunkBytes));
+}
+/** Updates a digest while leaving the byte stream otherwise untouched. */
+export async function* tapDigest(chunks, hash, onBytes) {
+    for await (const value of chunks) {
+        const chunk = value;
+        hash.update(chunk);
+        onBytes?.(chunk.length);
+        yield chunk;
+    }
+}
+/**
+ * Removes the managed VLA1 envelope frame while downloading. Only the small,
+ * explicitly bounded JSON header is retained; ciphertext is yielded as soon
+ * as the header ends. Legacy/plain objects pass through byte-for-byte.
+ */
+export async function* unframeChunks(chunks, magic = Buffer.from("VLA1", "ascii"), maxMetadataBytes = MAX_FRAME_METADATA_BYTES) {
+    let decided = false;
+    let framed = false;
+    let metadataBytes = null;
+    let held = [];
+    let heldBytes = 0;
+    for await (const value of chunks) {
+        const chunk = value;
+        if (decided) {
+            yield chunk;
+            continue;
+        }
+        held.push(chunk);
+        heldBytes += chunk.length;
+        if (heldBytes < magic.length)
+            continue;
+        let buffered = Buffer.concat(held, heldBytes);
+        if (!framed) {
+            if (!buffered.subarray(0, magic.length).equals(magic)) {
+                decided = true;
+                yield buffered;
+                held = [];
+                heldBytes = 0;
+                continue;
+            }
+            framed = true;
+        }
+        if (buffered.length < magic.length + 4)
+            continue;
+        metadataBytes ??= buffered.readUInt32BE(magic.length);
+        if (metadataBytes > maxMetadataBytes) {
+            throw new Error(`Managed archive metadata is ${metadataBytes} bytes; the safe limit is ${maxMetadataBytes}`);
+        }
+        const bodyStart = magic.length + 4 + metadataBytes;
+        if (buffered.length < bodyStart)
+            continue;
+        try {
+            JSON.parse(buffered.subarray(magic.length + 4, bodyStart).toString("utf8"));
+        }
+        catch {
+            throw new Error("Managed archive header is not readable JSON");
+        }
+        decided = true;
+        held = [];
+        heldBytes = 0;
+        buffered = buffered.subarray(bodyStart);
+        if (buffered.length > 0)
+            yield buffered;
+    }
+    if (!decided && heldBytes > 0) {
+        const buffered = Buffer.concat(held, heldBytes);
+        if (!framed)
+            yield buffered;
+        else
+            throw new Error("Managed archive header is truncated");
+    }
+}

package/dist/src/chunk-store.d.ts

@@ -1,5 +1,6 @@
-import type { ArchiveRecordV2, RemoteObject } from "./types.js";
-import { type ChunkHeader } from "../packages/vaultline-crypto/src/index.js";
+import { type ArchiveRecordV2, type RemoteObject } from "./types.js";
+import { type ChunkHeader } from "../packages/sealkeep-crypto/src/index.js";
+import type { Recipient } from "../packages/sealkeep-crypto/src/index.js";
 /**
  * Remote layout v2: a session's archive is a FOLDER of chunk objects, not one
  * blob. Paul's shape, and the natural completion of the gzip-chunk format —
@@ -10,7 +11,7 @@ import { type ChunkHeader } from "../packages/vaultline-crypto/src/index.js";
  *
  *   <project>/<YYYY-MM-DD>/<session>.<id8>/
  *       chunk-000000 … chunk-NNNNNN      one 4 MB sealed chunk per object
- *       envelope.vlmeta                  the wrapped-keys envelope
+ *       envelope.skmeta                  the wrapped-keys envelope
  *
  * What the folder buys:
  *  - A PUT per chunk needs no multipart anything: length known, checksum
@@ -38,19 +39,36 @@ import { type ChunkHeader } from "../packages/vaultline-crypto/src/index.js";
  * abandons the folder and restarts under a fresh key.
  */
 export type ChunkStoreClient = {
-    putObject(key: string, body: Buffer): Promise<{
+    putObject(key: string, body: Buffer, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
         checksum: string;
     }>;
-    headObject(key: string): Promise<{
+    headObject(key: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
         exists: boolean;
         bytes: number;
         checksum?: string;
     }>;
-    getObject(key: string): Promise<Buffer>;
+    getObject(key: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<Buffer>;
+    /** Optional production streaming verbs used by large index snapshots. */
+    uploadStream?(key: string, chunks: AsyncIterable<Buffer>, options?: {
+        signal?: AbortSignal;
+        bytes?: number;
+    }): Promise<{
+        remoteChecksum: string | null;
+        bytes: number;
+    }>;
+    getObjectStream?(key: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<AsyncIterable<Buffer>>;
     deleteObject(key: string): Promise<void>;
 };
 export declare const chunkObjectName: (index: number) => string;
-export declare const ENVELOPE_OBJECT = "envelope.vlmeta";
+export declare const ENVELOPE_OBJECT = "envelope.skmeta";
 export type RemoteNaming = "readable" | "hashed";
 /**
  * The key the hashed naming mode HMACs segments under, derived from the
@@ -115,9 +133,16 @@ export type ChunkSealOutcome = {
 export declare function sealToChunkFolder(dataDir: string, sourcePath: string, rawPhrase: string, agent: string, options?: {
     client?: ChunkStoreClient;
     project?: string | null;
+    projectKey?: string | null;
+    teamRecipients?: Recipient[];
     resume?: boolean;
     now?: number;
     targetId?: string;
+    signal?: AbortSignal;
+    chunkBytes?: number;
+    maxBytesPerSecond?: number;
+    /** Internal cooperative scheduler used by unattended/background sealing. */
+    onYield?: () => void | Promise<void>;
 }): Promise<ChunkSealOutcome>;
 /**
  * Seals the readable identity for the sidecar. Its own random nonce — chunk
@@ -128,13 +153,21 @@ export declare function sealToChunkFolder(dataDir: string, sourcePath: string, r
 export type FolderIdentity = {
     v: 1;
     project: string | null;
+    projectKey?: string;
+    projectScope?: string;
     sourcePath: string;
     agent: string;
     createdAt: string;
 };
 /** Opens a sidecar's identity with the unwrapped archive key. */
 export declare function openIdentity(archiveKey: Buffer, archiveId: string, blob: Buffer): FolderIdentity;
-/** Fetches a chunked remote back into one ciphertext buffer, hash-checked per chunk. */
+/** Fetches a chunked remote one bounded object at a time, hash-checking before yield. */
+export declare function fetchChunkFolderStream(client: ChunkStoreClient, remote: RemoteObject, expected: {
+    chunks: ChunkHeader[];
+}, options?: {
+    signal?: AbortSignal;
+}): AsyncGenerator<Buffer>;
+/** Compatibility API for callers that explicitly need the complete Buffer. */
 export declare function fetchChunkFolder(client: ChunkStoreClient, remote: RemoteObject, expected: {
     chunks: ChunkHeader[];
 }): Promise<Buffer>;