@freqhole/reliquary 0.0.0

package/dist/worker/midden-blake3.d.ts

@@ -0,0 +1,23 @@
+/** structural view of the pieces of a midden-shaped module this worker uses. */
+export interface MiddenBlake3Module {
+    hash_blake3?(data: Uint8Array): string;
+    Blake3Hasher?: new () => Blake3HasherLike;
+    opfs_store_selftest?(): Promise<string> | string;
+    opfs_store_selftest_persistence?(): Promise<string> | string;
+}
+/** incremental blake3 hasher, matching the shape midden's wasm bindings expose. */
+export interface Blake3HasherLike {
+    update(chunk: Uint8Array): void;
+    finalize(): string;
+    free(): void;
+}
+/**
+ * dynamically load the embedding app's midden module, if one is bundled.
+ * resolved once and cached; call `resetMiddenBlake3Cache()` to force a
+ * fresh attempt (mainly useful in tests).
+ */
+export declare function loadMiddenBlake3(): Promise<MiddenBlake3Module | null>;
+/** test-only hook: forget the cached resolution so a test can simulate a
+ *  fresh worker environment with midden present or absent. */
+export declare function resetMiddenBlake3Cache(): void;
+//# sourceMappingURL=midden-blake3.d.ts.map

package/dist/worker/midden-blake3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midden-blake3.d.ts","sourceRoot":"","sources":["../../src/worker/midden-blake3.ts"],"names":[],"mappings":"AAyBA,gFAAgF;AAChF,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IACvC,YAAY,CAAC,EAAE,UAAU,gBAAgB,CAAC;IAC1C,mBAAmB,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IACjD,+BAA+B,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CAC9D;AAED,mFAAmF;AACnF,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,QAAQ,IAAI,MAAM,CAAC;IACnB,IAAI,IAAI,IAAI,CAAC;CACd;AAID;;;;GAIG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAW3E;AAED;8DAC8D;AAC9D,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C"}

package/dist/worker/midden-blake3.js

@@ -0,0 +1,47 @@
+// optional blake3 hashing backend for the blob worker.
+//
+// this package does not declare a hard dependency on any specific midden
+// wasm build. blake3 hashing (and the opfs-store selftest hooks used
+// during development) are provided by whatever midden-shaped module the
+// embedding app bundles alongside this worker. the loader below resolves
+// that module dynamically at runtime; every caller degrades gracefully
+// (an empty hash string, or a clearly thrown error where there is no
+// meaningful fallback) when it is not available.
+//
+// the specifier must be a literal string at the `import()` call site, not
+// a variable: bundlers only apply their own alias/resolution config (e.g.
+// vite's `resolve.alias`) to dynamic imports they can statically analyze,
+// and a variable defeats that analysis entirely - the import then falls
+// through to the runtime's native module resolution, which cannot resolve
+// a bare specifier without an import map and fails with "failed to
+// resolve module specifier". `@ts-ignore` (not `@vite-ignore`) is what's
+// needed here: this package never bundles a real "midden" module itself,
+// so typechecking a literal import of it is expected to fail, but the
+// bundler must still see and rewrite the literal specifier.
+import { log } from "../utils/log.js";
+const TAG = "blob.worker.midden";
+let cached;
+/**
+ * dynamically load the embedding app's midden module, if one is bundled.
+ * resolved once and cached; call `resetMiddenBlake3Cache()` to force a
+ * fresh attempt (mainly useful in tests).
+ */
+export async function loadMiddenBlake3() {
+    if (cached !== undefined)
+        return cached;
+    try {
+        // @ts-ignore - this package never bundles a real "midden" module; the
+        // embedding app aliases the literal specifier below to its own build.
+        cached = (await import("midden"));
+    }
+    catch (err) {
+        log.warn(TAG, "midden module failed to load, blake3 hashing will degrade:", err);
+        cached = null;
+    }
+    return cached;
+}
+/** test-only hook: forget the cached resolution so a test can simulate a
+ *  fresh worker environment with midden present or absent. */
+export function resetMiddenBlake3Cache() {
+    cached = undefined;
+}

