@aithos/sdk 0.1.0-alpha.5 → 0.1.0-alpha.50

package/dist/src/react/context.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+/**
+ * React context for the Aithos assets client.
+ *
+ * App roots wrap their tree with `<AssetsClientProvider client={sdk.assets}>`
+ * once, then child components use `<AithosAsset urn="..." />` (or the
+ * `useAithosAsset` hook) without having to thread the client through
+ * props.
+ */
+import { createContext, useContext } from "react";
+const AssetsClientContext = createContext(null);
+/**
+ * Provider that exposes an {@link AssetsClient} to descendants.
+ *
+ * Typical placement: as high in the React tree as the authenticated
+ * session lives (e.g. inside the auth boundary).
+ */
+export function AssetsClientProvider(props) {
+    return (_jsx(AssetsClientContext.Provider, { value: props.client, children: props.children }));
+}
+/**
+ * Return the {@link AssetsClient} from the nearest provider, or `null`
+ * if no provider is present. Components SHOULD accept an override via
+ * an explicit `client` prop and fall back to this hook when omitted.
+ */
+export function useAssetsClient() {
+    return useContext(AssetsClientContext);
+}
+//# sourceMappingURL=context.js.map

package/dist/src/react/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `@aithos/sdk/react` — React bindings for the Aithos SDK.
+ *
+ * Drop-in components and hooks for displaying Aithos-hosted assets in
+ * React applications. The package's only peer dependency beyond
+ * `@aithos/sdk` itself is `react` (^18 || ^19).
+ *
+ * Quick start:
+ *
+ *     // 1. Wrap your tree once
+ *     <AssetsClientProvider client={sdk.assets}>
+ *       <App />
+ *     </AssetsClientProvider>
+ *
+ *     // 2. Use anywhere
+ *     <AithosAsset urn={cv.urn} alt="CV" className="w-full" />
+ *     <AithosAsset urn={video.urn} as="video" controls />
+ *     <AithosAsset urn={pdf.urn} as="download" filename="cv.pdf">
+ *       Download my CV
+ *     </AithosAsset>
+ *
+ *     // 3. Or use the hook directly for custom rendering
+ *     const { url, bytes, loading, error } = useAithosAsset(urn);
+ */
+export { AssetsClientProvider, useAssetsClient, type AssetsClientProviderProps, } from "./context.js";
+export { useAithosAsset, type UseAithosAssetState, type UseAithosAssetOptions, } from "./use-aithos-asset.js";
+export { AithosAsset, type AithosAssetProps, type AithosImageProps, type AithosVideoProps, type AithosAudioProps, type AithosDownloadProps, } from "./AithosAsset.js";
+export { useAithosTranscribePendingJobs, type UseAithosTranscribePendingJobs, } from "./use-transcribe-pending.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/react/index.js

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+/**
+ * `@aithos/sdk/react` — React bindings for the Aithos SDK.
+ *
+ * Drop-in components and hooks for displaying Aithos-hosted assets in
+ * React applications. The package's only peer dependency beyond
+ * `@aithos/sdk` itself is `react` (^18 || ^19).
+ *
+ * Quick start:
+ *
+ *     // 1. Wrap your tree once
+ *     <AssetsClientProvider client={sdk.assets}>
+ *       <App />
+ *     </AssetsClientProvider>
+ *
+ *     // 2. Use anywhere
+ *     <AithosAsset urn={cv.urn} alt="CV" className="w-full" />
+ *     <AithosAsset urn={video.urn} as="video" controls />
+ *     <AithosAsset urn={pdf.urn} as="download" filename="cv.pdf">
+ *       Download my CV
+ *     </AithosAsset>
+ *
+ *     // 3. Or use the hook directly for custom rendering
+ *     const { url, bytes, loading, error } = useAithosAsset(urn);
+ */
+export { AssetsClientProvider, useAssetsClient, } from "./context.js";
+export { useAithosAsset, } from "./use-aithos-asset.js";
+export { AithosAsset, } from "./AithosAsset.js";
+export { useAithosTranscribePendingJobs, } from "./use-transcribe-pending.js";
+//# sourceMappingURL=index.js.map

package/dist/src/react/use-aithos-asset.d.ts

