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

package/dist/src/compute.js

@@ -20,6 +20,7 @@ import { buildSignedEnvelope, } from "@aithos/protocol-client";
 import { computeInvokeUrl, } from "./endpoints.js";
 import { delegateKeyPair, ownerKeyPair, } from "./internal/protocol-client-bridge.js";
 import { AithosSDKError } from "./types.js";
+import { LocalPendingTranscribeTracker, TranscribeDraftStore, } from "./transcribe-resilience.js";
 /**
  * `sdk.compute` namespace. Constructed once by the {@link AithosSDK}
  * constructor; reads the active owner from the supplied
@@ -28,9 +29,23 @@ import { AithosSDKError } from "./types.js";
  */
 export class ComputeNamespace {
     #deps;
+    // Lazily-created browser resilience helpers (see transcribe-resilience.ts).
+    // Created on first access only — the core invoke path never touches them.
+    #pendingTracker = null;
+    #draftStore = null;
     constructor(deps) {
         this.#deps = deps;
     }
+    #tracker() {
+        if (!this.#pendingTracker)
+            this.#pendingTracker = new LocalPendingTranscribeTracker();
+        return this.#pendingTracker;
+    }
+    #draft() {
+        if (!this.#draftStore)
+            this.#draftStore = new TranscribeDraftStore();
+        return this.#draftStore;
+    }
     /**
      * Invoke a Bedrock model through the compute proxy. See
      * {@link InvokeBedrockArgs} and {@link InvokeBedrockResult}.
@@ -234,6 +249,307 @@ export class ComputeNamespace {
             signal: args.signal,
         });
     }
+    /* ---------------------------------------------------------------------- */
+    /*  Transcription — low-level (advanced) API                              */
+    /*                                                                        */
+    /*  Four thin wrappers over the JSON-RPC methods. Use these when you want */
+    /*  to own the upload + polling loop; otherwise prefer `invokeTranscribe` */
+    /*  which composes them. All four are isomorphic (sign + POST only).      */
+    /* ---------------------------------------------------------------------- */
+    /**
+     * Provision a transcription job and get a pre-signed S3 URL to PUT the
+     * audio to. No wallet debit. `mandateId` only selects the delegate
+     * signer (it is not part of the wire params for prepare).
+     */
+    async prepareTranscribe(args) {
+        const { endpoints, fetch: fetchImpl } = this.#deps;
+        const choice = this.#resolveSigner(args.mandateId);
+        const url = computeInvokeUrl(endpoints);
+        const params = {
+            app_did: this.#deps.appDid,
+            content_type: args.contentType,
+        };
+        if (args.durationSecEstimate !== undefined) {
+            params.duration_sec_estimate = args.durationSecEstimate;
+        }
+        const r = await this.#signAndPost({
+            url,
+            method: "aithos.compute_transcribe_prepare",
+            params,
+            choice,
+            fetchImpl,
+            signal: args.signal,
+        });
+        return {
+            jobId: r.job_id,
+            uploadUrl: r.upload_url,
+            s3ObjectKey: r.s3_object_key,
+            expiresAt: r.expires_at,
+        };
+    }
+    /**
+     * Verify the uploaded audio, pre-debit the wallet, and launch the AWS
+     * Transcribe job. Returns immediately with `status: "running"`.
+     */
+    async startTranscribe(args) {
+        const { endpoints, fetch: fetchImpl } = this.#deps;
+        const choice = this.#resolveSigner(args.mandateId);
+        const url = computeInvokeUrl(endpoints);
+        const params = {
+            app_did: this.#deps.appDid,
+            mandate_id: this.#resolveMandateIdForWire(args.mandateId, choice),
+            job_id: args.jobId,
+            model: args.model,
+            duration_sec: args.durationSec,
+        };
+        if (args.languageCode !== undefined)
+            params.language_code = args.languageCode;
+        if (args.diarization !== undefined)
+            params.diarization = args.diarization;
+        if (args.idempotencyKey !== undefined)
+            params.idempotency_key = args.idempotencyKey;
+        const r = await this.#signAndPost({
+            url,
+            method: "aithos.compute_transcribe_start",
+            params,
+            choice,
+            fetchImpl,
+            signal: args.signal,
+        });
+        return {
+            jobId: r.job_id,
+            status: "running",
+            estimatedCredits: r.estimated_credits,
+            walletBalance: r.walletBalance,
+            ...(r.fundedBy ? { fundedBy: r.fundedBy } : {}),
+            ...(r.receiptId ? { receiptId: r.receiptId } : {}),
+        };
+    }
+    /**
+     * Poll a job's status. On completion the server finalises (reconcile +
+     * audit) and returns the transcript; a resumed poll after reconnect
+     * re-reads the transcript while it's still in the 24h output window.
+     */
+    async getTranscribeStatus(args) {
+        const { endpoints, fetch: fetchImpl } = this.#deps;
+        const choice = this.#resolveSigner(args.mandateId);
+        const url = computeInvokeUrl(endpoints);
+        const params = { job_id: args.jobId };
+        const r = await this.#signAndPost({
+            url,
+            method: "aithos.compute_transcribe_status",
+            params,
+            choice,
+            fetchImpl,
+            signal: args.signal,
+        });
+        return mapTranscribeStatus(args.jobId, r);
+    }
+    /**
+     * List the caller's transcription jobs. Excludes terminal `completed`
+     * jobs unless `includeCompleted` is set — the resilience "what's still
+     * pending server-side" query.
+     */
+    async listPendingTranscribes(args) {
+        const { endpoints, fetch: fetchImpl } = this.#deps;
+        const choice = this.#resolveSigner(args?.mandateId);
+        const url = computeInvokeUrl(endpoints);
+        const params = {};
+        if (args?.includeCompleted !== undefined) {
+            params.include_completed = args.includeCompleted;
+        }
+        const r = await this.#signAndPost({
+            url,
+            method: "aithos.compute_transcribe_list_pending",
+            params,
+            choice,
+            fetchImpl,
+            signal: args?.signal,
+        });
+        return {
+            jobs: (r.jobs ?? []).map((j) => ({
+                jobId: String(j.job_id),
+                status: j.status,
+                createdAt: Number(j.created_at),
+                ...(j.estimated_credits !== undefined
+                    ? { estimatedCredits: Number(j.estimated_credits) }
+                    : {}),
+                ...(j.creditsCharged !== undefined
+                    ? { creditsCharged: Number(j.creditsCharged) }
+                    : {}),
+            })),
+        };
+    }
+    /* ---------------------------------------------------------------------- */
+    /*  Transcription — high-level one-call API                               */
+    /* ---------------------------------------------------------------------- */
+    /**
+     * Transcribe an audio Blob to text in one call. Composes the four
+     * low-level methods: prepare → direct S3 upload → start → poll. Returns
+     * the transcript and stores NOTHING server-side beyond the ephemeral
+     * job — the consumer decides what to do with the result.
+     *
+     * Isomorphic: depends only on `Blob`, `fetch`/`XMLHttpRequest` and
+     * timers. On a backend, pass `durationSecOverride` (no Blob duration
+     * probing is possible without a DOM); in a browser the duration is
+     * probed automatically when omitted.
+     *
+     * Resilience: the job id is recorded in a localStorage tracker (browser)
+     * before upload, so `listLocalPendingTranscribes()` / `resumeTranscribe()`
+     * can recover a job whose result never arrived. In Node the tracker is a
+     * harmless in-memory no-op.
+     */
+    async invokeTranscribe(args) {
+        const idempotencyKey = args.idempotencyKey ?? generateIdempotencyKey();
+        const model = args.model ?? "transcribe:aws-fr-standard";
+        const contentType = args.audio.type || "audio/webm";
+        const durationSec = args.durationSecOverride ?? (await probeBlobDuration(args.audio));
+        args.onProgress?.({ phase: "queued" });
+        // 1. Prepare — pre-signed S3 URL + job id.
+        const prepared = await this.prepareTranscribe({
+            contentType,
+            durationSecEstimate: durationSec,
+            ...(args.mandateId ? { mandateId: args.mandateId } : {}),
+            ...(args.signal ? { signal: args.signal } : {}),
+        });
+        const tracker = this.#tracker();
+        tracker.upsert(prepared.jobId, "uploading", { model, contentType });
+        // 2. Upload the blob straight to S3 (the proxy never sees the bytes).
+        try {
+            await uploadToS3WithProgress(prepared.uploadUrl, args.audio, contentType, {
+                onProgress: (b, t) => args.onProgress?.({ phase: "uploading", bytesUploaded: b, totalBytes: t }),
+                signal: args.signal,
+                fetchImpl: this.#deps.fetch,
+            });
+        }
+        catch (e) {
+            tracker.upsert(prepared.jobId, "failed");
+            throw e instanceof AithosSDKError
+                ? e
+                : new AithosSDKError("transcribe_upload_failed", e.message);
+        }
+        // 3. Start — pre-debit + launch AWS Transcribe.
+        args.onProgress?.({ phase: "starting" });
+        await this.startTranscribe({
+            jobId: prepared.jobId,
+            ...(args.mandateId ? { mandateId: args.mandateId } : {}),
+            model,
+            durationSec,
+            ...(args.languageCode ? { languageCode: args.languageCode } : {}),
+            ...(args.diarization !== undefined ? { diarization: args.diarization } : {}),
+            idempotencyKey,
+            ...(args.signal ? { signal: args.signal } : {}),
+        });
+        tracker.upsert(prepared.jobId, "running");
+        // 4. Poll to completion.
+        const result = await this.#pollUntilTerminal(prepared.jobId, {
+            ...(args.mandateId ? { mandateId: args.mandateId } : {}),
+            ...(args.signal ? { signal: args.signal } : {}),
+            ...(args.onProgress ? { onProgress: args.onProgress } : {}),
+            ...(args.pollIntervalMs ? { pollIntervalMs: args.pollIntervalMs } : {}),
+        });
+        tracker.remove(prepared.jobId);
+        return result;
+    }
+    /**
+     * Resume polling an in-flight job by id — for recovery after a reload or
+     * crash. Returns the final result and clears the job from the local
+     * pending tracker. Throws if the job has already failed.
+     */
+    async resumeTranscribe(jobId, opts) {
+        const result = await this.#pollUntilTerminal(jobId, {
+            ...(opts?.mandateId ? { mandateId: opts.mandateId } : {}),
+            ...(opts?.signal ? { signal: opts.signal } : {}),
+            ...(opts?.onProgress ? { onProgress: opts.onProgress } : {}),
+            ...(opts?.pollIntervalMs ? { pollIntervalMs: opts.pollIntervalMs } : {}),
+        });
+        this.#tracker().remove(jobId);
+        return result;
+    }
+    async #pollUntilTerminal(jobId, opts) {
+        const startedAt = Date.now();
+        let backoffMs = opts.pollIntervalMs ?? 2000;
+        for (;;) {
+            if (opts.signal?.aborted) {
+                throw new AithosSDKError("aborted", "transcription aborted");
+            }
+            const st = await this.getTranscribeStatus({
+                jobId,
+                ...(opts.mandateId ? { mandateId: opts.mandateId } : {}),
+                ...(opts.signal ? { signal: opts.signal } : {}),
+            });
+            if (st.status === "completed") {
+                opts.onProgress?.({ phase: "completed" });
+                return {
+                    text: st.text,
+                    segments: st.segments,
+                    words: st.words,
+                    durationSec: st.durationSec,
+                    languageCode: st.languageCode,
+                    creditsCharged: st.creditsCharged,
+                    walletBalance: st.walletBalance,
+                    auditId: st.auditId,
+                    jobId: st.jobId,
+                    ...(st.fundedBy ? { fundedBy: st.fundedBy } : {}),
+                    ...(st.sponsoredBy ? { sponsoredBy: st.sponsoredBy } : {}),
+                    ...(st.receiptId ? { receiptId: st.receiptId } : {}),
+                };
+            }
+            if (st.status === "failed") {
+                this.#tracker().upsert(jobId, "failed");
+                throw new AithosSDKError(st.error.code || "transcribe_failed", st.error.message);
+            }
+            opts.onProgress?.({
+                phase: "processing",
+                elapsedSec: Math.floor((Date.now() - startedAt) / 1000),
+            });
+            await sleep(backoffMs, opts.signal);
+            backoffMs = Math.min(15_000, Math.ceil(backoffMs * 1.5));
+        }
+    }
+    /* ---------------------------------------------------------------------- */
+    /*  Transcription — browser resilience (framework-agnostic)               */
+    /* ---------------------------------------------------------------------- */
+    /** Snapshot of locally-tracked in-flight jobs (stable ref between mutations). */
+    listLocalPendingTranscribes() {
+        return this.#tracker().list();
+    }
+    /** Stable snapshot for `useSyncExternalStore`-style consumers. */
+    getLocalPendingTranscribesSnapshot() {
+        return this.#tracker().getSnapshot();
+    }
+    /**
+     * Subscribe to changes in the local pending-jobs registry. Returns an
+     * unsubscribe function. Framework-agnostic: wrap it in a React
+     * `useSyncExternalStore`, a Vue effect, a Svelte store, etc.
+     */
+    subscribeLocalPendingTranscribes(listener) {
+        return this.#tracker().subscribe(listener);
+    }
+    /**
+     * IndexedDB-backed draft queue: persist a recording before any network
+     * call, upload it when the user confirms. Browser-only (methods reject
+     * with TranscribeDraftUnavailableError when IndexedDB is absent).
+     */
+    get transcribeDraft() {
+        const store = this.#draft();
+        const self = this;
+        return {
+            save: (blob, meta) => store.save(blob, meta),
+            list: () => store.list(),
+            get: (draftId) => store.get(draftId),
+            delete: (draftId) => store.delete(draftId),
+            upload: async (draftId, args) => {
+                const rec = await store.get(draftId);
+                if (!rec) {
+                    throw new AithosSDKError("draft_not_found", `no transcription draft '${draftId}'`);
+                }
+                const result = await self.invokeTranscribe({ ...args, audio: rec.blob });
+                await store.delete(draftId);
+                return result;
+            },
+        };
+    }
     /**
      * Resolve the active signer (owner takes precedence over delegate).
      *
@@ -363,6 +679,147 @@ function generateIdempotencyKey() {
     }
     return hex;
 }
+/**
+ * Probe an audio Blob's duration (seconds) in a browser. Returns 0 when no
+ * DOM is available (Node / SSR) or probing fails — the caller should pass
+ * `durationSecOverride` on a backend. Never throws.
+ */
+async function probeBlobDuration(blob) {
+    try {
+        if (typeof document === "undefined" ||
+            typeof URL === "undefined" ||
+            typeof Audio === "undefined") {
+            return 0;
+        }
+        return await new Promise((resolve) => {
+            const url = URL.createObjectURL(blob);
+            const audio = new Audio();
+            let settled = false;
+            const done = (v) => {
+                if (settled)
+                    return;
+                settled = true;
+                try {
+                    URL.revokeObjectURL(url);
+                }
+                catch {
+                    /* ignore */
+                }
+                resolve(Number.isFinite(v) && v > 0 ? v : 0);
+            };
+            audio.preload = "metadata";
+            audio.onloadedmetadata = () => done(audio.duration);
+            audio.onerror = () => done(0);
+            audio.src = url;
+            setTimeout(() => done(0), 5000);
+        });
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * PUT a Blob to a pre-signed S3 URL. Uses XMLHttpRequest in browsers for
+ * real upload-progress events; falls back to `fetch` on Node (coarse
+ * 0→100% progress). Honors an AbortSignal.
+ */
+async function uploadToS3WithProgress(url, blob, contentType, opts) {
+    const total = blob.size;
+    if (typeof XMLHttpRequest !== "undefined") {
+        await new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            xhr.open("PUT", url, true);
+            xhr.setRequestHeader("Content-Type", contentType);
+            xhr.upload.onprogress = (e) => {
+                if (e.lengthComputable)
+                    opts.onProgress?.(e.loaded, e.total);
+            };
+            xhr.onload = () => {
+                if (xhr.status >= 200 && xhr.status < 300)
+                    resolve();
+                else
+                    reject(new AithosSDKError("transcribe_upload_failed", `S3 upload failed: HTTP ${xhr.status}`));
+            };
+            xhr.onerror = () => reject(new AithosSDKError("transcribe_upload_failed", "S3 upload network error"));
+            xhr.onabort = () => reject(new AithosSDKError("aborted", "S3 upload aborted"));
+            if (opts.signal) {
+                if (opts.signal.aborted) {
+                    xhr.abort();
+                    return;
+                }
+                opts.signal.addEventListener("abort", () => xhr.abort(), { once: true });
+            }
+            xhr.send(blob);
+        });
+        return;
+    }
+    // Node / no XHR — use the injected fetch (falls back to global fetch).
+    opts.onProgress?.(0, total);
+    const doFetch = opts.fetchImpl ?? fetch;
+    const res = await doFetch(url, {
+        method: "PUT",
+        headers: { "content-type": contentType },
+        body: blob,
+        ...(opts.signal ? { signal: opts.signal } : {}),
+    });
+    if (!res.ok) {
+        throw new AithosSDKError("transcribe_upload_failed", `S3 upload failed: HTTP ${res.status}`);
+    }
+    opts.onProgress?.(total, total);
+}
+/** Sleep `ms`, rejecting early if the signal aborts. */
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(resolve, ms);
+        if (signal) {
+            if (signal.aborted) {
+                clearTimeout(t);
+                reject(new AithosSDKError("aborted", "aborted"));
+                return;
+            }
+            signal.addEventListener("abort", () => {
+                clearTimeout(t);
+                reject(new AithosSDKError("aborted", "aborted"));
+            }, { once: true });
+        }
+    });
+}
+/** Coerce a raw `transcribe_status` JSON-RPC result into the typed union. */
+function mapTranscribeStatus(jobId, r) {
+    const status = r.status;
+    if (status === "completed") {
+        const fundedBy = r.fundedBy;
+        return {
+            jobId,
+            status: "completed",
+            text: String(r.text ?? ""),
+            segments: r.segments ?? [],
+            words: r.words ?? [],
+            durationSec: Number(r.duration_sec_actual ?? 0),
+            languageCode: String(r.language_code ?? ""),
+            creditsCharged: Number(r.creditsCharged ?? 0),
+            walletBalance: Number(r.walletBalance ?? 0),
+            auditId: String(r.auditId ?? ""),
+            ...(fundedBy === "sponsored" || fundedBy === "grant" || fundedBy === "purchase"
+                ? { fundedBy }
+                : {}),
+            ...(typeof r.sponsoredBy === "string" ? { sponsoredBy: r.sponsoredBy } : {}),
+            ...(typeof r.receiptId === "string" ? { receiptId: r.receiptId } : {}),
+        };
+    }
+    if (status === "failed") {
+        const err = r.error ?? {};
+        return {
+            jobId,
+            status: "failed",
+            error: {
+                code: String(err.code ?? "transcribe_failed"),
+                message: String(err.message ?? ""),
+            },
+        };
+    }
+    return { jobId, status: "running", elapsedSec: Number(r.elapsed_sec ?? 0) };
+}
 /**
  * Encode an ArrayBuffer as base64 in environments where `Buffer` is
  * not available (browser). Uses btoa over a binary string — safe for

package/dist/src/ethos.js

@@ -485,38 +485,72 @@ export class EthosClient {
      * Publish height=1 for an owner whose Ethos identity exists on
      * `api.aithos.be` (provisioned by `auth.signUp()` in alpha.6+) but who
      * has no editions yet. Builds the manifest from the staged ADD
-     * mutations on the public zone and POSTs `aithos.publish_ethos_edition`.
+     * mutations and POSTs `aithos.publish_ethos_edition`.
      *
-     * Limitations of the alpha.7 cut:
-     *   - Public zone only. Staged mutations on circle/self are rejected
-     *     with `ethos_first_edition_public_only` — those zones can be
-     *     populated in subsequent editions via the regular
-     *     `publishZoneEdit` path once the public zone has been seeded.
+     * Behaviour:
+     *   - All three zones (public / circle / self) are supported at
+     *     height=1 since `@aithos/protocol-client@>=0.1.0-alpha.14`. Circle
+     *     and self sections are sealed via the same DEK + HKDF wrap
+     *     machinery that the height>=2 path uses, so they're verifiable by
+     *     the existing reader path with no special-casing.
+     *   - If the caller staged only circle / self mutations (typical for
+     *     an app like Linkedone that writes a personality section straight
+     *     to `circle`), an `aithos-init` sentinel is auto-injected into
+     *     the public zone. This preserves the invariant that every Ethos
+     *     has a non-empty public zone at height=1 — which all resolution
+     *     flows (handle lookup, public crawl) depend on.
      *   - First-edition publishes don't accept update/delete mutations
      *     (there's nothing to update or delete yet) — those are rejected
      *     with `ethos_first_edition_invalid_op`.
+     *   - The `ethos_first_edition_public_only` error code is no longer
+     *     emitted; the bucket-and-auto-inject path replaces it.
      */
     async #publishFirstEditionOwner() {
         if (this.#actor.kind !== "owner") {
             // Defensive — caller already checked this branch.
             throw new AithosSDKError("ethos_invalid_actor", "expected owner actor");
         }
