@freqhole/reliquary 0.0.0

package/dist/solid/transfer-progress.test.d.ts.map

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

package/dist/solid/transfer-progress.test.js

@@ -0,0 +1,76 @@
+import { createEffect, createRoot } from "solid-js";
+import { describe, expect, it } from "vitest";
+import { createTransferProgress } from "./transfer-progress.js";
+describe("createTransferProgress", () => {
+    it("starts with an empty map", () => {
+        createRoot((dispose) => {
+            const { states } = createTransferProgress();
+            expect(states().size).toBe(0);
+            dispose();
+        });
+    });
+    it("setState adds a key without replacing untouched entries", () => {
+        createRoot((dispose) => {
+            const { states, setState } = createTransferProgress();
+            setState("a", "downloading");
+            setState("b", "pending");
+            expect(states().get("a")).toBe("downloading");
+            expect(states().get("b")).toBe("pending");
+            expect(states().size).toBe(2);
+            dispose();
+        });
+    });
+    it("setState overwrites an existing key's state", () => {
+        createRoot((dispose) => {
+            const { states, setState } = createTransferProgress();
+            setState("a", "downloading");
+            setState("a", "error");
+            expect(states().get("a")).toBe("error");
+            expect(states().size).toBe(1);
+            dispose();
+        });
+    });
+    it("setState(key, null) removes the key", () => {
+        createRoot((dispose) => {
+            const { states, setState } = createTransferProgress();
+            setState("a", "downloading");
+            setState("a", null);
+            expect(states().has("a")).toBe(false);
+            dispose();
+        });
+    });
+    it("reset clears every tracked key", () => {
+        createRoot((dispose) => {
+            const { states, setState, reset } = createTransferProgress();
+            setState("a", "downloading");
+            setState("b", "pending");
+            reset();
+            expect(states().size).toBe(0);
+            dispose();
+        });
+    });
+    it("an effect reading states() re-runs after each setState call", async () => {
+        let runs = 0;
+        let dispose = () => { };
+        let setState;
+        createRoot((d) => {
+            dispose = d;
+            const progress = createTransferProgress();
+            setState = progress.setState;
+            createEffect(() => {
+                progress.states();
+                runs++;
+            });
+        });
+        // the initial effect run is flushed on the next microtask
+        await Promise.resolve();
+        expect(runs).toBe(1);
+        setState("a", "downloading");
+        await Promise.resolve();
+        expect(runs).toBe(2);
+        setState("a", "error");
+        await Promise.resolve();
+        expect(runs).toBe(3);
+        dispose();
+    });
+});

package/dist/testing/blob-fixtures.d.ts

@@ -0,0 +1,19 @@
+/** default size for content meant to exercise real chunked transfer - a
+ *  few multiples of a 16KiB chunk group, small enough to keep test
+ *  runtime reasonable. */
+export declare const DEFAULT_RANDOM_BLOB_SIZE: number;
+/**
+ * deterministic pseudo-random bytes (mulberry32 PRNG, seeded) -
+ * reproducible across runs (a failing test always fails on the exact
+ * same content, instead of a new random blob every run making failures
+ * harder to correlate/reproduce), but realistic enough (non-repeating, no
+ * long runs of the same byte) to exercise real chunk/BAO-tree code paths
+ * the way genuinely random file content would.
+ */
+export declare function deterministicBytes(sizeBytes: number, seed?: number): Uint8Array;
+/** genuinely random bytes (node `crypto.randomBytes`) - used where
+ *  cross-run reproducibility matters less than being sure there's no
+ *  accidental structure a bug could hide behind (e.g. verifying a
+ *  byte-for-byte disk write independent of any PRNG's own patterns). */
+export declare function randomBlobBytes(sizeBytes?: number): Uint8Array;
+//# sourceMappingURL=blob-fixtures.d.ts.map

package/dist/testing/blob-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob-fixtures.d.ts","sourceRoot":"","sources":["../../src/testing/blob-fixtures.ts"],"names":[],"mappings":"AAcA;;0BAE0B;AAC1B,eAAO,MAAM,wBAAwB,QAAY,CAAC;AAElD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,SAAW,GAAG,UAAU,CAejF;AAED;;;wEAGwE;AACxE,wBAAgB,eAAe,CAAC,SAAS,GAAE,MAAiC,GAAG,UAAU,CAExF"}