package/dist/worker/midden-blake3.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=midden-blake3.test.d.ts.map

package/dist/worker/midden-blake3.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midden-blake3.test.d.ts","sourceRoot":"","sources":["../../src/worker/midden-blake3.test.ts"],"names":[],"mappings":""}

package/dist/worker/midden-blake3.test.js

@@ -0,0 +1,25 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { loadMiddenBlake3, resetMiddenBlake3Cache } from "./midden-blake3.js";
+afterEach(() => {
+    resetMiddenBlake3Cache();
+});
+describe("loadMiddenBlake3", () => {
+    it("resolves to null when no midden-shaped module is bundled", async () => {
+        const midden = await loadMiddenBlake3();
+        expect(midden).toBeNull();
+    });
+    it("caches the (null) resolution across calls until reset", async () => {
+        const first = await loadMiddenBlake3();
+        const second = await loadMiddenBlake3();
+        expect(first).toBeNull();
+        expect(second).toBeNull();
+    });
+    it("resetMiddenBlake3Cache() allows a fresh resolution attempt", async () => {
+        await loadMiddenBlake3();
+        resetMiddenBlake3Cache();
+        // this just confirms the reset doesn't throw and a subsequent call
+        // still resolves cleanly (still null - no midden module in this env).
+        const after = await loadMiddenBlake3();
+        expect(after).toBeNull();
+    });
+});

package/dist/worker/midden-not-bundled.stub.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=midden-not-bundled.stub.d.ts.map

package/dist/worker/midden-not-bundled.stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midden-not-bundled.stub.d.ts","sourceRoot":"","sources":["../../src/worker/midden-not-bundled.stub.ts"],"names":[],"mappings":""}

package/dist/worker/midden-not-bundled.stub.js

@@ -0,0 +1,10 @@
+"use strict";
+// test-only stand-in for the "midden" bare specifier that `midden-blake3.ts`
+// dynamically imports. aliased in vitest.config.ts so that import resolves
+// to a real, existing module (satisfying the bundler's static import
+// analysis) instead of failing the transform outright - but this module
+// throws on evaluation, so `loadMiddenBlake3()`'s dynamic import still
+// rejects and is caught the same way it would be in a real embedding app
+// that hasn't aliased "midden" to anything, exercising the genuine
+// "no midden module bundled" degraded-behavior path.
+throw new Error("midden not bundled in this test environment");

package/dist/worker/midden-stub.d.ts

@@ -0,0 +1,10 @@
+export declare class MiddenNode {
+    static create(): Promise<MiddenNode>;
+    static create_from_key(_key: Uint8Array): Promise<MiddenNode>;
+    static create_with_alpns(_key: Uint8Array, _extra_alpns: string[]): Promise<MiddenNode>;
+    node_id(): string;
+    secret_key(): Uint8Array;
+    open_bi(_peer_addr: string, _alpn: string): Promise<never>;
+    accept(): Promise<never>;
+}
+//# sourceMappingURL=midden-stub.d.ts.map

package/dist/worker/midden-stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midden-stub.d.ts","sourceRoot":"","sources":["../../src/worker/midden-stub.ts"],"names":[],"mappings":"AASA,qBAAa,UAAU;WACR,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC;WAI7B,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;WAItD,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAI7F,OAAO,IAAI,MAAM;IAIjB,UAAU,IAAI,UAAU;IAIlB,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAI1D,MAAM,IAAI,OAAO,CAAC,KAAK,CAAC;CAG/B"}

package/dist/worker/midden-stub.js

