@aithos/sdk 0.1.0-alpha.42 → 0.1.0-alpha.44

package/dist/src/react/use-transcribe-pending.d.ts

@@ -0,0 +1,21 @@
+import type { ComputeNamespace, InvokeTranscribeResult, TranscribeProgressState } from "../compute.js";
+import type { LocalPendingEntry } from "../transcribe-resilience.js";
+export interface UseAithosTranscribePendingJobs {
+    /** Locally-tracked in-flight jobs (survives reloads via localStorage). */
+    readonly pending: readonly LocalPendingEntry[];
+    /** Resume polling a job by id; resolves with the final transcript. */
+    readonly resume: (jobId: string, opts?: {
+        readonly mandateId?: string;
+        readonly onProgress?: (state: TranscribeProgressState) => void;
+        readonly signal?: AbortSignal;
+        readonly pollIntervalMs?: number;
+    }) => Promise<InvokeTranscribeResult>;
+}
+/**
+ * Subscribe a React component to the SDK's local pending-transcription
+ * registry. Re-renders whenever a job is added, advances, or clears.
+ *
+ * @param compute the SDK compute namespace (`sdk.compute`).
+ */
+export declare function useAithosTranscribePendingJobs(compute: ComputeNamespace): UseAithosTranscribePendingJobs;
+//# sourceMappingURL=use-transcribe-pending.d.ts.map

package/dist/src/react/use-transcribe-pending.js

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+/**
+ * `useAithosTranscribePendingJobs(sdk.compute)` — a thin React adapter over
+ * the framework-agnostic local pending-jobs tracker exposed by the compute
+ * namespace. The tracker itself (subscribe/getSnapshot) is plain vanilla JS
+ * and works with any framework; this hook just wires it into React's
+ * `useSyncExternalStore`. Vue/Svelte/vanilla users can call
+ * `sdk.compute.subscribeLocalPendingTranscribes` directly.
+ *
+ *     function PendingBanner({ sdk }) {
+ *       const { pending, resume } = useAithosTranscribePendingJobs(sdk.compute);
+ *       if (pending.length === 0) return null;
+ *       return (
+ *         <div>
+ *           {pending.map((p) => (
+ *             <button key={p.jobId} onClick={() => resume(p.jobId)}>
+ *               Resume {p.jobId} ({p.status})
+ *             </button>
+ *           ))}
+ *         </div>
+ *       );
+ *     }
+ */
+import { useCallback, useEffect, useState } from "react";
+/**
+ * Subscribe a React component to the SDK's local pending-transcription
+ * registry. Re-renders whenever a job is added, advances, or clears.
+ *
+ * @param compute the SDK compute namespace (`sdk.compute`).
+ */
+export function useAithosTranscribePendingJobs(compute) {
+    const [pending, setPending] = useState(() => compute.getLocalPendingTranscribesSnapshot());
+    useEffect(() => {
+        // Sync immediately (the snapshot may have changed before mount) then
+        // subscribe. getSnapshot returns a stable reference between mutations,
+        // so identical states bail out of a re-render.
+        setPending(compute.getLocalPendingTranscribesSnapshot());
+        const unsubscribe = compute.subscribeLocalPendingTranscribes(() => {
+            setPending(compute.getLocalPendingTranscribesSnapshot());
+        });
+        return unsubscribe;
+    }, [compute]);
+    const resume = useCallback((jobId, opts) => compute.resumeTranscribe(jobId, opts), [compute]);
+    return { pending, resume };
+}
+//# sourceMappingURL=use-transcribe-pending.js.map

package/dist/src/transcribe-resilience.d.ts