@@ -0,0 +1,39 @@
+import type { AssetsClient } from "../assets.js";
+export interface UseAithosAssetState {
+    /** A `blob:` URL pointing at the decrypted plaintext. Use in <img src=…> etc. */
+    readonly url: string | null;
+    /** Raw decrypted bytes. Use when you need the binary itself (e.g. PDF viewer). */
+    readonly bytes: Uint8Array | null;
+    /** IANA media type — useful for routing rendering. */
+    readonly mediaType: string | null;
+    /** Plaintext size in bytes. */
+    readonly sizeBytes: number | null;
+    /** True while the fetch+decrypt is in flight. */
+    readonly loading: boolean;
+    /** Non-null when the fetch/decrypt failed. */
+    readonly error: Error | null;
+}
+export interface UseAithosAssetOptions {
+    /** Override the client from context. Useful for tests. */
+    readonly client?: AssetsClient | null;
+    /**
+     * If `true`, the hook keeps the previous blob URL visible while a
+     * new URN is being fetched, instead of flashing `null`. Default
+     * `false` (more predictable, less visual stutter avoidance).
+     */
+    readonly keepPreviousOnUrnChange?: boolean;
+}
+/**
+ * Fetch + decrypt an Aithos asset and return a stable `blob:` URL.
+ *
+ * Lifecycle:
+ *  - On mount or when `urn` changes, runs `client.fetch(urn)`.
+ *  - On success, creates an object URL from the plaintext bytes.
+ *  - On unmount or before refetching, revokes the URL to free memory.
+ *  - Cancels in-flight fetches if the URN changes mid-flight.
+ *
+ * Throws (via `error`) when no client is available — supply one via
+ * `<AssetsClientProvider>` or the `client` option.
+ */
+export declare function useAithosAsset(urn: string | null | undefined, options?: UseAithosAssetOptions): UseAithosAssetState;
+//# sourceMappingURL=use-aithos-asset.d.ts.map

package/dist/src/react/use-aithos-asset.js

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+/**
+ * `useAithosAsset(urn)` — React hook that fetches an asset and exposes
+ * it as a browser-consumable `blob:` URL, with full lifecycle
+ * management (revoke on unmount, race-cancel on URN change, error
+ * surfacing).
+ *
+ * For most UIs the higher-level `<AithosAsset>` component is enough.
+ * Reach for this hook directly when you want to feed the bytes or the
+ * blob URL to a non-`<img>`/`<video>`/`<audio>` consumer — e.g. an
+ * inline CSS `background-image`, a Canvas, a custom PDF viewer.
+ */
+import { useEffect, useState } from "react";
+import { useAssetsClient } from "./context.js";
+/**
+ * Fetch + decrypt an Aithos asset and return a stable `blob:` URL.
+ *
+ * Lifecycle:
+ *  - On mount or when `urn` changes, runs `client.fetch(urn)`.
+ *  - On success, creates an object URL from the plaintext bytes.
+ *  - On unmount or before refetching, revokes the URL to free memory.
+ *  - Cancels in-flight fetches if the URN changes mid-flight.
+ *
+ * Throws (via `error`) when no client is available — supply one via
+ * `<AssetsClientProvider>` or the `client` option.
+ */
+export function useAithosAsset(urn, options = {}) {
+    const contextClient = useAssetsClient();
+    const client = options.client ?? contextClient;
+    const [state, setState] = useState({
+        url: null,
+        bytes: null,
+        mediaType: null,
+        sizeBytes: null,
+        loading: !!urn,
+        error: null,
+    });
+    useEffect(() => {
+        if (!urn) {
+            setState({
+                url: null,
+                bytes: null,
+                mediaType: null,
+                sizeBytes: null,
+                loading: false,
+                error: null,
+            });
+            return;
+        }
+        if (!client) {
+            setState({
+                url: null,
+                bytes: null,
+                mediaType: null,
+                sizeBytes: null,
+                loading: false,
+                error: new Error("useAithosAsset: no AssetsClient available — wrap your tree with <AssetsClientProvider> or pass the `client` option"),
+            });
+            return;
+        }
+        let cancelled = false;
+        let createdUrl = null;
+        setState((prev) => options.keepPreviousOnUrnChange
+            ? { ...prev, loading: true, error: null }
+            : {
+                url: null,
+                bytes: null,
+                mediaType: null,
+                sizeBytes: null,
+                loading: true,
+                error: null,
+            });
+        (async () => {
+            try {
+                const result = await client.fetch(urn);
+                if (cancelled)
+                    return;
+                // Construct the blob: URL the DOM can consume.
+                // The `as BlobPart` cast is needed because @types/node and
+                // lib.dom disagree on whether Uint8Array's backing buffer is
+                // always ArrayBuffer (vs SharedArrayBuffer). The runtime
+                // accepts our Uint8Array unconditionally.
+                const blob = new Blob([result.bytes], {
+                    type: result.mediaType,
+                });
+                createdUrl = URL.createObjectURL(blob);
+                setState({
+                    url: createdUrl,
+                    bytes: result.bytes,
+                    mediaType: result.mediaType,
+                    sizeBytes: result.sizeBytes,
+                    loading: false,
+                    error: null,
+                });
+            }
+            catch (e) {
+                if (cancelled)
+                    return;
+                setState({
+                    url: null,
+                    bytes: null,
+                    mediaType: null,
+                    sizeBytes: null,
+                    loading: false,
+                    error: e instanceof Error ? e : new Error(String(e)),
+                });
+            }
+        })();
+        return () => {
+            cancelled = true;
+            if (createdUrl)
+                URL.revokeObjectURL(createdUrl);
+        };
+    }, [urn, client, options.keepPreviousOnUrnChange]);
+    return state;
+}
+//# sourceMappingURL=use-aithos-asset.js.map

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/sdk.d.ts