@@ -0,0 +1,31 @@
+// stub for midden in builds that don't need its wasm module (e.g. a
+// tauri build, where native code handles iroh/blob work instead).
+//
+// this stub exists so a bundler alias for the "midden" module (e.g. vite's
+// `resolve.alias: { midden: "@freqhole/reliquary/worker" }`) resolves to
+// something during dev/build without requiring a real wasm binary. every
+// method throws - callers in a build that aliases to this stub shouldn't
+// be calling it at all.
+export class MiddenNode {
+    static async create() {
+        throw new Error("midden wasm is not available in this build");
+    }
+    static async create_from_key(_key) {
+        throw new Error("midden wasm is not available in this build");
+    }
+    static async create_with_alpns(_key, _extra_alpns) {
+        throw new Error("midden wasm is not available in this build");
+    }
+    node_id() {
+        throw new Error("midden wasm is not available in this build");
+    }
+    secret_key() {
+        throw new Error("midden wasm is not available in this build");
+    }
+    async open_bi(_peer_addr, _alpn) {
+        throw new Error("midden wasm is not available in this build");
+    }
+    async accept() {
+        throw new Error("midden wasm is not available in this build");
+    }
+}

package/dist/worker/midden-stub.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=midden-stub.test.d.ts.map

package/dist/worker/midden-stub.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midden-stub.test.d.ts","sourceRoot":"","sources":["../../src/worker/midden-stub.test.ts"],"names":[],"mappings":""}

package/dist/worker/midden-stub.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { MiddenNode } from "./midden-stub.js";
+// every method on the stub throws - it exists only so a bundler alias for
+// the "midden" module (e.g. in a tauri build with no wasm binary) resolves
+// to something during dev/build. these tests pin down that every method
+// throws a clear, consistent error rather than something more confusing
+// (undefined is not a function, etc.).
+describe("midden stub MiddenNode", () => {
+    it("create() rejects", async () => {
+        await expect(MiddenNode.create()).rejects.toThrow(/midden wasm is not available/);
+    });
+    it("create_from_key() rejects", async () => {
+        await expect(MiddenNode.create_from_key(new Uint8Array(32))).rejects.toThrow(/midden wasm is not available/);
+    });
+    it("create_with_alpns() rejects", async () => {
+        await expect(MiddenNode.create_with_alpns(new Uint8Array(32), ["alpn/1"])).rejects.toThrow(/midden wasm is not available/);
+    });
+    it("instance methods all throw", async () => {
+        const node = Object.create(MiddenNode.prototype);
+        expect(() => node.node_id()).toThrow(/midden wasm is not available/);
+        expect(() => node.secret_key()).toThrow(/midden wasm is not available/);
+        await expect(node.open_bi("peer", "alpn/1")).rejects.toThrow(/midden wasm is not available/);
+        await expect(node.accept()).rejects.toThrow(/midden wasm is not available/);
+    });
+});

package/dist/worker/midden-worker-client.d.ts

