@freqhole/reliquary 0.0.0

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

@@ -0,0 +1,361 @@
+// blob-worker-client - lazy comlink wrapper around the blob worker.
+//
+// the worker is spun up on first call to `getBlobWorker()` and reused for
+// the lifetime of the page. importing this module costs nothing - the
+// worker bundle is only fetched/instantiated on first use.
+//
+// in environments without Worker support (e.g. SSR / certain test runners)
+// the client falls back to a synchronous in-process implementation so
+// callers don't have to branch.
+import * as Comlink from "comlink";
+import { sha256Hex } from "../utils/hash.js";
+import { loadMiddenBlake3 } from "./midden-blake3.js";
+import { BLOB_WORKER_READY_MESSAGE } from "./blob-worker-logic.js";
+import { log } from "../utils/log.js";
+const TAG = "blob.worker";
+let workerProxy = null;
+let workerInstance = null;
+let workerReadyPromise = null;
+// generous - the worker's top-level module may load a wasm-backed midden
+// module (when the embedding app bundles one) before it can register its
+// Comlink message listener. slow CI runners / cold caches can take a few
+// seconds for this.
+const WORKER_READY_TIMEOUT_MS = 20_000;
+function canSpawnWorker() {
+    return typeof Worker !== "undefined";
+}
+/**
+ * get (and lazily spawn) the comlink-wrapped blob worker proxy.
+ *
+ * returns null if Worker isn't available, or if the worker doesn't signal
+ * readiness within `WORKER_READY_TIMEOUT_MS` - callers should branch and use
+ * a main-thread fallback (every exported helper below already does this).
+ *
+ * waits for an explicit "ready" postMessage from the worker before handing
+ * out the Comlink proxy. this avoids a real race: the worker's module top
+ * level may await a wasm module's instantiation before calling
+ * `Comlink.expose()` (which registers the "message" listener). an RPC call
+ * sent before that listener exists fires with no listener attached and is
+ * silently dropped forever - the caller's promise then never resolves.
+ * waiting for the ready signal (sent immediately after `Comlink.expose()`
+ * in blob-worker.ts) guarantees the listener is registered before any real
+ * RPC call goes out.
+ */
+export async function getBlobWorker() {
+    if (workerProxy)
+        return workerProxy;
+    if (!canSpawnWorker())
+        return null;
+    if (workerReadyPromise)
+        return workerReadyPromise;
+    workerReadyPromise = (async () => {
+        // standard web-platform worker construction: resolves relative to this
+        // module's own compiled location, so it works under vite, webpack 5,
+        // and plain browsers without a bundler-specific import suffix.
+        const worker = new Worker(new URL("./blob-worker.js", import.meta.url), { type: "module" });
+        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 ${WORKER_READY_TIMEOUT_MS}ms`);
+                resolve(false);
+            }, WORKER_READY_TIMEOUT_MS);
+            const onMessage = (e) => {
+                if (e.data !== BLOB_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();
+            // allow a future call to retry (e.g. a one-off slow load) instead of
+            // permanently caching this failure.
+            workerReadyPromise = null;
+            return null;
+        }
+        workerInstance = worker;
+        workerProxy = Comlink.wrap(worker);
+        return workerProxy;
+    })();
+    return workerReadyPromise;
+}
+/**
+ * tear down the worker. mainly useful for tests; production code can leave
+ * the worker alive for the page lifetime.
+ */
+export function shutdownBlobWorker() {
+    if (workerInstance) {
+        workerInstance.terminate();
+        workerInstance = null;
+        workerProxy = null;
+    }
+    workerReadyPromise = null;
+}
+// ---- main-thread fallbacks -----------------------------------------------
+// used when Worker isn't available. these mirror the worker's API exactly
+// so consumers can share a single code path.
+async function fallbackHashBlake3(data) {
+    try {
+        const midden = await loadMiddenBlake3();
+        if (!midden || typeof midden.hash_blake3 !== "function") {
+            log.warn(TAG, "no midden module with hash_blake3 available, blake3 hashing degraded to empty string");
+            return "";
+        }
+        return midden.hash_blake3(data);
+    }
+    catch (err) {
+        log.warn(TAG, "blake3 hashing threw, degrading to empty string:", err);
+        return "";
+    }
+}
+async function fallbackBase64Encode(buffer) {
+    const bytes = new Uint8Array(buffer);
+    const chunkSize = 0x8000;
+    let binary = "";
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        const chunk = bytes.subarray(i, i + chunkSize);
+        binary += String.fromCharCode.apply(null, chunk);
+    }
+    return btoa(binary);
+}
+// ---- convenience helpers --------------------------------------------------
+/**
+ * hash bytes with blake3, preferring the worker. accepts a Uint8Array.
+ * note: this DOES copy across the worker boundary (Uint8Array isn't
+ * transferable directly without giving up the underlying ArrayBuffer);
+ * for upload pipelines, prefer `processBlobBytes` which transfers the
+ * underlying buffer.
+ */
+export async function hashBlake3(data) {
+    const worker = await getBlobWorker();
+    if (worker)
+        return worker.hashBlake3(data);
+    return fallbackHashBlake3(data);
+}
+/**
+ * sha256 hash of an ArrayBuffer.
+ */
+export async function hashSha256(data) {
+    const worker = await getBlobWorker();
+    if (worker)
+        return worker.hashSha256(data);
+    return sha256Hex(data);
+}
+/**
+ * base64-encode an ArrayBuffer.
+ *
+ * NOTE: the buffer is structured-cloned (copied) across the worker
+ * boundary so callers can safely reuse it afterwards. if you have a
+ * dedicated buffer that won't be touched again, you can transfer
+ * ownership manually for a small perf win.
+ */
+export async function base64Encode(buffer) {
+    const worker = await getBlobWorker();
+    if (worker)
+        return worker.base64Encode(buffer);
+    return fallbackBase64Encode(buffer);
+}
+/**
+ * one-shot upload pipeline: hash + write to OPFS in the worker, return
+ * metadata. transfers the buffer.
+ */
+export async function processBlobBytes(buffer, filename, mime) {
+    const worker = await getBlobWorker();
+    if (worker) {
+        return worker.processBlobBytes(Comlink.transfer(buffer, [buffer]), filename, mime);
+    }
+    // main-thread fallback path - rare, mostly for tests.
+    const [sha256, blake3] = await Promise.all([sha256Hex(buffer), fallbackHashBlake3(new Uint8Array(buffer))]);
+    return {
+        blob_id: blake3,
+        sha256,
+        blake3,
+        size: buffer.byteLength,
+        mime,
+        filename,
+    };
+}
+/**
+ * write a blob to OPFS via the worker (uses `FileSystemSyncAccessHandle`
+ * for max throughput).
+ *
+ * NOTE: the buffer is structured-cloned (copied) across the worker
+ * boundary so callers can safely reuse it afterwards - important for
+ * code paths that read or return the buffer after kicking off an OPFS
+ * write (e.g. a snatch/download cache-back-fill). for the upload pipeline
+ * use `processBlobBytes` instead, which transfers.
+ */
+export async function writeBlobToOpfs(blobId, buffer) {
+    const worker = await getBlobWorker();
+    if (worker) {
+        await worker.writeBlobToOpfs(blobId, buffer);
+        return;
+    }
+    // no main-thread fallback - opfs writes from main thread don't have a
+    // sync access handle path anyway. silently no-op.
+}
+/**
+ * stream a File into OPFS via the worker's chunked upload session:
+ * incremental blake3 + incremental sync-access-handle writes, so neither
+ * thread ever holds the whole payload. each chunk buffer is transferred
+ * (zero-copy) across the worker boundary.
+ *
+ * `onProgress` reports bytes pushed / file size (0..1) per chunk.
+ * `signal` cancels between chunks: the worker session is aborted (temp
+ * file cleaned up) and a DOMException AbortError is thrown.
+ *
+ * returns { blake3, size } - the file lands in OPFS under its blake3
+ * content address. throws when streaming isn't available (no worker, no
+ * OPFS sync handles, no midden module bundled); callers should fall back
+ * to the one-shot processBlobBytes path.
+ */
+export async function streamFileToOpfs(file, options) {
+    const worker = await getBlobWorker();
+    if (!worker)
+        throw new Error("streaming upload unavailable: no blob worker");
+    const sessionId = await worker.uploadBegin();
+    const reader = file.stream().getReader();
+    let bytesPushed = 0;
+    try {
+        for (;;) {
+            if (options?.signal?.aborted) {
+                throw new DOMException("upload cancelled", "AbortError");
+            }
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            // chunks are usually freshly-allocated exact buffers, but a view into
+            // a larger buffer is legal - slice to exact bytes before transferring
+            const exact = value.byteOffset === 0 && value.byteLength === value.buffer.byteLength
+                ? value.buffer
+                : value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+            const chunkLen = value.byteLength;
+            await worker.uploadPush(sessionId, Comlink.transfer(exact, [exact]));
+            bytesPushed += chunkLen;
+            if (options?.onProgress && file.size > 0) {
+                options.onProgress(Math.min(1, bytesPushed / file.size));
+            }
+        }
+        return await worker.uploadFinish(sessionId);
+    }
+    catch (err) {
+        await worker.uploadAbort(sessionId).catch(() => { });
+        throw err;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/**
+ * resize an image Blob to a (default WebP) data URL.
+ * prefers the blob worker (keeps the decode/encode work off the main
+ * thread); falls back to a main-thread `OffscreenCanvas` path if the
+ * worker isn't available. returns null on failure (non-image input,
+ * decode failure, etc.).
+ */
+export async function resizeImageToWebpDataUrl(blob, options) {
+    const worker = await getBlobWorker();
+    if (worker)
+        return worker.resizeImageToWebpDataUrl(blob, options);
+    return mainThreadResizeImage(blob, options);
+}
+/**
+ * generate a thumbnail data URL (default 200x200 WebP @ q=0.75) for an
+ * image Blob. delegates to the worker.
+ */
+export async function generateThumbnailDataUrl(blob, maxSize = 200) {
+    if (!blob.type.startsWith("image/"))
+        return null;
+    return resizeImageToWebpDataUrl(blob, {
+        maxWidth: maxSize,
+        maxHeight: maxSize,
+        quality: 0.75,
+    });
+}
+/**
+ * decode a base64 string into a Uint8Array via the worker. for large
+ * payloads (megabyte-scale snatch responses) this avoids blocking the
+ * main thread on a tight `String.charCodeAt` loop.
+ */
+export async function base64Decode(b64) {
+    const worker = await getBlobWorker();
+    if (worker)
+        return worker.base64Decode(b64);
+    // main-thread fallback
+    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;
+}
+// ---- main-thread fallbacks -----------------------------------------------
+async function mainThreadResizeImage(blob, options) {
+    if (typeof OffscreenCanvas === "undefined" || typeof createImageBitmap !== "function") {
+        return null;
+    }
+    const maxWidth = options?.maxWidth ?? 200;
+    const maxHeight = options?.maxHeight ?? 200;
+    const quality = options?.quality ?? 0.8;
+    const cropSquare = options?.cropSquare ?? false;
+    const mime = options?.mime ?? "image/webp";
+    let bitmap = null;
+    try {
+        bitmap = await createImageBitmap(blob);
+        let sx = 0;
+        let sy = 0;
+        let sw = bitmap.width;
+        let sh = bitmap.height;
+        if (cropSquare) {
+            const minDim = Math.min(bitmap.width, bitmap.height);
+            sx = (bitmap.width - minDim) / 2;
+            sy = (bitmap.height - minDim) / 2;
+            sw = minDim;
+            sh = minDim;
+        }
+        const aspect = sw / sh;
+        let outW = sw;
+        let outH = sh;
+        if (outW > maxWidth) {
+            outW = maxWidth;
+            outH = Math.round(outW / aspect);
+        }
+        if (outH > maxHeight) {
+            outH = maxHeight;
+            outW = Math.round(outH * aspect);
+        }
+        outW = Math.max(1, outW);
+        outH = Math.max(1, outH);
+        const canvas = new OffscreenCanvas(outW, outH);
+        const ctx = canvas.getContext("2d");
+        if (!ctx)
+            return null;
+        ctx.drawImage(bitmap, sx, sy, sw, sh, 0, 0, outW, outH);
+        const out = await canvas.convertToBlob({ type: mime, quality });
+        const buf = await out.arrayBuffer();
+        const b64 = await fallbackBase64Encode(buf);
+        return `data:${mime};base64,${b64}`;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        bitmap?.close();
+    }
+}

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

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

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

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

package/dist/worker/blob-worker-client.test.js

@@ -0,0 +1,137 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { base64Decode, base64Encode, generateThumbnailDataUrl, getBlobWorker, hashBlake3, hashSha256, processBlobBytes, resizeImageToWebpDataUrl, shutdownBlobWorker, streamFileToOpfs, writeBlobToOpfs, } from "./blob-worker-client.js";
+import { resetMiddenBlake3Cache } from "./midden-blake3.js";
+import { log } from "../utils/log.js";
+// this test environment has no `Worker` global, so every helper below
+// exercises its main-thread fallback path - the same path used in
+// environments without Worker support (SSR, certain test runners) -
+// except the `getBlobWorker` tests below that explicitly stub in a fake
+// `Worker` to exercise the real ready-handshake logic instead.
+/** minimal fake `Worker`: enough of the `EventTarget`-based message/error
+ *  surface for the ready-handshake tests below, without a real thread. */
+class FakeWorker extends EventTarget {
+    postMessage = vi.fn();
+    terminate = vi.fn();
+}
+class FakeImageBitmap {
+    width;
+    height;
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+    }
+    close = vi.fn();
+}
+class FakeOffscreenCanvasContext {
+    drawImage = vi.fn();
+}
+class FakeOffscreenCanvas {
+    width;
+    height;
+    context = new FakeOffscreenCanvasContext();
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+    }
+    getContext() {
+        return this.context;
+    }
+    async convertToBlob(options) {
+        return new Blob(["fake-encoded-bytes"], { type: options?.type ?? "image/webp" });
+    }
+}
+function installCanvasFakes(size = { width: 100, height: 100 }) {
+    vi.stubGlobal("createImageBitmap", vi.fn(async () => new FakeImageBitmap(size.width, size.height)));
+    vi.stubGlobal("OffscreenCanvas", FakeOffscreenCanvas);
+}
+afterEach(() => {
+    vi.unstubAllGlobals();
+    resetMiddenBlake3Cache();
+    shutdownBlobWorker();
+});
+describe("getBlobWorker", () => {
+    it("returns null when Worker isn't available in this environment", async () => {
+        expect(await getBlobWorker()).toBeNull();
+    });
+    it("resolves once the worker signals ready via a message, without waiting out the timeout", async () => {
+        const worker = new FakeWorker();
+        vi.stubGlobal("Worker", vi.fn(() => worker));
+        const proxyPromise = getBlobWorker();
+        worker.dispatchEvent(new MessageEvent("message", { data: "blob-worker-ready" }));
+        expect(await proxyPromise).not.toBeNull();
+    });
+    it("resolves null quickly (not after the full ready-timeout) when the worker script fails to load, and logs a warning", async () => {
+        vi.useFakeTimers();
+        const warnSpy = vi.spyOn(log, "warn");
+        const worker = new FakeWorker();
+        vi.stubGlobal("Worker", vi.fn(() => worker));
+        const proxyPromise = getBlobWorker();
+        // a worker script that fails to load fires an `error` event, never a
+        // `message` - this must resolve right away, not after the 20s
+        // ready-timeout (proven by asserting the result WITHOUT advancing
+        // fake timers at all).
+        worker.dispatchEvent(new Event("error"));
+        expect(await proxyPromise).toBeNull();
+        expect(warnSpy).toHaveBeenCalled();
+        vi.useRealTimers();
+    });
+});
+describe("hashBlake3", () => {
+    it("falls back to an empty string with no worker and no midden module", async () => {
+        expect(await hashBlake3(new Uint8Array([1, 2, 3]))).toBe("");
+    });
+});
+describe("hashSha256", () => {
+    it("falls back to a real sha-256 digest with no worker", async () => {
+        const bytes = new TextEncoder().encode("abc");
+        const hash = await hashSha256(bytes.buffer);
+        expect(hash).toBe("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
+    });
+});
+describe("base64Encode / base64Decode", () => {
+    it("round-trips bytes through the fallback path", async () => {
+        const original = new Uint8Array([0, 1, 2, 253, 254, 255]);
+        const encoded = await base64Encode(original.buffer);
+        const decoded = await base64Decode(encoded);
+        expect(Array.from(decoded)).toEqual(Array.from(original));
+    });
+});
+describe("processBlobBytes", () => {
+    it("hashes without a worker (blake3 empty, sha256 real)", async () => {
+        const bytes = new TextEncoder().encode("hello world");
+        const result = await processBlobBytes(bytes.buffer, "hello.txt", "text/plain");
+        expect(result.blake3).toBe("");
+        expect(result.blob_id).toBe("");
+        expect(result.sha256).toBe("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9");
+        expect(result.size).toBe(bytes.byteLength);
+    });
+});
+describe("writeBlobToOpfs", () => {
+    it("silently no-ops when there's no worker to delegate to", async () => {
+        await expect(writeBlobToOpfs("some-hash", new ArrayBuffer(4))).resolves.toBeUndefined();
+    });
+});
+describe("streamFileToOpfs", () => {
+    it("throws when no worker is available", async () => {
+        const file = new File(["hello"], "hello.txt", { type: "text/plain" });
+        await expect(streamFileToOpfs(file)).rejects.toThrow(/no blob worker/);
+    });
+});
+describe("resizeImageToWebpDataUrl", () => {
+    it("uses the main-thread fallback and returns a data url", async () => {
+        installCanvasFakes();
+        const result = await resizeImageToWebpDataUrl(new Blob(["x"], { type: "image/png" }));
+        expect(result).toMatch(/^data:image\/webp;base64,/);
+    });
+    it("returns null when OffscreenCanvas/createImageBitmap are unavailable", async () => {
+        const result = await resizeImageToWebpDataUrl(new Blob(["x"], { type: "image/png" }));
+        expect(result).toBeNull();
+    });
+});
+describe("generateThumbnailDataUrl", () => {
+    it("skips non-image blobs", async () => {
+        const result = await generateThumbnailDataUrl(new Blob(["x"], { type: "text/plain" }));
+        expect(result).toBeNull();
+    });
+});

package/dist/worker/blob-worker-logic.d.ts

@@ -0,0 +1,120 @@
+/** message the worker entry posts once comlink has registered its message
+ *  listener - see `blob-worker.ts` for why the ordering matters. */
+export declare const BLOB_WORKER_READY_MESSAGE = "blob-worker-ready";
+/** directory name for the on-disk (OPFS) blob store. exported so callers
+ *  reading bytes back directly (bypassing the worker's write path, e.g.
+ *  `./blobs`'s main-thread OPFS reads) always agree with the worker on
+ *  where the bytes actually live. */
+export declare const OPFS_DIR = "reliquary-blobs";
+/**
+ * compute blake3 hash of a Uint8Array via the embedding app's midden
+ * module. returns an empty string when no such module is bundled, or when
+ * it does not export `hash_blake3`.
+ */
+export declare function hashBlake3(data: Uint8Array): Promise<string>;
+/**
+ * compute sha256 hash via SubtleCrypto. SubtleCrypto.digest is already
+ * async/non-blocking on the main thread, but this is exposed here too so
+ * callers can do sha256 + blake3 in a single round-trip.
+ */
+export declare function hashSha256(data: ArrayBuffer): Promise<string>;
+/**
+ * base64-encode an ArrayBuffer. uses chunked btoa to avoid stack overflow
+ * on large buffers (`String.fromCharCode(...veryLargeArray)` blows up).
+ */
+export declare function base64Encode(buffer: ArrayBuffer): Promise<string>;
+/**
+ * decode a base64 string into a Uint8Array.
+ */
+export declare function base64Decode(b64: string): Promise<Uint8Array>;
+/**
+ * write blob bytes to OPFS. prefers `FileSystemSyncAccessHandle` (worker-only,
+ * fastest path on chromium/safari/firefox) and falls back to the async
+ * writable-stream API. silently no-ops if OPFS is unavailable.
+ *
+ * `data` should be transferred across postMessage to avoid a copy.
+ */
+export declare function writeBlobToOpfs(blobId: string, data: ArrayBuffer): Promise<void>;
+/**
+ * read blob bytes from OPFS into a transferable ArrayBuffer. returns null
+ * if the file doesn't exist or OPFS is unavailable.
+ */
+export declare function readBlobFromOpfs(blobId: string): Promise<ArrayBuffer | null>;
+export interface ProcessedBlob {
+    blob_id: string;
+    sha256: string;
+    blake3: string;
+    size: number;
+    mime: string;
+    filename: string;
+}
+/**
+ * one-shot: hash bytes (sha256 + blake3), write to OPFS, return metadata.
+ * lets callers avoid three round-trips across the worker boundary for an
+ * upload. `data` should be transferred.
+ *
+ * blake3 is the canonical blob id (matches iroh-blobs / a native rust
+ * store); sha256 is still computed so legacy sha256-keyed records and old
+ * doc references keep resolving via the sha256 index.
+ */
+export declare function processBlobBytes(data: ArrayBuffer, filename: string, mime: string): Promise<ProcessedBlob>;
+export interface ResizeImageOptions {
+    /** maximum output width in pixels (default: 200) */
+    maxWidth?: number;
+    /** maximum output height in pixels (default: 200) */
+    maxHeight?: number;
+    /** WebP quality 0..1 (default: 0.8) */
+    quality?: number;
+    /** if true, center-crop to a square before resizing */
+    cropSquare?: boolean;
+    /** output mime type (default: "image/webp") */
+    mime?: string;
+}
+/**
+ * resize an image Blob to a WebP data URL via OffscreenCanvas. all heavy
+ * work (image decode, resize, WebP encode, base64 encode) happens here.
+ * returns null on any failure.
+ *
+ * the input Blob is structured-cloned across postMessage by reference
+ * (the underlying bytes aren't copied), so this is cheap to call.
+ */
+export declare function resizeImageToWebpDataUrl(blob: Blob, options?: ResizeImageOptions): Promise<string | null>;
+/**
+ * convenience wrapper that fits an image inside `maxSize` x `maxSize`,
+ * encoding WebP at 0.75 quality. skips non-image blobs.
+ */
+export declare function generateThumbnailDataUrl(blob: Blob, maxSize?: number): Promise<string | null>;
+/**
+ * begin a streaming upload session. throws when the environment can't
+ * support it (no OPFS sync access handles, or no midden module with a
+ * Blake3Hasher bundled) - callers fall back to the one-shot
+ * processBlobBytes path.
+ */
+export declare function uploadBegin(): Promise<number>;
+/** append the next chunk (transferred buffer) to a session. */
+export declare function uploadPush(id: number, buffer: ArrayBuffer): Promise<void>;
+/**
+ * finish a session: flush + close the temp file, then rename it to the
+ * final blake3 content address. returns { blake3, size }.
+ */
+export declare function uploadFinish(id: number): Promise<{
+    blake3: string;
+    size: number;
+}>;
+/** abort a session: close and delete the temp file. */
+export declare function uploadAbort(id: number): Promise<void>;
+/**
+ * opfs-store selftest - runs the embedding app's midden module's
+ * out-of-crate iroh-blobs store round trip against real OPFS. must run in
+ * a dedicated worker: sync access handles don't exist on the main thread.
+ * throws when no midden module (or no `opfs_store_selftest` export) is
+ * bundled.
+ */
+export declare function opfsStoreSelftest(): Promise<string>;
+/**
+ * persistence selftest - blobs + tags must survive a store shutdown and
+ * reopen over the same OPFS directory (the whole point of the store:
+ * cross-reload resume without re-import). worker context required.
+ */
+export declare function opfsStoreSelftestPersistence(): Promise<string>;
+//# sourceMappingURL=blob-worker-logic.d.ts.map

package/dist/worker/blob-worker-logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob-worker-logic.d.ts","sourceRoot":"","sources":["../../src/worker/blob-worker-logic.ts"],"names":[],"mappings":"AAqBA;oEACoE;AACpE,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAE7D;;;qCAGqC;AACrC,eAAO,MAAM,QAAQ,oBAAoB,CAAC;AAE1C;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAYlE;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAEnE;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CASvE;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAOnE;AAuBD;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAmCtF;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAUlF;AAID,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,CAAC,CAcxB;AAID,MAAM,WAAW,kBAAkB;IACjC,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAuDxB;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,SAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAOhG;AAoBD;;;;;GAKG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAwBnD;AAED,+DAA+D;AAC/D,wBAAsB,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/E;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CA0CxF;AAED,uDAAuD;AACvD,wBAAsB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAY3D;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CAOzD;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,IAAI,OAAO,CAAC,MAAM,CAAC,CAOpE"}