@@ -0,0 +1,57 @@
+export type LocalPendingStatus = "uploading" | "running" | "completed" | "failed";
+export interface LocalPendingEntry {
+    readonly jobId: string;
+    readonly status: LocalPendingStatus;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly meta?: Record<string, unknown>;
+}
+/**
+ * Framework-agnostic observable registry of in-flight transcription jobs.
+ * Persisted to localStorage when available (so it survives reloads), with
+ * an in-memory fallback otherwise. Subscribe with `subscribe(listener)`;
+ * read with `getSnapshot()` (stable reference between mutations, so it
+ * plugs directly into React's `useSyncExternalStore`).
+ */
+export declare class LocalPendingTranscribeTracker {
+    #private;
+    constructor();
+    /** Current entries. Stable reference until the next mutation. */
+    getSnapshot(): readonly LocalPendingEntry[];
+    list(): readonly LocalPendingEntry[];
+    /** Subscribe to changes. Returns an unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    upsert(jobId: string, status: LocalPendingStatus, meta?: Record<string, unknown>): void;
+    remove(jobId: string): void;
+    clear(): void;
+}
+export interface TranscribeDraftMeta {
+    readonly title?: string;
+    readonly tag?: string;
+    readonly contentType?: string;
+}
+export interface TranscribeDraftRecord {
+    readonly draftId: string;
+    readonly blob: Blob;
+    readonly metadata: TranscribeDraftMeta;
+    readonly createdAt: number;
+}
+export declare class TranscribeDraftUnavailableError extends Error {
+    constructor();
+}
+/**
+ * IndexedDB-backed queue of recorded audio Blobs. Save a recording the
+ * instant it finishes (before any network), then `upload` it when the
+ * user confirms — so a flaky network or a closed tab never loses audio.
+ * Browser-only: methods reject with {@link TranscribeDraftUnavailableError}
+ * when IndexedDB is absent.
+ */
+export declare class TranscribeDraftStore {
+    save(blob: Blob, meta?: TranscribeDraftMeta): Promise<{
+        readonly draftId: string;
+    }>;
+    list(): Promise<readonly TranscribeDraftRecord[]>;
+    get(draftId: string): Promise<TranscribeDraftRecord | null>;
+    delete(draftId: string): Promise<void>;
+}
+//# sourceMappingURL=transcribe-resilience.d.ts.map

package/dist/src/transcribe-resilience.js

@@ -0,0 +1,203 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+const LS_KEY = "aithos:transcribe:pending";
+/**
+ * Framework-agnostic observable registry of in-flight transcription jobs.
+ * Persisted to localStorage when available (so it survives reloads), with
+ * an in-memory fallback otherwise. Subscribe with `subscribe(listener)`;
+ * read with `getSnapshot()` (stable reference between mutations, so it
+ * plugs directly into React's `useSyncExternalStore`).
+ */
+export class LocalPendingTranscribeTracker {
+    #listeners = new Set();
+    #mem = [];
+    #snapshot = [];
+    constructor() {
+        this.#snapshot = this.#read();
+        // Cross-tab sync: when another tab updates the key, re-emit.
+        try {
+            if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+                window.addEventListener("storage", (e) => {
+                    if (e.key === LS_KEY) {
+                        this.#snapshot = this.#read();
+                        this.#emit();
+                    }
+                });
+            }
+        }
+        catch {
+            /* no window — fine */
+        }
+    }
+    #ls() {
+        try {
+            return typeof localStorage !== "undefined" ? localStorage : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    #read() {
+        const ls = this.#ls();
+        if (!ls)
+            return [...this.#mem];
+        try {
+            const raw = ls.getItem(LS_KEY);
+            return raw ? JSON.parse(raw) : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    #write(list) {
+        const ls = this.#ls();
+        if (ls) {
+            try {
+                ls.setItem(LS_KEY, JSON.stringify(list));
+            }
+            catch {
+                /* quota / private mode — keep in-memory copy authoritative */
+                this.#mem = list;
+            }
+        }
+        else {
+            this.#mem = list;
+        }
+        this.#snapshot = list;
+        this.#emit();
+    }
+    #emit() {
+        for (const l of this.#listeners)
+            l();
+    }
+    /** Current entries. Stable reference until the next mutation. */
+    getSnapshot() {
+        return this.#snapshot;
+    }
+    list() {
+        this.#snapshot = this.#read();
+        return this.#snapshot;
+    }
+    /** Subscribe to changes. Returns an unsubscribe function. */
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    upsert(jobId, status, meta) {
+        const now = Date.now();
+        const list = this.#read();
+        const idx = list.findIndex((e) => e.jobId === jobId);
+        if (idx >= 0) {
+            const prev = list[idx];
+            list[idx] = {
+                ...prev,
+                status,
+                updatedAt: now,
+                ...(meta ? { meta: { ...prev.meta, ...meta } } : {}),
+            };
+        }
+        else {
+            list.push({
+                jobId,
+                status,
+                createdAt: now,
+                updatedAt: now,
+                ...(meta ? { meta } : {}),
+            });
+        }
+        this.#write(list);
+    }
+    remove(jobId) {
+        const list = this.#read().filter((e) => e.jobId !== jobId);
+        this.#write(list);
+    }
+    clear() {
+        this.#write([]);
+    }
+}
+const DB_NAME = "aithos-transcribe";
+const DB_VERSION = 1;
+const STORE = "drafts";
+export class TranscribeDraftUnavailableError extends Error {
+    constructor() {
+        super("IndexedDB is not available in this environment — the transcription draft queue is browser-only.");
+        this.name = "TranscribeDraftUnavailableError";
+    }
+}
+function getIndexedDB() {
+    try {
+        if (typeof indexedDB !== "undefined")
+            return indexedDB;
+    }
+    catch {
+        /* fall through */
+    }
+    throw new TranscribeDraftUnavailableError();
+}
+function openDb() {
+    const idb = getIndexedDB();
+    return new Promise((resolve, reject) => {
+        const req = idb.open(DB_NAME, DB_VERSION);
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            if (!db.objectStoreNames.contains(STORE)) {
+                db.createObjectStore(STORE, { keyPath: "draftId" });
+            }
+        };
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error ?? new Error("indexedDB open failed"));
+    });
+}
+function tx(db, mode, fn) {
+    return new Promise((resolve, reject) => {
+        const t = db.transaction(STORE, mode);
+        const req = fn(t.objectStore(STORE));
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error ?? new Error("indexedDB request failed"));
+    });
+}
+/**
+ * IndexedDB-backed queue of recorded audio Blobs. Save a recording the
+ * instant it finishes (before any network), then `upload` it when the
+ * user confirms — so a flaky network or a closed tab never loses audio.
+ * Browser-only: methods reject with {@link TranscribeDraftUnavailableError}
+ * when IndexedDB is absent.
+ */
+export class TranscribeDraftStore {
+    async save(blob, meta) {
+        const db = await openDb();
+        const draftId = `draft_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+        const record = {
+            draftId,
+            blob,
+            metadata: {
+                ...(meta ?? {}),
+                ...(meta?.contentType ? {} : { contentType: blob.type || "audio/webm" }),
+            },
+            createdAt: Date.now(),
+        };
+        await tx(db, "readwrite", (s) => s.put(record));
+        db.close();
+        return { draftId };
+    }
+    async list() {
+        const db = await openDb();
+        const out = await tx(db, "readonly", (s) => s.getAll());
+        db.close();
+        return out.sort((a, b) => a.createdAt - b.createdAt);
+    }
+    async get(draftId) {
+        const db = await openDb();
+        const rec = await tx(db, "readonly", (s) => s.get(draftId));
+        db.close();
+        return rec ?? null;
+    }
+    async delete(draftId) {
+        const db = await openDb();
+        await tx(db, "readwrite", (s) => s.delete(draftId));
+        db.close();
+    }
+}
+//# sourceMappingURL=transcribe-resilience.js.map

package/dist/test/ethos-first-edition.test.js

@@ -185,19 +185,142 @@ describe("EthosClient — fresh Ethos (no edition published yet)", () => {
         assert.equal(env.method, "aithos.publish_ethos_edition");
         assert.match(env.proof.verificationMethod, /#public$/);
     });
-    it("publish() rejects circle/self mutations on first edition", async () => {
+    it("publish() accepts circle mutations on first edition with auto-injected public sentinel", async () => {
+        // Regression target: this used to throw `ethos_first_edition_public_only`.
+        // Since aithos-sdk@0.1.0-alpha.43 + protocol-client@0.1.0-alpha.14, the
+        // SDK auto-injects an `aithos-init` public section and seals the circle
+        // sections in the same height=1 manifest.
+        let publishBody = null;
         installFetchMock([
             {
                 url: "/mcp/primitives/read",
                 rpcMethod: "aithos.get_ethos_manifest",
                 respond: noEditionYetResponse,
             },
+            {
+                url: "/mcp/primitives/write",
+                rpcMethod: "aithos.publish_ethos_edition",
+                respond: (call) => {
+                    publishBody = call.body;
+                    return publishOkResponse();
+                },
+            },
         ]);
         const auth = makeAuth();
         await signInAsAlice(auth);
         const me = makeNamespace(auth).me();
         me.zone("circle").addSection({ title: "Private", body: "..." });
-        await assert.rejects(() => me.publish(), (e) => e instanceof AithosSDKError && e.code === "ethos_first_edition_public_only");
+        const r = await me.publish();
+        assert.equal(r.editionHeight, 1);
+        assert.deepEqual(r.zonesPublished, ["public", "circle"]);
+        const manifest = publishBody.params.manifest;
+        assert.equal(manifest.edition.height, 1);
+        assert.equal(manifest.edition.prev_hash, null);
+        // Auto-injected sentinel.
+        assert.deepEqual(manifest.zones.public.section_titles, ["aithos-init"]);
+        assert.equal(manifest.zones.public.encrypted, false);
+        // Sealed circle zone.
+        assert.deepEqual(manifest.zones.circle.section_titles, ["Private"]);
+        assert.equal(manifest.zones.circle.encrypted, true);
+        assert.ok(manifest.zones.circle.cipher, "circle cipher must be present");
+        // Both zones uploaded.
+        assert.ok(publishBody.params.zones.public?.bytes_base64);
+        assert.ok(publishBody.params.zones.circle?.bytes_base64);
+        assert.equal(publishBody.params.zones.self, undefined);
+    });
+    it("publish() preserves the caller's explicit public section when mixed with circle", async () => {
+        // When the caller stages BOTH a public and a circle add, the SDK
+        // must NOT inject a sentinel — the user's public section is enough.
+        let publishBody = null;
+        installFetchMock([
+            {
+                url: "/mcp/primitives/read",
+                rpcMethod: "aithos.get_ethos_manifest",
+                respond: noEditionYetResponse,
+            },
+            {
+                url: "/mcp/primitives/write",
+                rpcMethod: "aithos.publish_ethos_edition",
+                respond: (call) => {
+                    publishBody = call.body;
+                    return publishOkResponse();
+                },
+            },
+        ]);
+        const auth = makeAuth();
+        await signInAsAlice(auth);
+        const me = makeNamespace(auth).me();
+        me.zone("public").addSection({ title: "About", body: "Public bio." });
+        me.zone("circle").addSection({ title: "Notes", body: "Private notes." });
+        const r = await me.publish();
+        assert.deepEqual(r.zonesPublished, ["public", "circle"]);
+        const manifest = publishBody.params.manifest;
+        // No sentinel — the user's section is the public titles entry.
+        assert.deepEqual(manifest.zones.public.section_titles, ["About"]);
+        assert.deepEqual(manifest.zones.circle.section_titles, ["Notes"]);
+    });
+    it("publish() auto-injects public sentinel when only self mutations are staged", async () => {
+        let publishBody = null;
+        installFetchMock([
+            {
+                url: "/mcp/primitives/read",
+                rpcMethod: "aithos.get_ethos_manifest",
+                respond: noEditionYetResponse,
+            },
+            {
+                url: "/mcp/primitives/write",
+                rpcMethod: "aithos.publish_ethos_edition",
+                respond: (call) => {
+                    publishBody = call.body;
+                    return publishOkResponse();
+                },
+            },
+        ]);
+        const auth = makeAuth();
+        await signInAsAlice(auth);
+        const me = makeNamespace(auth).me();
+        me.zone("self").addSection({ title: "Journal", body: "Private." });
+        const r = await me.publish();
+        assert.deepEqual(r.zonesPublished, ["public", "self"]);
+        const manifest = publishBody.params.manifest;
+        assert.deepEqual(manifest.zones.public.section_titles, ["aithos-init"]);
+        assert.deepEqual(manifest.zones.self.section_titles, ["Journal"]);
+        assert.equal(manifest.zones.self.encrypted, true);
+        assert.equal(manifest.zones.circle, undefined);
+    });
+    it("publish() lands public + circle + self in a single height=1 edition", async () => {
+        let publishBody = null;
+        installFetchMock([
+            {
+                url: "/mcp/primitives/read",
+                rpcMethod: "aithos.get_ethos_manifest",
+                respond: noEditionYetResponse,
+            },
+            {
+                url: "/mcp/primitives/write",
+                rpcMethod: "aithos.publish_ethos_edition",
+                respond: (call) => {
+                    publishBody = call.body;
+                    return publishOkResponse();
+                },
+            },
+        ]);
+        const auth = makeAuth();
+        await signInAsAlice(auth);
+        const me = makeNamespace(auth).me();
+        me.zone("public").addSection({ title: "Bio", body: "Bio body." });
+        me.zone("circle").addSection({ title: "Circle", body: "Circle body." });
+        me.zone("self").addSection({ title: "Self", body: "Self body." });
+        const r = await me.publish();
+        assert.equal(r.editionHeight, 1);
+        assert.deepEqual(r.zonesPublished, ["public", "circle", "self"]);
+        const manifest = publishBody.params.manifest;
+        assert.deepEqual(manifest.zones.public.section_titles, ["Bio"]);
+        assert.deepEqual(manifest.zones.circle.section_titles, ["Circle"]);
+        assert.deepEqual(manifest.zones.self.section_titles, ["Self"]);
+        assert.ok(publishBody.params.zones.public?.bytes_base64);
+        assert.ok(publishBody.params.zones.circle?.bytes_base64);
+        assert.ok(publishBody.params.zones.self?.bytes_base64);
     });
     it("publish() rejects update/delete operations on a fresh Ethos", async () => {
         installFetchMock([

package/dist/test/transcribe-invoke.test.d.ts

@@ -0,0 +1,2 @@
+import "fake-indexeddb/auto";
+//# sourceMappingURL=transcribe-invoke.test.d.ts.map

package/dist/test/transcribe-invoke.test.js

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Tests for the high-level invokeTranscribe flow (prepare -> upload -> start
+// -> poll) and the framework-agnostic resilience helpers (local pending
+// tracker + IndexedDB draft store). fake-indexeddb/auto installs an
+// in-memory IndexedDB for the draft tests.
+import "fake-indexeddb/auto";
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { createBrowserIdentity } from "@aithos/protocol-client";
+import { AithosAuth, AithosSDK, LocalPendingTranscribeTracker, TranscribeDraftStore, memoryKeyStore, noopStore, } from "../src/index.js";
+import { serializeRecoveryFile } from "../src/internal/recovery-file.js";
+const APP_DID = "did:aithos:app:test";
+const UPLOAD_URL = "https://s3.example.test/upload?sig=abc";
+async function makeSdk(fetchImpl) {
+    const id = createBrowserIdentity("test-handle", "Test User");
+    const auth = new AithosAuth({
+        authBaseUrl: "https://auth.test",
+        fetch: (() => {
+            throw new Error("auth not used");
+        }),
+        sessionStore: noopStore(),
+        keyStore: memoryKeyStore(),
+    });
+    const { text } = serializeRecoveryFile(id);
+    await auth.signInWithRecovery({ file: text });
+    return new AithosSDK({
+        auth,
+        appDid: APP_DID,
+        endpoints: { compute: "https://compute.example.test" },
+        fetch: fetchImpl,
+    });
+}
+function jsonRpc(result) {
+    return new Response(JSON.stringify({ result }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+    });
+}
+describe("compute.invokeTranscribe — full flow", () => {
+    it("prepares, uploads to S3, starts, polls and returns the transcript", async () => {
+        const calls = [];
+        let putBytes = 0;
+        let statusPolls = 0;
+        const fetchImpl = async (input, init) => {
+            const url = typeof input === "string" ? input : input.toString();
+            if (init?.method === "PUT" && url.startsWith("https://s3.example.test/")) {
+                // S3 upload.
+                calls.push("s3-put");
+                putBytes = init.body.size;
+                return new Response("", { status: 200 });
+            }
+            const method = JSON.parse(init?.body).method;
+            calls.push(method);
+            if (method === "aithos.compute_transcribe_prepare") {
+                return jsonRpc({
+                    job_id: "tj_FLOW",
+                    upload_url: UPLOAD_URL,
+                    s3_object_key: "uploads/2026/05/tj_FLOW.webm",
+                    expires_at: 1717000000,
+                });
+            }
+            if (method === "aithos.compute_transcribe_start") {
+                return jsonRpc({
+                    job_id: "tj_FLOW",
+                    status: "running",
+                    estimated_credits: 60,
+                    walletBalance: 49_940,
+                    fundedBy: "purchase",
+                });
+            }
+            if (method === "aithos.compute_transcribe_status") {
+                statusPolls += 1;
+                if (statusPolls < 2) {
+                    return jsonRpc({ job_id: "tj_FLOW", status: "running", elapsed_sec: 1 });
+                }
+                return jsonRpc({
+                    job_id: "tj_FLOW",
+                    status: "completed",
+                    text: "Bonjour le monde",
+                    segments: [{ start_sec: 0, end_sec: 1.4, text: "Bonjour le monde" }],
+                    words: [{ start_sec: 0, end_sec: 0.4, content: "Bonjour", confidence: 0.99 }],
+                    duration_sec_actual: 30,
+                    language_code: "fr-FR",
+                    creditsCharged: 60,
+                    walletBalance: 49_940,
+                    auditId: "audit_flow",
+                    fundedBy: "purchase",
+                });
+            }
+            throw new Error(`unexpected method ${method}`);
+        };
+        const sdk = await makeSdk(fetchImpl);
+        const phases = [];
+        const audio = new Blob([new Uint8Array(2048)], { type: "audio/webm" });
+        const result = await sdk.compute.invokeTranscribe({
+            audio,
+            durationSecOverride: 30,
+            pollIntervalMs: 1,
+            onProgress: (s) => phases.push(s.phase),
+        });
+        assert.equal(result.text, "Bonjour le monde");
+        assert.equal(result.durationSec, 30);
+        assert.equal(result.creditsCharged, 60);
+        assert.equal(result.jobId, "tj_FLOW");
+        assert.equal(result.fundedBy, "purchase");
+        assert.equal(result.segments.length, 1);
+        // The flow visited every step in order.
+        assert.deepEqual(calls, [
+            "aithos.compute_transcribe_prepare",
+            "s3-put",
+            "aithos.compute_transcribe_start",
+            "aithos.compute_transcribe_status",
+            "aithos.compute_transcribe_status",
+        ]);
+        assert.equal(putBytes, 2048);
+        assert.ok(phases.includes("queued"));
+        assert.ok(phases.includes("uploading"));
+        assert.ok(phases.includes("starting"));
+        assert.ok(phases.includes("completed"));
+        // Job cleared from the local pending tracker on success.
+        assert.equal(sdk.compute.listLocalPendingTranscribes().length, 0);
+    });
+    it("throws an AithosSDKError when the job fails, leaving the job flagged failed", async () => {
+        const fetchImpl = async (input, init) => {
+            const url = typeof input === "string" ? input : input.toString();
+            if (init?.method === "PUT")
+                return new Response("", { status: 200 });
+            const method = JSON.parse(init?.body).method;
+            if (method === "aithos.compute_transcribe_prepare") {
+                return jsonRpc({ job_id: "tj_F", upload_url: UPLOAD_URL, s3_object_key: "k", expires_at: 1 });
+            }
+            if (method === "aithos.compute_transcribe_start") {
+                return jsonRpc({ job_id: "tj_F", status: "running", estimated_credits: 60, walletBalance: 1 });
+            }
+            return jsonRpc({
+                job_id: "tj_F",
+                status: "failed",
+                error: { code: "transcribe_provider_error", message: "bad audio" },
+            });
+        };
+        const sdk = await makeSdk(fetchImpl);
+        const audio = new Blob([new Uint8Array(10)], { type: "audio/webm" });
+        await assert.rejects(() => sdk.compute.invokeTranscribe({ audio, durationSecOverride: 30, pollIntervalMs: 1 }), (e) => {
+            assert.ok(e instanceof Error);
+            assert.match(e.message, /bad audio/);
+            return true;
+        });
+        const pending = sdk.compute.listLocalPendingTranscribes();
+        assert.equal(pending.find((p) => p.jobId === "tj_F")?.status, "failed");
+    });
+});
+describe("LocalPendingTranscribeTracker (vanilla, framework-agnostic)", () => {
+    it("upserts, lists, removes and notifies subscribers", () => {
+        const t = new LocalPendingTranscribeTracker();
+        t.clear();
+        let notifications = 0;
+        const unsub = t.subscribe(() => {
+            notifications += 1;
+        });
+        t.upsert("tj_1", "uploading", { model: "transcribe:aws-fr-standard" });
+        assert.equal(t.list().length, 1);
+        assert.equal(t.list()[0]?.status, "uploading");
+        t.upsert("tj_1", "running");
+        assert.equal(t.list().length, 1, "same job id updates in place");
+        assert.equal(t.list()[0]?.status, "running");
+        t.upsert("tj_2", "running");
+        assert.equal(t.list().length, 2);
+        t.remove("tj_1");
+        assert.equal(t.list().length, 1);
+        assert.equal(t.list()[0]?.jobId, "tj_2");
+        assert.ok(notifications >= 4, "subscriber fired on each mutation");
+        unsub();
+        const before = notifications;
+        t.upsert("tj_3", "running");
+        assert.equal(notifications, before, "no notification after unsubscribe");
+    });
+    it("getSnapshot returns a stable reference between mutations", () => {
+        const t = new LocalPendingTranscribeTracker();
+        t.clear();
+        const a = t.getSnapshot();
+        const b = t.getSnapshot();
+        assert.equal(a, b);
+        t.upsert("tj_x", "running");
+        assert.notEqual(t.getSnapshot(), a, "new reference after a mutation");
+    });
+});
+describe("TranscribeDraftStore (IndexedDB via fake-indexeddb)", () => {
+    it("saves, lists, gets and deletes a draft", async () => {
+        const store = new TranscribeDraftStore();
+        const blob = new Blob([new Uint8Array(64)], { type: "audio/webm" });
+        const { draftId } = await store.save(blob, { title: "séance 1" });
+        assert.ok(draftId.startsWith("draft_"));
+        const list = await store.list();
+        assert.ok(list.some((d) => d.draftId === draftId));
+        const got = await store.get(draftId);
+        assert.equal(got?.metadata.title, "séance 1");
+        assert.equal(got?.metadata.contentType, "audio/webm");
+        assert.equal(got?.blob.size, 64);
+        await store.delete(draftId);
+        assert.equal(await store.get(draftId), null);
+    });
+});
+//# sourceMappingURL=transcribe-invoke.test.js.map