@@ -0,0 +1,103 @@
+import * as Comlink from "comlink";
+import { type MiddenWorkerApi, type StreamInfo } from "./midden-worker-contract.js";
+type Api = Comlink.Remote<MiddenWorkerApi>;
+/** main-thread face of a worker-held BiStream. implements BiStreamLike. */
+export declare class WorkerBiStream {
+    private readonly api;
+    private readonly info;
+    constructor(api: Api, info: StreamInfo);
+    peer_node_id(): string;
+    alpn(): string;
+    read_message(): Promise<Uint8Array | null>;
+    write_message(data: Uint8Array): Promise<void>;
+    read_to_end(maxSize: number): Promise<Uint8Array>;
+    write_raw_and_finish(data: Uint8Array): Promise<void>;
+    /** fire-and-forget, matching a wasm BiStream's sync close(). */
+    close(): void;
+}
+/** main-thread face of a worker-held ImportSession. `start_import()` stays
+ *  synchronous (like a wasm ImportSession) by resolving the session id
+ *  lazily. */
+export declare class WorkerImportSession {
+    private readonly api;
+    private readonly sessionId;
+    constructor(api: Api);
+    push(chunk: Uint8Array): Promise<void>;
+    finish(): Promise<string>;
+    abort(): void;
+}
+/**
+ * constructs (or otherwise obtains) the Worker instance hosting the midden
+ * worker entry. this package doesn't own that entry file (see
+ * `midden-worker-contract.ts`), so it can't spawn it via a relative
+ * `new Worker(new URL(...))` the way this subpath's own blob worker does -
+ * the embedding app supplies this, typically:
+ *
+ * ```ts
+ * const node = await WorkerMiddenNode.create(secretKey, () =>
+ *   new Worker(new URL("./midden-worker.js", import.meta.url), { type: "module" })
+ * );
+ * ```
+ */
+export type CreateMiddenWorker = () => Worker;
+/**
+ * main-thread face of a worker-hosted MiddenNode. same snake_case method
+ * names as a wasm node so existing call sites and capability probes
+ * (`typeof node.method === "function"`) keep working.
+ *
+ * sync->async flips vs a wasm node (call sites must be audited/adjusted):
+ * - has_active_blob returns a Promise<boolean> (must be awaited)
+ * - release_blob / restrict_blob_to_peers / clear_blob_restriction return
+ *   promises that fire-and-forget callers may ignore
+ */
+export declare class WorkerMiddenNode {
+    private readonly api;
+    private readonly worker;
+    private readonly nodeId;
+    private readonly secretKey;
+    private constructor();
+    /** spawn the worker (via `createWorker`), wait for the ready handshake,
+     *  create the node. */
+    static create(secretKey: Uint8Array | null, createWorker: CreateMiddenWorker): Promise<WorkerMiddenNode>;
+    /** tear the worker down (identity delete/import). in-flight calls reject. */
+    terminate(): void;
+    node_id(): string;
+    secret_key(): Uint8Array;
+    open_bi(peerAddr: string, alpn: string): Promise<WorkerBiStream>;
+    accept(): Promise<WorkerBiStream | null>;
+    import_blob(data: Uint8Array): Promise<string>;
+    import_blob_and_export_bao(data: Uint8Array): Promise<{
+        hash: string;
+        bao: Uint8Array;
+    }>;
+    import_bao(blake3Hash: string, baoData: Uint8Array): Promise<string>;
+    /** NOTE: async here (sync on a wasm node) - callers must await. */
+    has_active_blob(blake3Hash: string): Promise<boolean>;
+    has_complete_blob(blake3Hash: string): Promise<boolean>;
+    release_blob(blake3Hash: string): Promise<void>;
+    restrict_blob_to_peers(blake3Hash: string, peerNodeIds: string[]): Promise<void>;
+    clear_blob_restriction(blake3Hash: string): Promise<void>;
+    start_import(): WorkerImportSession;
+    ensure_blob(peerAddr: string, blake3Hash: string): Promise<boolean>;
+    download_verified_with_ensure(peerAddr: string, blake3Hash: string): Promise<Uint8Array>;
+    download_verified_with_ensure_progress(peerAddr: string, blake3Hash: string, totalSize: number, onProgress: (fraction: number) => void, downloadId?: string): Promise<Uint8Array>;
+    download_verified_by_id(peerAddr: string, blobId: string): Promise<[Uint8Array, string]>;
+    download_verified_by_id_progress(peerAddr: string, blobId: string, totalSize: number, onProgress: (fraction: number) => void): Promise<[Uint8Array, string]>;
+    download_verified_streaming_with_ensure(peerAddr: string, blake3Hash: string, totalSize: number, onChunk: (chunk: Uint8Array, offset: number) => void, onProgress: (fraction: number) => void, downloadId?: string): Promise<number>;
+    /** pause/cancel an in-flight download by the id passed to the download
+     *  call. returns false when the download already settled. the partial
+     *  stays in the persistent store, pinned against gc - a later download
+     *  of the same hash resumes from the persisted bitfield. */
+    download_cancel(downloadId: string): Promise<boolean>;
+    /** pin a hash against gc (keep a paused partial alive). */
+    protect_blob(blake3Hash: string): Promise<void>;
+    /** remove a gc pin added by protect_blob or a cancelled download. */
+    unprotect_blob(blake3Hash: string): Promise<void>;
+    compute_blake3(peerAddr: string, blobId: string): Promise<string | null>;
+    proxy_request(peerAddr: string, method: string, path: string, body?: string | null): Promise<{
+        status: number;
+        body: string;
+    }>;
+}
+export {};
+//# sourceMappingURL=midden-worker-client.d.ts.map