-        // Validate the staged operation set. First edition = ADDs on public
-        // zone only.
+        // Validate the staged operation set and bucket by zone. First
+        // edition = ADD mutations only; update / delete are rejected because
+        // there's no prior state to mutate.
         const publicAdds = [];
+        const circleAdds = [];
+        const selfAdds = [];
         for (const m of this.#mutations) {
             if (m.kind !== "add") {
                 throw new AithosSDKError("ethos_first_edition_invalid_op", `first edition: cannot ${m.kind} a section before any edition exists; only addSection is supported on a fresh Ethos`, { data: { mutation: m } });
             }
-            if (m.zone !== "public") {
-                throw new AithosSDKError("ethos_first_edition_public_only", `first edition: only the "public" zone is supported on a fresh Ethos; "${m.zone}" sections can be added after the first publish`, { data: { zone: m.zone } });
-            }
-            publicAdds.push({ section: m.section });
-        }
-        if (publicAdds.length === 0) {
+            if (m.zone === "public")
+                publicAdds.push(m.section);
+            else if (m.zone === "circle")
+                circleAdds.push(m.section);
+            else if (m.zone === "self")
+                selfAdds.push(m.section);
+        }
+        if (publicAdds.length === 0 &&
+            circleAdds.length === 0 &&
+            selfAdds.length === 0) {
             // Should never reach here — publish() short-circuits on empty
             // mutations. Belt-and-braces in case the contract drifts.
-            throw new AithosSDKError("ethos_first_edition_empty", "first edition: stage at least one public-zone section before publishing");
+            throw new AithosSDKError("ethos_first_edition_empty", "first edition: stage at least one section before publishing");
+        }
+        // Public zone invariant: every Ethos has a non-empty public zone at
+        // height=1. If the caller only staged encrypted-zone mutations
+        // (typical for apps like Linkedone that write straight to circle),
+        // auto-inject an `aithos-init` sentinel — identical in shape to
+        // what `ensureInitialized()` would produce if called explicitly.
+        if (publicAdds.length === 0) {
+            publicAdds.push({
+                id: "sec_" + randomHex(12),
+                title: "aithos-init",
+                body: "Ethos initialized.\n\n" +
+                    "This section is a sentinel created by `EthosClient.publish()` " +
+                    "to materialise the subject's first edition alongside the " +
+                    "encrypted-zone content the caller staged. It is safe to delete " +
+                    "or edit later — its only purpose is to satisfy the invariant " +
+                    "that every Ethos has a non-empty public zone at height=1.",
+                gamma_ref: "gamma_none_" + randomHex(24),
+            });
         }
         const identity = this.#actor.signers._unsafeStoredIdentity();
         const browserId = browserIdentityFromStored(identity);