@@ -1,9 +1,11 @@
 import type { AithosAuth } from "./auth.js";
+import { AppsNamespace } from "./apps.js";
 import { ComputeNamespace } from "./compute.js";
 import { type AithosSdkEndpoints } from "./endpoints.js";
 import { EthosNamespace } from "./ethos.js";
 import { MandatesNamespace } from "./mandates.js";
 import { WalletNamespace } from "./wallet.js";
+import { WebNamespace } from "./web.js";
 export interface AithosSDKConfig {
     /**
      * The {@link AithosAuth} instance the SDK reads sign-in state from.
@@ -44,6 +46,14 @@ export declare class AithosSDK {
     readonly ethos: EthosNamespace;
     /** Mandate lifecycle namespace — create / list / revoke. */
     readonly mandates: MandatesNamespace;
+    /** Web extraction namespace — aithos.web_extract through the web extractor proxy. */
+    readonly web: WebNamespace;
+    /**
+     * App lifecycle namespace — sponsorship mandates + app-credit top-ups.
+     * V0.1 (2026-05-27 — draft §13). Lets a developer pre-pay a pool that
+     * funds compute calls from their app's users within explicit caps.
+     */
+    readonly apps: AppsNamespace;
     constructor(config: AithosSDKConfig);
     /** DID of the currently signed-in owner, or null if no owner is loaded. */
     get userDid(): string | null;

package/dist/src/sdk.js

@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright 2026 Mathieu Colla
+import { AppsNamespace } from "./apps.js";
 import { ComputeNamespace } from "./compute.js";
 import { resolveEndpoints } from "./endpoints.js";
 import { EthosNamespace } from "./ethos.js";
 import { MandatesNamespace } from "./mandates.js";
 import { WalletNamespace } from "./wallet.js";
+import { WebNamespace } from "./web.js";
 export class AithosSDK {
     /** Resolved endpoint configuration (defaults + caller overrides). */
     endpoints;
@@ -20,6 +22,14 @@ export class AithosSDK {
     ethos;
     /** Mandate lifecycle namespace — create / list / revoke. */
     mandates;
+    /** Web extraction namespace — aithos.web_extract through the web extractor proxy. */
+    web;
+    /**
+     * App lifecycle namespace — sponsorship mandates + app-credit top-ups.
+     * V0.1 (2026-05-27 — draft §13). Lets a developer pre-pay a pool that
+     * funds compute calls from their app's users within explicit caps.
+     */
+    apps;
     constructor(config) {
         if (!config.auth) {
             throw new TypeError("AithosSDK: config.auth is required");
@@ -53,6 +63,18 @@ export class AithosSDK {
             endpoints: this.endpoints,
             fetch: fetchImpl,
         });
+        this.web = new WebNamespace({
+            auth: config.auth,
+            appDid: config.appDid,
+            endpoints: this.endpoints,
+            fetch: fetchImpl,
+        });
+        this.apps = new AppsNamespace({
+            auth: config.auth,
+            appDid: config.appDid,
+            endpoints: this.endpoints,
+            fetch: fetchImpl,
+        });
     }
     /** DID of the currently signed-in owner, or null if no owner is loaded. */
     get userDid() {

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