package/dist/worker/midden-worker-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midden-worker-client.d.ts","sourceRoot":"","sources":["../../src/worker/midden-worker-client.ts"],"names":[],"mappings":"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"}

package/dist/worker/midden-worker-client.js

@@ -0,0 +1,246 @@
+// midden-worker-client - main-thread wrapper around a midden worker entry.
+//
+// see `midden-worker-contract.ts` for the full comlink message-shape
+// contract this file codes against. the entry itself lives with whichever
+// app hosts it (its lifecycle is entangled with that app's own boot and
+// identity wiring) - this facade only knows how to talk to it once it's
+// running, so the caller of `WorkerMiddenNode.create()` supplies a factory
+// that constructs the entry's Worker instance.
+//
+// `WorkerMiddenNode` implements the same snake_case surface as a wasm
+// MiddenNode (MiddenNodeLike / MiddenStreamNode), and `WorkerBiStream` /
+// `WorkerImportSession` reconstruct the stateful objects over the entry's
+// flat id-keyed api. call sites - network adapters, protocol handlers,
+// transfer/blob glue, test bridges - keep working unchanged, except for
+// the documented sync->async flips (`has_active_blob`).
+import * as Comlink from "comlink";
+import { MIDDEN_WORKER_READY_MESSAGE, MIDDEN_WORKER_READY_TIMEOUT_MS, } from "./midden-worker-contract.js";
+import { log } from "../utils/log.js";
+const TAG = "midden.worker";
+/** copy a view to an exact-length buffer and mark it for transfer. the
+ *  copy is required for correctness, not just safety: transferring the
+ *  caller's own buffer would detach it (callers legitimately reuse their
+ *  buffers after a send), and a bare structured clone of a subarray view
+ *  would clone the ENTIRE underlying buffer, not just the view. one exact
+ *  copy + zero-copy transfer is the cheapest correct option. */
+function toTransferable(bytes) {
+    const copy = bytes.slice();
+    return Comlink.transfer(copy, [copy.buffer]);
+}
+/** main-thread face of a worker-held BiStream. implements BiStreamLike. */
+export class WorkerBiStream {
+    api;
+    info;
+    constructor(api, info) {
+        this.api = api;
+        this.info = info;
+    }
+    peer_node_id() {
+        return this.info.peerNodeId;
+    }
+    alpn() {
+        return this.info.alpn;
+    }
+    async read_message() {
+        return this.api.streamReadMessage(this.info.streamId);
+    }
+    async write_message(data) {
+        await this.api.streamWriteMessage(this.info.streamId, toTransferable(data));
+    }
+    async read_to_end(maxSize) {
+        return this.api.streamReadToEnd(this.info.streamId, maxSize);
+    }
+    async write_raw_and_finish(data) {
+        await this.api.streamWriteRawAndFinish(this.info.streamId, toTransferable(data));
+    }
+    /** fire-and-forget, matching a wasm BiStream's sync close(). */
+    close() {
+        this.api.streamClose(this.info.streamId).catch(() => {
+            // worker gone - nothing to close
+        });
+    }
+}
+/** main-thread face of a worker-held ImportSession. `start_import()` stays
+ *  synchronous (like a wasm ImportSession) by resolving the session id
+ *  lazily. */
+export class WorkerImportSession {
+    api;
+    sessionId;
+    constructor(api) {
+        this.api = api;
+        this.sessionId = api.startImport();
+    }
+    async push(chunk) {
+        const id = await this.sessionId;
+        await this.api.importPush(id, toTransferable(chunk));
+    }
+    async finish() {
+        const id = await this.sessionId;
+        return this.api.importFinish(id);
+    }
+    abort() {
+        void this.sessionId.then((id) => this.api.importAbort(id)).catch(() => { });
+    }
+}
+/**
+ * main-thread face of a worker-hosted MiddenNode. same snake_case method
+ * names as a wasm node so existing call sites and capability probes
+ * (`typeof node.method === "function"`) keep working.
+ *
+ * sync->async flips vs a wasm node (call sites must be audited/adjusted):
+ * - has_active_blob returns a Promise<boolean> (must be awaited)
+ * - release_blob / restrict_blob_to_peers / clear_blob_restriction return
+ *   promises that fire-and-forget callers may ignore
+ */
+export class WorkerMiddenNode {
+    api;
+    worker;
+    nodeId;
+    secretKey;
+    constructor(api, worker, nodeId, secretKey) {
+        this.api = api;
+        this.worker = worker;
+        this.nodeId = nodeId;
+        this.secretKey = secretKey;
+    }
+    /** spawn the worker (via `createWorker`), wait for the ready handshake,
+     *  create the node. */
+    static async create(secretKey, createWorker) {
+        const worker = createWorker();
+        const ready = await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                worker.removeEventListener("message", onMessage);
+                worker.removeEventListener("error", onError);
+                log.warn(TAG, `worker did not signal ready within ${MIDDEN_WORKER_READY_TIMEOUT_MS}ms`);
+                resolve(false);
+            }, MIDDEN_WORKER_READY_TIMEOUT_MS);
+            const onMessage = (e) => {
+                if (e.data !== MIDDEN_WORKER_READY_MESSAGE)
+                    return;
+                clearTimeout(timeout);
+                worker.removeEventListener("error", onError);
+                worker.removeEventListener("message", onMessage);
+                resolve(true);
+            };
+            // a worker script that fails to load (network error, blocked by a dev
+            // server's file-serving restrictions, syntax error, etc.) fires an
+            // `error` event, never a `message` - without this listener the promise
+            // above would otherwise sit unresolved for the full ready-timeout with
+            // no indication anything went wrong.
+            const onError = (e) => {
+                clearTimeout(timeout);
+                worker.removeEventListener("message", onMessage);
+                worker.removeEventListener("error", onError);
+                log.warn(TAG, "worker failed to load:", e.message || e);
+                resolve(false);
+            };
+            worker.addEventListener("message", onMessage);
+            worker.addEventListener("error", onError);
+        });
+        if (!ready) {
+            worker.terminate();
+            throw new Error("midden worker did not become ready in time");
+        }
+        const api = Comlink.wrap(worker);
+        try {
+            const identity = await api.init(secretKey);
+            log.debug(TAG, "worker node ready:", identity.nodeId.slice(0, 16) + "...");
+            return new WorkerMiddenNode(api, worker, identity.nodeId, identity.secretKey);
+        }
+        catch (err) {
+            worker.terminate();
+            throw err;
+        }
+    }
+    /** tear the worker down (identity delete/import). in-flight calls reject. */
+    terminate() {
+        this.worker.terminate();
+    }
+    // ---- identity (sync, cached at init) ----
+    node_id() {
+        return this.nodeId;
+    }
+    secret_key() {
+        return this.secretKey;
+    }
+    // ---- streams ----
+    async open_bi(peerAddr, alpn) {
+        return new WorkerBiStream(this.api, await this.api.openBi(peerAddr, alpn));
+    }
+    async accept() {
+        const info = await this.api.accept();
+        if (!info)
+            return null;
+        return new WorkerBiStream(this.api, info);
+    }
+    // ---- blob store ----
+    async import_blob(data) {
+        return this.api.importBlob(toTransferable(data));
+    }
+    async import_blob_and_export_bao(data) {
+        return this.api.importBlobAndExportBao(toTransferable(data));
+    }
+    async import_bao(blake3Hash, baoData) {
+        return this.api.importBao(blake3Hash, toTransferable(baoData));
+    }
+    /** NOTE: async here (sync on a wasm node) - callers must await. */
+    has_active_blob(blake3Hash) {
+        return this.api.hasActiveBlob(blake3Hash);
+    }
+    has_complete_blob(blake3Hash) {
+        return this.api.hasCompleteBlob(blake3Hash);
+    }
+    release_blob(blake3Hash) {
+        return this.api.releaseBlob(blake3Hash);
+    }
+    restrict_blob_to_peers(blake3Hash, peerNodeIds) {
+        return this.api.restrictBlobToPeers(blake3Hash, peerNodeIds);
+    }
+    clear_blob_restriction(blake3Hash) {
+        return this.api.clearBlobRestriction(blake3Hash);
+    }
+    start_import() {
+        return new WorkerImportSession(this.api);
+    }
+    // ---- downloads ----
+    async ensure_blob(peerAddr, blake3Hash) {
+        return this.api.ensureBlob(peerAddr, blake3Hash);
+    }
+    async download_verified_with_ensure(peerAddr, blake3Hash) {
+        return this.api.downloadVerifiedWithEnsure(peerAddr, blake3Hash);
+    }
+    async download_verified_with_ensure_progress(peerAddr, blake3Hash, totalSize, onProgress, downloadId) {
+        return this.api.downloadVerifiedWithEnsureProgress(peerAddr, blake3Hash, totalSize, Comlink.proxy(onProgress), downloadId);
+    }
+    async download_verified_by_id(peerAddr, blobId) {
+        return this.api.downloadVerifiedById(peerAddr, blobId);
+    }
+    async download_verified_by_id_progress(peerAddr, blobId, totalSize, onProgress) {
+        return this.api.downloadVerifiedByIdProgress(peerAddr, blobId, totalSize, Comlink.proxy(onProgress));
+    }
+    async download_verified_streaming_with_ensure(peerAddr, blake3Hash, totalSize, onChunk, onProgress, downloadId) {
+        return this.api.downloadVerifiedStreamingWithEnsure(peerAddr, blake3Hash, totalSize, Comlink.proxy(onChunk), Comlink.proxy(onProgress), downloadId);
+    }
+    /** pause/cancel an in-flight download by the id passed to the download
+     *  call. returns false when the download already settled. the partial
+     *  stays in the persistent store, pinned against gc - a later download
+     *  of the same hash resumes from the persisted bitfield. */
+    async download_cancel(downloadId) {
+        return this.api.downloadCancel(downloadId);
+    }
+    /** pin a hash against gc (keep a paused partial alive). */
+    async protect_blob(blake3Hash) {
+        return this.api.protectBlob(blake3Hash);
+    }
+    /** remove a gc pin added by protect_blob or a cancelled download. */
+    async unprotect_blob(blake3Hash) {
+        return this.api.unprotectBlob(blake3Hash);
+    }
+    async compute_blake3(peerAddr, blobId) {
+        return this.api.computeBlake3(peerAddr, blobId);
+    }
+    // ---- proxy requests ----
+    async proxy_request(peerAddr, method, path, body) {
+        return this.api.proxyRequest(peerAddr, method, path, body ?? null);
+    }
+}

package/dist/worker/midden-worker-client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=midden-worker-client.test.d.ts.map

package/dist/worker/midden-worker-client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midden-worker-client.test.d.ts","sourceRoot":"","sources":["../../src/worker/midden-worker-client.test.ts"],"names":[],"mappings":""}