@@ -524,14 +558,27 @@ export class EthosClient {
         const built = buildSignedFirstEditionFromSections({
             identity: browserId,
             signedDidDoc: signedDoc,
-            publicSections: publicAdds.map((a) => a.section),
+            publicSections: publicAdds,
+            ...(circleAdds.length > 0 ? { circleSections: circleAdds } : {}),
+            ...(selfAdds.length > 0 ? { selfSections: selfAdds } : {}),
         });
         const url = writeEndpoint();
+        const zonesPayload = {
+            public: { bytes_base64: bytesToBase64Padded(built.publicMarkdownBytes) },
+        };
+        if (built.circleBytes) {
+            zonesPayload.circle = {
+                bytes_base64: bytesToBase64Padded(built.circleBytes),
+            };
+        }
+        if (built.selfBytes) {
+            zonesPayload.self = {
+                bytes_base64: bytesToBase64Padded(built.selfBytes),
+            };
+        }
         const params = {
             manifest: built.manifest,
-            zones: {
-                public: { bytes_base64: bytesToBase64Padded(built.publicMarkdownBytes) },
-            },
+            zones: zonesPayload,
         };
         const envelope = buildSignedEnvelope({
             iss: browserId.did,
@@ -575,11 +622,16 @@ export class EthosClient {
         // take the regular next-edition path.
         this.#ethosHasNoEditionYet = false;
         this.#afterPublish();
+        const zonesPublished = ["public"];
+        if (built.circleBytes)
+            zonesPublished.push("circle");
+        if (built.selfBytes)
+            zonesPublished.push("self");
         return {
             editionHeight: 1,
             manifestHash: "", // protocol-client surfaces this on later editions; not on first
             subjectDid: browserId.did,
-            zonesPublished: ["public"],
+            zonesPublished,
         };
     }
 }

package/dist/src/index.d.ts

@@ -1,12 +1,14 @@
-export declare const VERSION = "0.1.0-alpha.42";
+export declare const VERSION = "0.1.0-alpha.44";
 export { AithosSDK } from "./sdk.js";
 export type { AithosSDKConfig } from "./types.js";
 export { AithosSDKError } from "./types.js";
 export { AithosRpcError } from "@aithos/protocol-client";
 export type { AithosSdkEndpoints } from "./endpoints.js";
 export { DEFAULT_SDK_ENDPOINTS } from "./endpoints.js";
-export type { ComputeMessage, ImageAspectRatio, ImageModelId, InvokeBedrockArgs, InvokeBedrockResult, InvokeBedrockVisionArgs, InvokeBedrockVisionResult, InvokeImageArgs, InvokeImageImage, InvokeImageResult, InvokeSegmentationArgs, InvokeSegmentationResult, SegmentPolygon, StopReason, } from "./compute.js";
+export type { ComputeMessage, ImageAspectRatio, ImageModelId, InvokeBedrockArgs, InvokeBedrockResult, InvokeBedrockVisionArgs, InvokeBedrockVisionResult, InvokeImageArgs, InvokeImageImage, InvokeImageResult, InvokeSegmentationArgs, InvokeSegmentationResult, SegmentPolygon, StopReason, TranscribeModelId, TranscribeProgressState, TranscribeSegment, TranscribeWord, InvokeTranscribeArgs, InvokeTranscribeResult, PrepareTranscribeArgs, PrepareTranscribeResult, StartTranscribeArgs, StartTranscribeResult, TranscribeStatusResult, TranscribeJobSummary, } from "./compute.js";
 export { ComputeNamespace } from "./compute.js";
+export type { LocalPendingEntry, LocalPendingStatus, TranscribeDraftMeta, TranscribeDraftRecord, } from "./transcribe-resilience.js";
+export { LocalPendingTranscribeTracker, TranscribeDraftStore, TranscribeDraftUnavailableError, } from "./transcribe-resilience.js";
 export type { CreditPackId, CreateTopupSessionArgs, CreateTopupSessionResult, GetBalanceArgs, GetBalanceResult, } from "./wallet.js";
 export { WalletNamespace } from "./wallet.js";
 export type { ComponentStyle, ExtractArgs, ExtractContent, ExtractData, ExtractForm, ExtractFormField, ExtractHeading, ExtractIconDeclaration, ExtractImage, ExtractLink, ExtractLogo, ExtractMeta, ExtractResult, ExtractSection, ExtractStructure, ExtractStyles, FetchAssetArgs, FetchAssetResult, PaletteEntry, VisualSignature, WebNamespaceDeps, } from "./web.js";

package/dist/src/index.js

@@ -17,7 +17,7 @@
 // Public types specific to the SDK (`AithosSDKConfig`, `AithosSDKError`)
 // are exported from here. Endpoint config (`AithosSdkEndpoints`,
 // `DEFAULT_SDK_ENDPOINTS`) likewise.
-export const VERSION = "0.1.0-alpha.42";
+export const VERSION = "0.1.0-alpha.44";
 export { AithosSDK } from "./sdk.js";
 export { AithosSDKError } from "./types.js";
 // Re-export protocol-client's JSON-RPC error type so consumers can
@@ -26,6 +26,7 @@ export { AithosSDKError } from "./types.js";
 export { AithosRpcError } from "@aithos/protocol-client";
 export { DEFAULT_SDK_ENDPOINTS } from "./endpoints.js";
 export { ComputeNamespace } from "./compute.js";
+export { LocalPendingTranscribeTracker, TranscribeDraftStore, TranscribeDraftUnavailableError, } from "./transcribe-resilience.js";
 export { WalletNamespace } from "./wallet.js";
 export { WebNamespace, WEB_EXTRACT_SCOPE } from "./web.js";
 // Sign-up, sign-in, sign-in-with-Google. Lives outside the AithosSDK

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

@@ -25,4 +25,5 @@
 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

@@ -27,4 +27,5 @@
 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