package/dist/testing/blob-fixtures.js

@@ -0,0 +1,46 @@
+// test content for blob-transfer coverage, sized to actually exercise
+// chunked/verified transfer instead of false-greening on a tiny payload.
+//
+// a short ascii marker string is enough to prove a hash/transfer
+// round-trips *a* value, but it never exercises anything past a
+// transport's first chunk group (iroh-blobs' BAO tree groups chunks in
+// 16KiB units by default) - every real file a user ever transfers
+// (images, audio, arbitrary files) is orders of magnitude bigger than a
+// short sentence, so a bug that only shows up past the first chunk (a bad
+// chunk-range request, a truncated multi-round download, an off-by-one at
+// a tail chunk) would never be caught by marker-string content alone.
+import { randomBytes as nodeRandomBytes } from "node:crypto";
+/** default size for content meant to exercise real chunked transfer - a
+ *  few multiples of a 16KiB chunk group, small enough to keep test
+ *  runtime reasonable. */
+export const DEFAULT_RANDOM_BLOB_SIZE = 96 * 1024; // 96 KiB
+/**
+ * deterministic pseudo-random bytes (mulberry32 PRNG, seeded) -
+ * reproducible across runs (a failing test always fails on the exact
+ * same content, instead of a new random blob every run making failures
+ * harder to correlate/reproduce), but realistic enough (non-repeating, no
+ * long runs of the same byte) to exercise real chunk/BAO-tree code paths
+ * the way genuinely random file content would.
+ */
+export function deterministicBytes(sizeBytes, seed = 0xc0ffee) {
+    let state = seed >>> 0;
+    const next = () => {
+        state |= 0;
+        state = (state + 0x6d2b79f5) | 0;
+        let t = Math.imul(state ^ (state >>> 15), 1 | state);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+    const bytes = new Uint8Array(sizeBytes);
+    for (let i = 0; i < sizeBytes; i++) {
+        bytes[i] = Math.floor(next() * 256);
+    }
+    return bytes;
+}
+/** genuinely random bytes (node `crypto.randomBytes`) - used where
+ *  cross-run reproducibility matters less than being sure there's no
+ *  accidental structure a bug could hide behind (e.g. verifying a
+ *  byte-for-byte disk write independent of any PRNG's own patterns). */
+export function randomBlobBytes(sizeBytes = DEFAULT_RANDOM_BLOB_SIZE) {
+    return new Uint8Array(nodeRandomBytes(sizeBytes));
+}

package/dist/testing/blob-fixtures.test.d.ts

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

package/dist/testing/blob-fixtures.test.d.ts.map

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

package/dist/testing/blob-fixtures.test.js

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { DEFAULT_RANDOM_BLOB_SIZE, deterministicBytes, randomBlobBytes } from "./blob-fixtures.js";
+describe("deterministicBytes", () => {
+    it("is deterministic across two calls with the same seed", () => {
+        const a = deterministicBytes(256, 42);
+        const b = deterministicBytes(256, 42);
+        expect(a).toEqual(b);
+    });
+    it("produces different content for different seeds", () => {
+        const a = deterministicBytes(256, 1);
+        const b = deterministicBytes(256, 2);
+        expect(a).not.toEqual(b);
+    });
+    it("returns exactly the requested size", () => {
+        expect(deterministicBytes(100).byteLength).toBe(100);
+    });
+    it("does not degenerate into long runs of the same byte", () => {
+        const bytes = deterministicBytes(4096);
+        let longestRun = 0;
+        let currentRun = 1;
+        for (let i = 1; i < bytes.length; i++) {
+            if (bytes[i] === bytes[i - 1]) {
+                currentRun++;
+                longestRun = Math.max(longestRun, currentRun);
+            }
+            else {
+                currentRun = 1;
+            }
+        }
+        expect(longestRun).toBeLessThan(20);
+    });
+});
+describe("randomBlobBytes", () => {
+    it("defaults to DEFAULT_RANDOM_BLOB_SIZE (96 KiB)", () => {
+        expect(DEFAULT_RANDOM_BLOB_SIZE).toBe(96 * 1024);
+        expect(randomBlobBytes().byteLength).toBe(DEFAULT_RANDOM_BLOB_SIZE);
+    });
+    it("returns exactly the requested size", () => {
+        expect(randomBlobBytes(128).byteLength).toBe(128);
+    });
+    it("produces different content across calls", () => {
+        const a = randomBlobBytes(64);
+        const b = randomBlobBytes(64);
+        expect(a).not.toEqual(b);
+    });
+});

package/dist/testing/idb-harness.d.ts

@@ -0,0 +1,10 @@
+import "fake-indexeddb/auto";
+/**
+ * resets `globalThis.indexedDB` to a brand new `IDBFactory`, so every
+ * caller starts from an empty database regardless of what earlier tests
+ * wrote. the `fake-indexeddb/auto` polyfill import above runs once, at
+ * module load time, installing `indexedDB` (and friends) as globals; this
+ * function only needs to swap in a fresh factory per test.
+ */
+export declare function fakeIdbHarness(): void;
+//# sourceMappingURL=idb-harness.d.ts.map

package/dist/testing/idb-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idb-harness.d.ts","sourceRoot":"","sources":["../../src/testing/idb-harness.ts"],"names":[],"mappings":"AAMA,OAAO,qBAAqB,CAAC;AAG7B;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAErC"}

package/dist/testing/idb-harness.js

@@ -0,0 +1,17 @@
+// installs the `fake-indexeddb` global and resets it to a fresh
+// `IDBFactory` - call from a test's `beforeEach` so data doesn't leak
+// across tests through a shared `indexedDB` instance (a real risk: a
+// previous test's records are otherwise still there when the next test's
+// store opens the same database name).
+import "fake-indexeddb/auto";
+import { IDBFactory } from "fake-indexeddb";
+/**
+ * resets `globalThis.indexedDB` to a brand new `IDBFactory`, so every
+ * caller starts from an empty database regardless of what earlier tests
+ * wrote. the `fake-indexeddb/auto` polyfill import above runs once, at
+ * module load time, installing `indexedDB` (and friends) as globals; this
+ * function only needs to swap in a fresh factory per test.
+ */
+export function fakeIdbHarness() {
+    globalThis.indexedDB = new IDBFactory();
+}

package/dist/testing/idb-harness.test.d.ts

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

package/dist/testing/idb-harness.test.d.ts.map

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

package/dist/testing/idb-harness.test.js

@@ -0,0 +1,48 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { fakeIdbHarness } from "./idb-harness.js";
+beforeEach(() => {
+    fakeIdbHarness();
+});
+function openTestDb(name) {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(name, 1);
+        request.onupgradeneeded = () => {
+            request.result.createObjectStore("things", { keyPath: "id" });
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+function putThing(db, thing) {
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction("things", "readwrite");
+        tx.objectStore("things").put(thing);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+function getThing(db, id) {
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction("things", "readonly");
+        const request = tx.objectStore("things").get(id);
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+describe("fakeIdbHarness", () => {
+    it("provides a working indexedDB global", async () => {
+        const db = await openTestDb("harness-test-1");
+        await putThing(db, { id: "a", value: "hello" });
+        await expect(getThing(db, "a")).resolves.toEqual({ id: "a", value: "hello" });
+        db.close();
+    });
+    it("resets to an empty database between calls, even for the same db name", async () => {
+        const db1 = await openTestDb("harness-test-2");
+        await putThing(db1, { id: "a", value: "leftover" });
+        db1.close();
+        fakeIdbHarness();
+        const db2 = await openTestDb("harness-test-2");
+        await expect(getThing(db2, "a")).resolves.toBeUndefined();
+        db2.close();
+    });
+});

package/dist/testing/index.d.ts

@@ -0,0 +1,7 @@
+export { createMockBiStream, createMockMidden, type MockBiStream, type MockMidden } from "./mock-node.js";
+export { CollectingStream, makeServingStream, encodeJsonMessage, decodeJsonMessage, type CollectingStreamOptions, type MakeServingStreamOptions, type ServingStreamEntry, } from "./streams.js";
+export { makeWav, type MakeWavOptions } from "./media.js";
+export { deterministicBytes, randomBlobBytes, DEFAULT_RANDOM_BLOB_SIZE } from "./blob-fixtures.js";
+export { fakeIdbHarness } from "./idb-harness.js";
+export { createMockBlobFetcher, type MockBlobBehaviour, type MockBlobFetcher } from "./mock-blob-fetch.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC1G,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,GACxB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACnG,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1,11 @@
+// exported test utilities: doubles and fixtures consuming apps use in
+// their own suites instead of re-rolling mocks. no restriction on what
+// this subpath imports at runtime (it is only ever imported by test
+// files), but its own exports stay framework-free where practical - none
+// of these doubles need solid-js.
+export { createMockBiStream, createMockMidden } from "./mock-node.js";
+export { CollectingStream, makeServingStream, encodeJsonMessage, decodeJsonMessage, } from "./streams.js";
+export { makeWav } from "./media.js";
+export { deterministicBytes, randomBlobBytes, DEFAULT_RANDOM_BLOB_SIZE } from "./blob-fixtures.js";
+export { fakeIdbHarness } from "./idb-harness.js";
+export { createMockBlobFetcher } from "./mock-blob-fetch.js";

package/dist/testing/media.d.ts

@@ -0,0 +1,15 @@
+export interface MakeWavOptions {
+    /** tone frequency in Hz. ignored when `silent` is true. default 440. */
+    freqHz?: number;
+    /** samples per second. default 8000 - plenty for tests, keeps file size
+     *  (and thus transfer/hash test runtime) small. */
+    sampleRate?: number;
+    /** produce silence instead of a sine tone. */
+    silent?: boolean;
+}
+/**
+ * builds a valid mono 16-bit PCM WAV file. `durationSec` controls both
+ * file size and the decoded duration a real audio element would report.
+ */
+export declare function makeWav(durationSec?: number, options?: MakeWavOptions): Uint8Array;
+//# sourceMappingURL=media.d.ts.map

package/dist/testing/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../src/testing/media.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;uDACmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,WAAW,SAAI,EAAE,OAAO,GAAE,cAAmB,GAAG,UAAU,CA+BjF"}

package/dist/testing/media.js

@@ -0,0 +1,37 @@
+// synthetic audio generation for tests: a valid, decodable mono 16-bit
+// PCM WAV file, either a sine tone (something a test can visibly play/
+// decode) or silence (a minimal stand-in blob when only a valid file
+// format matters, not its content).
+/**
+ * builds a valid mono 16-bit PCM WAV file. `durationSec` controls both
+ * file size and the decoded duration a real audio element would report.
+ */
+export function makeWav(durationSec = 1, options = {}) {
+    const { freqHz = 440, sampleRate = 8000, silent = false } = options;
+    const numSamples = Math.floor(sampleRate * durationSec);
+    const dataSize = numSamples * 2;
+    const buf = new ArrayBuffer(44 + dataSize);
+    const view = new DataView(buf);
+    const writeStr = (offset, s) => {
+        for (let i = 0; i < s.length; i++)
+            view.setUint8(offset + i, s.charCodeAt(i));
+    };
+    writeStr(0, "RIFF");
+    view.setUint32(4, 36 + dataSize, true);
+    writeStr(8, "WAVE");
+    writeStr(12, "fmt ");
+    view.setUint32(16, 16, true); // fmt chunk size
+    view.setUint16(20, 1, true); // PCM
+    view.setUint16(22, 1, true); // mono
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * 2, true); // byte rate
+    view.setUint16(32, 2, true); // block align
+    view.setUint16(34, 16, true); // bits per sample
+    writeStr(36, "data");
+    view.setUint32(40, dataSize, true);
+    for (let i = 0; i < numSamples; i++) {
+        const sample = silent ? 0 : Math.sin((2 * Math.PI * freqHz * i) / sampleRate);
+        view.setInt16(44 + i * 2, Math.floor(sample * 0x4fff), true);
+    }
+    return new Uint8Array(buf);
+}

package/dist/testing/media.test.d.ts

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

package/dist/testing/media.test.d.ts.map

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

package/dist/testing/media.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { makeWav } from "./media.js";
+function readHeader(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const str = (offset, length) => String.fromCharCode(...bytes.subarray(offset, offset + length));
+    return {
+        riff: str(0, 4),
+        wave: str(8, 4),
+        fmt: str(12, 4),
+        audioFormat: view.getUint16(20, true),
+        numChannels: view.getUint16(22, true),
+        sampleRate: view.getUint32(24, true),
+        bitsPerSample: view.getUint16(34, true),
+        data: str(36, 4),
+        dataSize: view.getUint32(40, true),
+    };
+}
+describe("makeWav", () => {
+    it("produces a valid mono 16-bit PCM WAV header", () => {
+        const bytes = makeWav(1);
+        const header = readHeader(bytes);
+        expect(header.riff).toBe("RIFF");
+        expect(header.wave).toBe("WAVE");
+        expect(header.fmt).toBe("fmt ");
+        expect(header.audioFormat).toBe(1); // PCM
+        expect(header.numChannels).toBe(1); // mono
+        expect(header.bitsPerSample).toBe(16);
+        expect(header.data).toBe("data");
+    });
+    it("sizes the file for the requested duration and sample rate", () => {
+        const bytes = makeWav(2, { sampleRate: 8000 });
+        const header = readHeader(bytes);
+        expect(header.sampleRate).toBe(8000);
+        expect(header.dataSize).toBe(2 * 8000 * 2); // 2 bytes/sample
+        expect(bytes.byteLength).toBe(44 + header.dataSize);
+    });
+    it("silent mode produces all-zero sample data", () => {
+        const bytes = makeWav(1, { silent: true, sampleRate: 100 });
+        const samples = bytes.subarray(44);
+        expect(samples.every((b) => b === 0)).toBe(true);
+    });
+    it("non-silent mode produces a non-zero sine tone", () => {
+        const bytes = makeWav(1, { freqHz: 440, sampleRate: 8000 });
+        const samples = bytes.subarray(44);
+        expect(samples.some((b) => b !== 0)).toBe(true);
+    });
+});

package/dist/testing/mock-blob-fetch.d.ts

@@ -0,0 +1,33 @@
+export type MockBlobBehaviour = {
+    type: "instant";
+} | {
+    type: "delayed";
+    ms?: number;
+} | {
+    type: "stall";
+} | {
+    type: "error";
+    message?: string;
+};
+export interface MockBlobFetcher {
+    /** sets (or clears, with `null`) the simulated behaviour for `id`.
+     *  an id with no behaviour set defaults to `{ type: "instant" }`. */
+    setBehaviour(id: string, behaviour: MockBlobBehaviour | null): void;
+    /** simulates fetching `id`: resolves/rejects/stalls according to its
+     *  configured behaviour, then resolves with `resolveBytes(id)`'s
+     *  result. `onProgress` (if given) is called once with `1` right
+     *  before the bytes resolve - this double has no partial-progress
+     *  simulation, only success/failure/stall timing. */
+    fetchBlob(id: string, onProgress?: (fraction: number) => void): Promise<Uint8Array>;
+}
+/**
+ * creates a mock blob fetcher: a per-id behaviour table plus a
+ * `fetchBlob` function that simulates it, generalized off the pattern of
+ * installing a fetch override that a mocked transport consults instead of
+ * making a real network call. the actual bytes returned on success come
+ * from the caller-supplied `resolveBytes` (typically `deterministicBytes`
+ * or `makeWav`) - this helper only controls timing and success/failure,
+ * not payload shape.
+ */
+export declare function createMockBlobFetcher(resolveBytes: (id: string) => Uint8Array | Promise<Uint8Array>): MockBlobFetcher;
+//# sourceMappingURL=mock-blob-fetch.d.ts.map

package/dist/testing/mock-blob-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-blob-fetch.d.ts","sourceRoot":"","sources":["../../src/testing/mock-blob-fetch.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAIxC,MAAM,WAAW,eAAe;IAC9B;yEACqE;IACrE,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,GAAG,IAAI,GAAG,IAAI,CAAC;IACpE;;;;yDAIqD;IACrD,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,eAAe,CA6BrH"}

package/dist/testing/mock-blob-fetch.js

@@ -0,0 +1,39 @@
+// a scriptable stand-in for a blob transport: per-id behaviour (instant
+// success, a delayed success, an unresolved stall, or a hard error) so a
+// test can exercise progress/cancel/retry paths without real network
+// flakiness or timing.
+const DEFAULT_DELAY_MS = 50;
+/**
+ * creates a mock blob fetcher: a per-id behaviour table plus a
+ * `fetchBlob` function that simulates it, generalized off the pattern of
+ * installing a fetch override that a mocked transport consults instead of
+ * making a real network call. the actual bytes returned on success come
+ * from the caller-supplied `resolveBytes` (typically `deterministicBytes`
+ * or `makeWav`) - this helper only controls timing and success/failure,
+ * not payload shape.
+ */
+export function createMockBlobFetcher(resolveBytes) {
+    const behaviours = new Map();
+    function setBehaviour(id, behaviour) {
+        if (behaviour)
+            behaviours.set(id, behaviour);
+        else
+            behaviours.delete(id);
+    }
+    async function fetchBlob(id, onProgress) {
+        const behaviour = behaviours.get(id) ?? { type: "instant" };
+        if (behaviour.type === "error") {
+            throw new Error(behaviour.message ?? `mock blob error: ${id}`);
+        }
+        if (behaviour.type === "stall") {
+            // never resolves - simulates a hung transport for cancel-path tests
+            return new Promise(() => { });
+        }
+        if (behaviour.type === "delayed") {
+            await new Promise((resolve) => setTimeout(resolve, behaviour.ms ?? DEFAULT_DELAY_MS));
+        }
+        onProgress?.(1);
+        return await resolveBytes(id);
+    }
+    return { setBehaviour, fetchBlob };
+}

package/dist/testing/mock-blob-fetch.test.d.ts

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

package/dist/testing/mock-blob-fetch.test.d.ts.map

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

package/dist/testing/mock-blob-fetch.test.js

@@ -0,0 +1,65 @@
+import { describe, expect, it, vi } from "vitest";
+import { createMockBlobFetcher } from "./mock-blob-fetch.js";
+describe("createMockBlobFetcher", () => {
+    it("defaults to instant success, returning the resolver's bytes", async () => {
+        const fetcher = createMockBlobFetcher((id) => new Uint8Array([id.length]));
+        await expect(fetcher.fetchBlob("abc")).resolves.toEqual(new Uint8Array([3]));
+    });
+    it("calls onProgress(1) right before resolving", async () => {
+        const fetcher = createMockBlobFetcher(() => new Uint8Array([1]));
+        const onProgress = vi.fn();
+        await fetcher.fetchBlob("id", onProgress);
+        expect(onProgress).toHaveBeenCalledTimes(1);
+        expect(onProgress).toHaveBeenCalledWith(1);
+    });
+    it("delayed behaviour waits before resolving", async () => {
+        vi.useFakeTimers();
+        try {
+            const fetcher = createMockBlobFetcher(() => new Uint8Array([1]));
+            fetcher.setBehaviour("id", { type: "delayed", ms: 500 });
+            let resolved = false;
+            const promise = fetcher.fetchBlob("id").then((bytes) => {
+                resolved = true;
+                return bytes;
+            });
+            await vi.advanceTimersByTimeAsync(499);
+            expect(resolved).toBe(false);
+            await vi.advanceTimersByTimeAsync(1);
+            await expect(promise).resolves.toEqual(new Uint8Array([1]));
+            expect(resolved).toBe(true);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it("error behaviour rejects with the configured message", async () => {
+        const fetcher = createMockBlobFetcher(() => new Uint8Array([1]));
+        fetcher.setBehaviour("id", { type: "error", message: "boom" });
+        await expect(fetcher.fetchBlob("id")).rejects.toThrow("boom");
+    });
+    it("error behaviour without a message still rejects", async () => {
+        const fetcher = createMockBlobFetcher(() => new Uint8Array([1]));
+        fetcher.setBehaviour("id", { type: "error" });
+        await expect(fetcher.fetchBlob("id")).rejects.toThrow(/mock blob error/);
+    });
+    it("stall behaviour never resolves", async () => {
+        const fetcher = createMockBlobFetcher(() => new Uint8Array([1]));
+        fetcher.setBehaviour("id", { type: "stall" });
+        let settled = false;
+        void fetcher.fetchBlob("id").then(() => (settled = true));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(settled).toBe(false);
+    });
+    it("setBehaviour(id, null) clears an override, reverting to instant", async () => {
+        const fetcher = createMockBlobFetcher(() => new Uint8Array([1]));
+        fetcher.setBehaviour("id", { type: "error" });
+        fetcher.setBehaviour("id", null);
+        await expect(fetcher.fetchBlob("id")).resolves.toEqual(new Uint8Array([1]));
+    });
+    it("behaviour is per-id", async () => {
+        const fetcher = createMockBlobFetcher((id) => new Uint8Array([id.charCodeAt(0)]));
+        fetcher.setBehaviour("a", { type: "error" });
+        await expect(fetcher.fetchBlob("a")).rejects.toThrow();
+        await expect(fetcher.fetchBlob("b")).resolves.toEqual(new Uint8Array(["b".charCodeAt(0)]));
+    });
+});

package/dist/testing/mock-node.d.ts

@@ -0,0 +1,36 @@
+import { vi } from "vitest";
+import type { BiStreamLike, MiddenStreamNode } from "../automerge/types.js";
+/** a `BiStreamLike` double whose queued/pushed messages a test controls
+ *  directly, plus introspection fields (`_written`, `_closed`) for
+ *  asserting on what was sent and whether the stream was closed. */
+export interface MockBiStream extends BiStreamLike {
+    _messageQueue: (Uint8Array | null)[];
+    _written: Uint8Array[];
+    _closed: boolean;
+    _readResolvers: ((value: Uint8Array | null) => void)[];
+    write_message: ReturnType<typeof vi.fn>;
+    read_message: ReturnType<typeof vi.fn>;
+    read_to_end?: ReturnType<typeof vi.fn>;
+    write_raw_and_finish?: ReturnType<typeof vi.fn>;
+    close: ReturnType<typeof vi.fn>;
+    /** push a message (or `null` to simulate the peer closing the stream)
+     *  for the next pending/future `read_message()` call to resolve with. */
+    pushMessage(data: Uint8Array | null): void;
+}
+/** creates a mock bidirectional stream addressed to `peerId`. reads block
+ *  until a message is pushed via `pushMessage`; writes are recorded in
+ *  `_written` for assertions. */
+export declare function createMockBiStream(peerId: string, alpn?: string): MockBiStream;
+/** a `MiddenStreamNode` double whose inbound streams (`accept()`) a test
+ *  pushes by hand, alongside dialing (`open_bi()`) that always succeeds
+ *  with a fresh mock stream. */
+export interface MockMidden extends MiddenStreamNode {
+    open_bi: ReturnType<typeof vi.fn>;
+    accept: ReturnType<typeof vi.fn>;
+    /** push a stream (or `null` to simulate no more inbound connections)
+     *  for the next pending/future `accept()` call to resolve with. */
+    pushIncoming(stream: BiStreamLike | null): void;
+}
+/** creates a mock midden node identified by `nodeId`. */
+export declare function createMockMidden(nodeId?: string): MockMidden;
+//# sourceMappingURL=mock-node.d.ts.map

package/dist/testing/mock-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-node.d.ts","sourceRoot":"","sources":["../../src/testing/mock-node.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAE5B,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE5E;;oEAEoE;AACpE,MAAM,WAAW,YAAa,SAAQ,YAAY;IAChD,aAAa,EAAE,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC;IACrC,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,CAAC,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;IACvD,aAAa,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IACxC,YAAY,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IACvC,oBAAoB,CAAC,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IAChD,KAAK,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IAChC;6EACyE;IACzE,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,CAAC;CAC5C;AAED;;iCAEiC;AACjC,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,MAAgC,GAAG,YAAY,CA0DvG;AAED;;gCAEgC;AAChC,MAAM,WAAW,UAAW,SAAQ,gBAAgB;IAClD,OAAO,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IAClC,MAAM,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IACjC;uEACmE;IACnE,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAAC;CACjD;AAED,yDAAyD;AACzD,wBAAgB,gBAAgB,CAAC,MAAM,GAAE,MAAuB,GAAG,UAAU,CA8B5E"}