@freqhole/reliquary 0.0.0

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

@@ -0,0 +1,368 @@
+// blob worker logic - the CPU-bound blob work (blake3 hashing, sha256
+// hashing, base64 encode/decode, OPFS writes, thumbnail generation, chunked
+// upload sessions) that `blob-worker.ts` exposes over comlink.
+//
+// kept free of comlink/postMessage side effects on purpose: this module is
+// what the test suite imports directly, and what `blob-worker.ts` (the
+// thin worker entry) and `blob-worker-client.ts` (the main-thread fallback
+// path) both build on.
+//
+// browser-only. blake3 hashing needs a midden-shaped module bundled by the
+// embedding app (see `midden-blake3.ts`) - without one, `hashBlake3`
+// degrades to an empty string and the streaming upload/selftest functions
+// throw a clear error, matching the graceful-degradation contract of the
+// rest of this file.
+import { sha256Hex } from "../utils/hash.js";
+import { loadMiddenBlake3 } from "./midden-blake3.js";
+import { log } from "../utils/log.js";
+const TAG = "blob.worker.logic";
+/** message the worker entry posts once comlink has registered its message
+ *  listener - see `blob-worker.ts` for why the ordering matters. */
+export 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 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 async function hashBlake3(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 "";
+    }
+}
+/**
+ * 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 async function hashSha256(data) {
+    return sha256Hex(data);
+}
+/**
+ * base64-encode an ArrayBuffer. uses chunked btoa to avoid stack overflow
+ * on large buffers (`String.fromCharCode(...veryLargeArray)` blows up).
+ */
+export async function base64Encode(buffer) {
+    const bytes = new Uint8Array(buffer);
+    const chunkSize = 0x8000; // 32 KiB at a time
+    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);
+}
+/**
+ * decode a base64 string into a Uint8Array.
+ */
+export async function base64Decode(b64) {
+    const binary = atob(b64);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        out[i] = binary.charCodeAt(i);
+    }
+    return out;
+}
+// ---- OPFS write path ------------------------------------------------------
+async function getOpfsDir(create = false) {
+    try {
+        const root = await navigator.storage.getDirectory();
+        return await root.getDirectoryHandle(OPFS_DIR, { create });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 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 async function writeBlobToOpfs(blobId, data) {
+    const dir = await getOpfsDir(true);
+    if (!dir)
+        return;
+    const fileHandle = await dir.getFileHandle(blobId, { create: true });
+    // sync access handle: only available in workers, much faster than
+    // createWritable(). uses synchronous I/O on a dedicated I/O thread.
+    const createSync = fileHandle.createSyncAccessHandle;
+    if (typeof createSync === "function") {
+        let handle = null;
+        try {
+            handle = await createSync.call(fileHandle);
+            handle.truncate(0);
+            handle.write(data, { at: 0 });
+            handle.flush();
+        }
+        finally {
+            handle?.close();
+        }
+        return;
+    }
+    // fallback: async writable stream (works on main thread too)
+    const createWritable = fileHandle.createWritable;
+    if (typeof createWritable !== "function")
+        return;
+    const writable = await createWritable.call(fileHandle);
+    await writable.write(data);
+    await writable.close();
+}
+/**
+ * read blob bytes from OPFS into a transferable ArrayBuffer. returns null
+ * if the file doesn't exist or OPFS is unavailable.
+ */
+export async function readBlobFromOpfs(blobId) {
+    const dir = await getOpfsDir(false);
+    if (!dir)
+        return null;
+    try {
+        const fileHandle = await dir.getFileHandle(blobId, { create: false });
+        const file = await fileHandle.getFile();
+        return await file.arrayBuffer();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 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 async function processBlobBytes(data, filename, mime) {
+    // run sha256 and blake3 concurrently. SubtleCrypto.digest does its own
+    // copy of the bytes, so we can't transfer-and-reuse - do them in parallel
+    // and let the runtime overlap them.
+    const [sha256, blake3] = await Promise.all([hashSha256(data), hashBlake3(new Uint8Array(data))]);
+    await writeBlobToOpfs(blake3, data);
+    return {
+        blob_id: blake3,
+        sha256,
+        blake3,
+        size: data.byteLength,
+        mime,
+        filename,
+    };
+}
+/**
+ * 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 async function resizeImageToWebpDataUrl(blob, options) {
+    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 sourceAspect = sw / sh;
+        let outW = sw;
+        let outH = sh;
+        if (outW > maxWidth) {
+            outW = maxWidth;
+            outH = Math.round(outW / sourceAspect);
+        }
+        if (outH > maxHeight) {
+            outH = maxHeight;
+            outW = Math.round(outH * sourceAspect);
+        }
+        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 base64Encode(buf);
+        return `data:${mime};base64,${b64}`;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        bitmap?.close();
+    }
+}
+/**
+ * convenience wrapper that fits an image inside `maxSize` x `maxSize`,
+ * encoding WebP at 0.75 quality. skips non-image blobs.
+ */
+export async function generateThumbnailDataUrl(blob, maxSize = 200) {
+    if (!blob.type.startsWith("image/"))
+        return null;
+    return resizeImageToWebpDataUrl(blob, {
+        maxWidth: maxSize,
+        maxHeight: maxSize,
+        quality: 0.75,
+    });
+}
+const uploadSessions = new Map();
+let nextUploadSessionId = 1;
+/**
+ * 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 async function uploadBegin() {
+    const midden = await loadMiddenBlake3();
+    const Blake3HasherCtor = midden?.Blake3Hasher;
+    if (typeof Blake3HasherCtor !== "function") {
+        throw new Error("streaming upload unavailable: midden Blake3Hasher missing");
+    }
+    const dir = await getOpfsDir(true);
+    if (!dir)
+        throw new Error("streaming upload unavailable: OPFS inaccessible");
+    const id = nextUploadSessionId++;
+    const tmpName = `.upload-${id}-${Date.now()}`;
+    const fileHandle = await dir.getFileHandle(tmpName, { create: true });
+    const createSync = fileHandle.createSyncAccessHandle;
+    if (typeof createSync !== "function") {
+        await dir.removeEntry(tmpName).catch(() => { });
+        throw new Error("streaming upload unavailable: no sync access handle support");
+    }
+    const handle = await createSync.call(fileHandle);
+    handle.truncate(0);
+    uploadSessions.set(id, { handle, tmpName, hasher: new Blake3HasherCtor(), size: 0 });
+    return id;
+}
+/** append the next chunk (transferred buffer) to a session. */
+export async function uploadPush(id, buffer) {
+    const session = uploadSessions.get(id);
+    if (!session)
+        throw new Error(`unknown upload session ${id}`);
+    const bytes = new Uint8Array(buffer);
+    session.hasher.update(bytes);
+    session.handle.write(bytes, { at: session.size });
+    session.size += bytes.byteLength;
+}
+/**
+ * finish a session: flush + close the temp file, then rename it to the
+ * final blake3 content address. returns { blake3, size }.
+ */
+export async function uploadFinish(id) {
+    const session = uploadSessions.get(id);
+    if (!session)
+        throw new Error(`unknown upload session ${id}`);
+    uploadSessions.delete(id);
+    let blake3 = "";
+    try {
+        session.handle.flush();
+        session.handle.close();
+        blake3 = session.hasher.finalize();
+    }
+    finally {
+        session.hasher.free();
+    }
+    const dir = await getOpfsDir(true);
+    if (!dir)
+        throw new Error("OPFS inaccessible at upload finish");
+    const tmpHandle = await dir.getFileHandle(session.tmpName);
+    // dedup: if the content-addressed file already exists, drop the temp copy
+    let exists = false;
+    try {
+        await dir.getFileHandle(blake3, { create: false });
+        exists = true;
+    }
+    catch {
+        // target doesn't exist - rename below
+    }
+    if (exists) {
+        await dir.removeEntry(session.tmpName).catch(() => { });
+        return { blake3, size: session.size };
+    }
+    const move = tmpHandle.move;
+    if (typeof move === "function") {
+        await move.call(tmpHandle, blake3);
+    }
+    else {
+        // rare fallback (no FileSystemFileHandle.move): copy then remove.
+        // buffers once here - still better than failing the upload.
+        const file = await tmpHandle.getFile();
+        await writeBlobToOpfs(blake3, await file.arrayBuffer());
+        await dir.removeEntry(session.tmpName).catch(() => { });
+    }
+    return { blake3, size: session.size };
+}
+/** abort a session: close and delete the temp file. */
+export async function uploadAbort(id) {
+    const session = uploadSessions.get(id);
+    if (!session)
+        return;
+    uploadSessions.delete(id);
+    try {
+        session.handle.close();
+    }
+    catch {
+        // already closed
+    }
+    session.hasher.free();
+    const dir = await getOpfsDir(false);
+    await dir?.removeEntry(session.tmpName).catch(() => { });
+}
+/**
+ * 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 async function opfsStoreSelftest() {
+    const midden = await loadMiddenBlake3();
+    const fn = midden?.opfs_store_selftest;
+    if (typeof fn !== "function") {
+        throw new Error("opfs_store_selftest missing from the bundled midden module");
+    }
+    return fn();
+}
+/**
+ * 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 async function opfsStoreSelftestPersistence() {
+    const midden = await loadMiddenBlake3();
+    const fn = midden?.opfs_store_selftest_persistence;
+    if (typeof fn !== "function") {
+        throw new Error("opfs_store_selftest_persistence missing from the bundled midden module");
+    }
+    return fn();
+}

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

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

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

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

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

@@ -0,0 +1,191 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { base64Decode, base64Encode, generateThumbnailDataUrl, hashBlake3, hashSha256, opfsStoreSelftest, opfsStoreSelftestPersistence, processBlobBytes, readBlobFromOpfs, resizeImageToWebpDataUrl, uploadBegin, writeBlobToOpfs, } from "./blob-worker-logic.js";
+import { resetMiddenBlake3Cache } from "./midden-blake3.js";
+// ---- fake OPFS (async writable-stream fallback path only - sync access
+// handles are worker/chromium-specific and not worth faking here; the
+// fallback path exercises the same directory/file-handle logic). ----
+class FakeWritable {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    async write(data) {
+        this.file.bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer);
+    }
+    async close() { }
+}
+class FakeFileHandle {
+    bytes = new Uint8Array(0);
+    async getFile() {
+        const bytes = this.bytes;
+        return { arrayBuffer: async () => bytes.buffer };
+    }
+    async createWritable() {
+        return new FakeWritable(this);
+    }
+}
+class FakeDirHandle {
+    files = new Map();
+    async getFileHandle(name, opts) {
+        let handle = this.files.get(name);
+        if (!handle) {
+            if (!opts?.create)
+                throw new Error(`not found: ${name}`);
+            handle = new FakeFileHandle();
+            this.files.set(name, handle);
+        }
+        return handle;
+    }
+    async getDirectoryHandle() {
+        return this;
+    }
+}
+function installFakeOpfs() {
+    const root = new FakeDirHandle();
+    vi.stubGlobal("navigator", {
+        storage: {
+            getDirectory: async () => root,
+        },
+    });
+    return root;
+}
+// ---- fake canvas pipeline (same approach as utils/image-utils.test.ts) ----
+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();
+});
+describe("hashSha256", () => {
+    it("hashes a known buffer to its well-known sha-256 digest", async () => {
+        const bytes = new TextEncoder().encode("abc");
+        const hash = await hashSha256(bytes.buffer);
+        expect(hash).toBe("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
+    });
+});
+describe("hashBlake3", () => {
+    it("degrades to an empty string when no midden module is bundled", async () => {
+        const hash = await hashBlake3(new Uint8Array([1, 2, 3]));
+        expect(hash).toBe("");
+    });
+});
+describe("base64Encode / base64Decode", () => {
+    it("round-trips arbitrary bytes", async () => {
+        const original = new Uint8Array([0, 1, 2, 253, 254, 255, 42]);
+        const encoded = await base64Encode(original.buffer);
+        const decoded = await base64Decode(encoded);
+        expect(Array.from(decoded)).toEqual(Array.from(original));
+    });
+    it("handles buffers larger than the chunk size", async () => {
+        const original = new Uint8Array(0x8000 * 3 + 17).map((_, i) => i % 256);
+        const encoded = await base64Encode(original.buffer);
+        const decoded = await base64Decode(encoded);
+        expect(Array.from(decoded)).toEqual(Array.from(original));
+    });
+});
+describe("writeBlobToOpfs / readBlobFromOpfs", () => {
+    it("round-trips bytes through the fake opfs directory", async () => {
+        installFakeOpfs();
+        const data = new Uint8Array([9, 8, 7, 6]).buffer;
+        await writeBlobToOpfs("blake3-hex", data);
+        const readBack = await readBlobFromOpfs("blake3-hex");
+        expect(readBack).not.toBeNull();
+        expect(Array.from(new Uint8Array(readBack))).toEqual([9, 8, 7, 6]);
+    });
+    it("readBlobFromOpfs returns null for a file that was never written", async () => {
+        installFakeOpfs();
+        const result = await readBlobFromOpfs("never-written");
+        expect(result).toBeNull();
+    });
+    it("readBlobFromOpfs returns null when OPFS is unavailable", async () => {
+        vi.stubGlobal("navigator", {});
+        const result = await readBlobFromOpfs("anything");
+        expect(result).toBeNull();
+    });
+    it("writeBlobToOpfs silently no-ops when OPFS is unavailable", async () => {
+        vi.stubGlobal("navigator", {});
+        await expect(writeBlobToOpfs("anything", new ArrayBuffer(4))).resolves.toBeUndefined();
+    });
+});
+describe("processBlobBytes", () => {
+    it("hashes and writes to opfs, returning blake3 as the canonical blob_id", async () => {
+        installFakeOpfs();
+        const bytes = new TextEncoder().encode("hello world");
+        const result = await processBlobBytes(bytes.buffer, "hello.txt", "text/plain");
+        expect(result.filename).toBe("hello.txt");
+        expect(result.mime).toBe("text/plain");
+        expect(result.size).toBe(bytes.byteLength);
+        // no midden module bundled in this test environment - blake3 degrades
+        // to an empty string, and blob_id mirrors it (documented behavior).
+        expect(result.blake3).toBe("");
+        expect(result.blob_id).toBe(result.blake3);
+        expect(result.sha256).toBe("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9");
+    });
+});
+describe("uploadBegin", () => {
+    it("throws a clear error when no midden Blake3Hasher is bundled", async () => {
+        installFakeOpfs();
+        await expect(uploadBegin()).rejects.toThrow(/Blake3Hasher/);
+    });
+});
+describe("opfsStoreSelftest / opfsStoreSelftestPersistence", () => {
+    it("opfsStoreSelftest throws when no midden module is bundled", async () => {
+        await expect(opfsStoreSelftest()).rejects.toThrow(/opfs_store_selftest/);
+    });
+    it("opfsStoreSelftestPersistence throws when no midden module is bundled", async () => {
+        await expect(opfsStoreSelftestPersistence()).rejects.toThrow(/opfs_store_selftest_persistence/);
+    });
+});
+describe("resizeImageToWebpDataUrl", () => {
+    it("returns a data url with the requested mime type", 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 () => {
+        installCanvasFakes();
+        const result = await generateThumbnailDataUrl(new Blob(["x"], { type: "text/plain" }));
+        expect(result).toBeNull();
+    });
+    it("resizes image blobs to a webp data url", async () => {
+        installCanvasFakes();
+        const result = await generateThumbnailDataUrl(new Blob(["x"], { type: "image/png" }));
+        expect(result).toMatch(/^data:image\/webp;base64,/);
+    });
+});

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

@@ -0,0 +1,21 @@
+import { base64Decode, base64Encode, generateThumbnailDataUrl, hashBlake3, hashSha256, opfsStoreSelftest, opfsStoreSelftestPersistence, processBlobBytes, readBlobFromOpfs, resizeImageToWebpDataUrl, uploadAbort, uploadBegin, uploadFinish, uploadPush, writeBlobToOpfs } from "./blob-worker-logic.js";
+declare const api: {
+    hashBlake3: typeof hashBlake3;
+    hashSha256: typeof hashSha256;
+    base64Encode: typeof base64Encode;
+    base64Decode: typeof base64Decode;
+    writeBlobToOpfs: typeof writeBlobToOpfs;
+    readBlobFromOpfs: typeof readBlobFromOpfs;
+    processBlobBytes: typeof processBlobBytes;
+    resizeImageToWebpDataUrl: typeof resizeImageToWebpDataUrl;
+    generateThumbnailDataUrl: typeof generateThumbnailDataUrl;
+    uploadBegin: typeof uploadBegin;
+    uploadPush: typeof uploadPush;
+    uploadFinish: typeof uploadFinish;
+    uploadAbort: typeof uploadAbort;
+    opfsStoreSelftest: typeof opfsStoreSelftest;
+    opfsStoreSelftestPersistence: typeof opfsStoreSelftestPersistence;
+};
+export type BlobWorkerApi = typeof api;
+export {};
+//# sourceMappingURL=blob-worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blob-worker.d.ts","sourceRoot":"","sources":["../../src/worker/blob-worker.ts"],"names":[],"mappings":"AAeA,OAAO,EAEL,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,4BAA4B,EAC5B,gBAAgB,EAChB,gBAAgB,EAChB,wBAAwB,EACxB,WAAW,EACX,WAAW,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAChB,MAAM,wBAAwB,CAAC;AAEhC,QAAA,MAAM,GAAG;;;;;;;;;;;;;;;;CAgBR,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,CAAC"}

package/dist/worker/blob-worker.js

@@ -0,0 +1,44 @@
+// blob worker entry - moves CPU-bound blob work (blake3 hashing, sha256
+// hashing, base64 encode/decode, OPFS writes) off the main thread.
+//
+// architecture: comlink-exposed module. spun up lazily by
+// `blob-worker-client.ts` on first use. shares no state with the main
+// thread other than what's passed across postMessage (with transfer
+// ownership for ArrayBuffers).
+//
+// kept deliberately thin: all the actual logic lives in
+// `blob-worker-logic.ts`, which has no comlink/postMessage side effects
+// and is what the test suite imports directly. this file is the
+// worker-only glue - importing it anywhere other than as a worker script
+// runs `Comlink.expose()` and posts a ready message for no reason.
+import * as Comlink from "comlink";
+import { BLOB_WORKER_READY_MESSAGE, base64Decode, base64Encode, generateThumbnailDataUrl, hashBlake3, hashSha256, opfsStoreSelftest, opfsStoreSelftestPersistence, processBlobBytes, readBlobFromOpfs, resizeImageToWebpDataUrl, uploadAbort, uploadBegin, uploadFinish, uploadPush, writeBlobToOpfs, } from "./blob-worker-logic.js";
+const api = {
+    hashBlake3,
+    hashSha256,
+    base64Encode,
+    base64Decode,
+    writeBlobToOpfs,
+    readBlobFromOpfs,
+    processBlobBytes,
+    resizeImageToWebpDataUrl,
+    generateThumbnailDataUrl,
+    uploadBegin,
+    uploadPush,
+    uploadFinish,
+    uploadAbort,
+    opfsStoreSelftest,
+    opfsStoreSelftestPersistence,
+};
+Comlink.expose(api);
+// signal readiness *after* Comlink has registered its message listener.
+//
+// without this, a Comlink RPC call sent right after `new Worker()` can race
+// the worker's own startup (fetching + instantiating a wasm-backed midden
+// module, when one is bundled, can take a couple of seconds). if the
+// browser dispatches the postMessage'd call before Comlink.expose() above
+// has added its "message" listener, the event fires with no listener
+// attached and is silently dropped forever - the caller's promise never
+// resolves. see `getBlobWorker()` in blob-worker-client.ts, which waits
+// for this signal before handing out the worker proxy.
+postMessage(BLOB_WORKER_READY_MESSAGE);

package/dist/worker/index.d.ts

@@ -0,0 +1,12 @@
+export type { ProcessedBlob, ResizeImageOptions } from "./blob-worker-logic.js";
+export { BLOB_WORKER_READY_MESSAGE, OPFS_DIR as BLOB_OPFS_DIR } from "./blob-worker-logic.js";
+export type { BlobWorkerApi } from "./blob-worker.js";
+export { getBlobWorker, shutdownBlobWorker, hashBlake3, hashSha256, base64Encode, base64Decode, processBlobBytes, writeBlobToOpfs, streamFileToOpfs, resizeImageToWebpDataUrl, generateThumbnailDataUrl, } from "./blob-worker-client.js";
+export type { MiddenWorkerApi, MiddenWorkerIdentity, StreamInfo } from "./midden-worker-contract.js";
+export { MIDDEN_WORKER_READY_MESSAGE, MIDDEN_WORKER_READY_TIMEOUT_MS, } from "./midden-worker-contract.js";
+export type { CreateMiddenWorker } from "./midden-worker-client.js";
+export { WorkerBiStream, WorkerImportSession, WorkerMiddenNode } from "./midden-worker-client.js";
+export { MiddenNode } from "./midden-stub.js";
+export type { Blake3HasherLike, MiddenBlake3Module } from "./midden-blake3.js";
+export { loadMiddenBlake3, resetMiddenBlake3Cache } from "./midden-blake3.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/worker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/worker/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,QAAQ,IAAI,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE9F,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,UAAU,EACV,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACrG,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,GAC/B,MAAM,6BAA6B,CAAC;AAErC,YAAY,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElG,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,YAAY,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/worker/index.js

@@ -0,0 +1,6 @@
+export { BLOB_WORKER_READY_MESSAGE, OPFS_DIR as BLOB_OPFS_DIR } from "./blob-worker-logic.js";
+export { getBlobWorker, shutdownBlobWorker, hashBlake3, hashSha256, base64Encode, base64Decode, processBlobBytes, writeBlobToOpfs, streamFileToOpfs, resizeImageToWebpDataUrl, generateThumbnailDataUrl, } from "./blob-worker-client.js";
+export { MIDDEN_WORKER_READY_MESSAGE, MIDDEN_WORKER_READY_TIMEOUT_MS, } from "./midden-worker-contract.js";
+export { WorkerBiStream, WorkerImportSession, WorkerMiddenNode } from "./midden-worker-client.js";
+export { MiddenNode } from "./midden-stub.js";
+export { loadMiddenBlake3, resetMiddenBlake3Cache } from "./midden-blake3.js";