@opengeni/react 0.41.0 → 0.42.1

package/dist/{chunk-OMCFRWHL.js → chunk-UWYTCQWW.js}

@@ -20,6 +20,346 @@ import {
   cn
 } from "./chunk-TK7G6XLT.js";
 
+// src/voice-recording-store.ts
+var DEFAULT_DATABASE_NAME = "opengeni-voice-recordings-v1";
+var DATABASE_VERSION = 1;
+var MANIFEST_STORE = "recordings";
+var CHUNK_STORE = "chunks";
+var CHUNKS_BY_RECORDING = "by-recording";
+var VoiceRecordingStorageUnavailableError = class extends Error {
+  constructor() {
+    super("Durable voice recording storage is unavailable.");
+    this.name = "VoiceRecordingStorageUnavailableError";
+  }
+};
+var VoiceRecordingNotFoundError = class extends Error {
+  constructor(recordingId) {
+    super(`Voice recording ${recordingId} was not found.`);
+    this.name = "VoiceRecordingNotFoundError";
+  }
+};
+var VoiceRecordingChunkConflictError = class extends Error {
+  constructor(recordingId, chunkNumber) {
+    super(`Voice recording ${recordingId} chunk ${chunkNumber} conflicts with persisted audio.`);
+    this.name = "VoiceRecordingChunkConflictError";
+  }
+};
+var VoiceRecordingChunkSequenceError = class extends Error {
+  constructor(expected, received) {
+    super(`Expected voice recording chunk ${expected}, received ${received}.`);
+    this.name = "VoiceRecordingChunkSequenceError";
+  }
+};
+var VoiceRecordingOwnedError = class extends Error {
+  constructor(recordingId) {
+    super(`Voice recording ${recordingId} is active in another browser tab.`);
+    this.name = "VoiceRecordingOwnedError";
+  }
+};
+function createVoiceRecordingManifest(input) {
+  return {
+    version: 1,
+    recordingId: input.recordingId,
+    workspaceId: input.workspaceId,
+    createdAt: input.createdAt,
+    updatedAt: input.createdAt,
+    mimeType: input.mimeType,
+    codec: codecForMimeType(input.mimeType),
+    captureState: "capturing",
+    uploadState: "pending",
+    transcriptionState: "pending",
+    finalizationState: "pending",
+    ownerId: input.ownerId ?? null,
+    ownerHeartbeatAt: input.ownerId ? input.createdAt : null,
+    transcriptText: null,
+    nextChunkNumber: 0,
+    chunkCount: 0,
+    totalBytes: 0,
+    totalDurationMilliseconds: 0
+  };
+}
+async function prepareVoiceRecordingChunk(input) {
+  if (!Number.isSafeInteger(input.chunkNumber) || input.chunkNumber < 0) {
+    throw new VoiceRecordingChunkSequenceError(0, input.chunkNumber);
+  }
+  if (!Number.isFinite(input.startMilliseconds) || input.startMilliseconds < 0) {
+    throw new RangeError("Voice recording chunk start must be non-negative.");
+  }
+  if (!Number.isFinite(input.durationMilliseconds) || input.durationMilliseconds < 0) {
+    throw new RangeError("Voice recording chunk duration must be non-negative.");
+  }
+  const bytes = new Uint8Array(await input.audio.arrayBuffer());
+  if (bytes.byteLength === 0) throw new RangeError("Voice recording chunks cannot be empty.");
+  return {
+    recordingId: input.recordingId,
+    chunkNumber: input.chunkNumber,
+    capturedAt: input.capturedAt,
+    startMilliseconds: Math.round(input.startMilliseconds),
+    durationMilliseconds: Math.round(input.durationMilliseconds),
+    mimeType: input.mimeType,
+    codec: codecForMimeType(input.mimeType),
+    byteLength: bytes.byteLength,
+    sha256: await sha256Hex(bytes),
+    uploadState: "pending",
+    audio: input.audio
+  };
+}
+function planVoiceRecordingChunkCommit(input) {
+  const { manifest, chunk, existingChunk } = input;
+  if (manifest.recordingId !== chunk.recordingId) {
+    throw new VoiceRecordingChunkConflictError(chunk.recordingId, chunk.chunkNumber);
+  }
+  if (existingChunk) {
+    if (existingChunk.sha256 !== chunk.sha256 || existingChunk.byteLength !== chunk.byteLength || existingChunk.mimeType !== chunk.mimeType) {
+      throw new VoiceRecordingChunkConflictError(chunk.recordingId, chunk.chunkNumber);
+    }
+    return { manifest, chunk: existingChunk, deduplicated: true };
+  }
+  if (chunk.chunkNumber !== manifest.nextChunkNumber) {
+    throw new VoiceRecordingChunkSequenceError(manifest.nextChunkNumber, chunk.chunkNumber);
+  }
+  const updatedManifest = {
+    ...manifest,
+    updatedAt: chunk.capturedAt,
+    ownerHeartbeatAt: manifest.ownerId ? chunk.capturedAt : manifest.ownerHeartbeatAt,
+    nextChunkNumber: manifest.nextChunkNumber + 1,
+    chunkCount: manifest.chunkCount + 1,
+    totalBytes: manifest.totalBytes + chunk.byteLength,
+    totalDurationMilliseconds: Math.max(
+      manifest.totalDurationMilliseconds,
+      chunk.startMilliseconds + chunk.durationMilliseconds
+    )
+  };
+  return { manifest: updatedManifest, chunk, deduplicated: false };
+}
+var IndexedDbVoiceRecordingStore = class {
+  database;
+  constructor(options) {
+    const factory = options && "indexedDB" in options ? options.indexedDB : globalThis.indexedDB;
+    if (!factory) throw new VoiceRecordingStorageUnavailableError();
+    this.database = openDatabase(factory, options?.databaseName ?? DEFAULT_DATABASE_NAME);
+  }
+  async createManifest(manifest) {
+    const database = await this.database;
+    const transaction = database.transaction(MANIFEST_STORE, "readwrite");
+    transaction.objectStore(MANIFEST_STORE).add(manifest);
+    await transactionComplete(transaction);
+  }
+  async getManifest(recordingId) {
+    const database = await this.database;
+    const transaction = database.transaction(MANIFEST_STORE, "readonly");
+    const manifest = await requestResult(
+      transaction.objectStore(MANIFEST_STORE).get(recordingId)
+    );
+    await transactionComplete(transaction);
+    return manifest ? normalizeManifest(manifest) : null;
+  }
+  async listRecoverableManifests(workspaceId, ownership) {
+    const database = await this.database;
+    const transaction = database.transaction(MANIFEST_STORE, "readonly");
+    const manifests = await requestResult(
+      transaction.objectStore(MANIFEST_STORE).getAll()
+    );
+    await transactionComplete(transaction);
+    return manifests.map(normalizeManifest).filter(
+      (manifest) => manifest.workspaceId === workspaceId && manifest.captureState !== "discarded" && manifest.finalizationState !== "handed-off" && manifestAvailableToOwner(manifest, ownership)
+    ).sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+  }
+  async claimManifest(recordingId, ownerId, claimedAt, staleBefore) {
+    const database = await this.database;
+    const transaction = database.transaction(MANIFEST_STORE, "readwrite");
+    const manifests = transaction.objectStore(MANIFEST_STORE);
+    const stored = await requestResult(
+      manifests.get(recordingId)
+    );
+    if (!stored) {
+      transaction.abort();
+      throw new VoiceRecordingNotFoundError(recordingId);
+    }
+    const manifest = normalizeManifest(stored);
+    if (manifest.finalizationState === "handed-off" || !manifestAvailableToOwner(manifest, { ownerId, staleBefore })) {
+      transaction.abort();
+      throw new VoiceRecordingOwnedError(recordingId);
+    }
+    const updated = {
+      ...manifest,
+      captureState: manifest.captureState === "capturing" ? "stopped" : manifest.captureState,
+      ownerId,
+      ownerHeartbeatAt: claimedAt,
+      updatedAt: claimedAt
+    };
+    manifests.put(updated);
+    await transactionComplete(transaction);
+    return updated;
+  }
+  async listChunks(recordingId) {
+    const database = await this.database;
+    const transaction = database.transaction(CHUNK_STORE, "readonly");
+    const chunks = await requestResult(
+      transaction.objectStore(CHUNK_STORE).index(CHUNKS_BY_RECORDING).getAll(recordingId)
+    );
+    await transactionComplete(transaction);
+    return chunks.sort((left, right) => left.chunkNumber - right.chunkNumber);
+  }
+  async persistChunk(input) {
+    const chunk = await prepareVoiceRecordingChunk(input);
+    const database = await this.database;
+    const transaction = database.transaction([MANIFEST_STORE, CHUNK_STORE], "readwrite");
+    const manifests = transaction.objectStore(MANIFEST_STORE);
+    const chunks = transaction.objectStore(CHUNK_STORE);
+    const [manifest, existingChunk] = await Promise.all([
+      requestResult(manifests.get(input.recordingId)),
+      requestResult(
+        chunks.get([input.recordingId, input.chunkNumber])
+      )
+    ]);
+    if (!manifest) {
+      transaction.abort();
+      throw new VoiceRecordingNotFoundError(input.recordingId);
+    }
+    const normalizedManifest = normalizeManifest(manifest);
+    assertManifestOwnership(normalizedManifest, input.ownerId);
+    const result = planVoiceRecordingChunkCommit({
+      manifest: normalizedManifest,
+      chunk,
+      existingChunk: existingChunk ?? null
+    });
+    if (!result.deduplicated) {
+      chunks.add(result.chunk);
+      manifests.put(result.manifest);
+    }
+    await transactionComplete(transaction);
+    return result;
+  }
+  async updateManifest(recordingId, update, updatedAt, ownerId) {
+    const database = await this.database;
+    const transaction = database.transaction(MANIFEST_STORE, "readwrite");
+    const manifests = transaction.objectStore(MANIFEST_STORE);
+    const manifest = await requestResult(
+      manifests.get(recordingId)
+    );
+    if (!manifest) {
+      transaction.abort();
+      throw new VoiceRecordingNotFoundError(recordingId);
+    }
+    const normalizedManifest = normalizeManifest(manifest);
+    assertManifestOwnership(normalizedManifest, ownerId);
+    const updated = { ...normalizedManifest, ...update, updatedAt };
+    manifests.put(updated);
+    await transactionComplete(transaction);
+    return updated;
+  }
+  async discard(recordingId, ownerId) {
+    const database = await this.database;
+    const transaction = database.transaction([MANIFEST_STORE, CHUNK_STORE], "readwrite");
+    const manifests = transaction.objectStore(MANIFEST_STORE);
+    const stored = await requestResult(
+      manifests.get(recordingId)
+    );
+    if (!stored) {
+      transaction.abort();
+      throw new VoiceRecordingNotFoundError(recordingId);
+    }
+    assertManifestOwnership(normalizeManifest(stored), ownerId);
+    const chunks = transaction.objectStore(CHUNK_STORE);
+    const chunkKeys = await requestResult(
+      chunks.index(CHUNKS_BY_RECORDING).getAllKeys(recordingId)
+    );
+    for (const key of chunkKeys) chunks.delete(key);
+    manifests.delete(recordingId);
+    await transactionComplete(transaction);
+  }
+  async cleanupHandedOffManifests(ownership) {
+    const database = await this.database;
+    const transaction = database.transaction([MANIFEST_STORE, CHUNK_STORE], "readwrite");
+    const manifests = transaction.objectStore(MANIFEST_STORE);
+    const chunks = transaction.objectStore(CHUNK_STORE);
+    const handedOff = (await requestResult(manifests.getAll())).map(normalizeManifest).filter(
+      (manifest) => manifest.finalizationState === "handed-off" && manifestAvailableToOwner(manifest, ownership)
+    );
+    const chunkKeys = await Promise.all(
+      handedOff.map(
+        (manifest) => requestResult(
+          chunks.index(CHUNKS_BY_RECORDING).getAllKeys(manifest.recordingId)
+        )
+      )
+    );
+    handedOff.forEach((manifest, index) => {
+      for (const key of chunkKeys[index] ?? []) chunks.delete(key);
+      manifests.delete(manifest.recordingId);
+    });
+    await transactionComplete(transaction);
+    return handedOff.length;
+  }
+  async close() {
+    (await this.database).close();
+  }
+};
+function normalizeManifest(manifest) {
+  return {
+    ...manifest,
+    ownerId: manifest.ownerId ?? null,
+    ownerHeartbeatAt: manifest.ownerHeartbeatAt ?? null,
+    transcriptText: manifest.transcriptText ?? null
+  };
+}
+function manifestAvailableToOwner(manifest, ownership) {
+  if (!manifest.ownerId) return true;
+  if (!ownership) return false;
+  if (manifest.ownerId === ownership.ownerId) return true;
+  return !manifest.ownerHeartbeatAt || manifest.ownerHeartbeatAt <= ownership.staleBefore;
+}
+function assertManifestOwnership(manifest, ownerId) {
+  if (manifest.ownerId !== (ownerId ?? null)) {
+    throw new VoiceRecordingOwnedError(manifest.recordingId);
+  }
+}
+function codecForMimeType(mimeType) {
+  const match = /(?:^|;)\s*codecs?\s*=\s*"?([^;"]+)/iu.exec(mimeType);
+  return match?.[1]?.trim().toLowerCase() ?? null;
+}
+async function sha256Hex(bytes) {
+  const digest = await crypto.subtle.digest("SHA-256", Uint8Array.from(bytes).buffer);
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function openDatabase(factory, name) {
+  return new Promise((resolve, reject) => {
+    const request = factory.open(name, DATABASE_VERSION);
+    request.onupgradeneeded = () => {
+      const database = request.result;
+      if (!database.objectStoreNames.contains(MANIFEST_STORE)) {
+        database.createObjectStore(MANIFEST_STORE, { keyPath: "recordingId" });
+      }
+      if (!database.objectStoreNames.contains(CHUNK_STORE)) {
+        const chunks = database.createObjectStore(CHUNK_STORE, {
+          keyPath: ["recordingId", "chunkNumber"]
+        });
+        chunks.createIndex(CHUNKS_BY_RECORDING, "recordingId", { unique: false });
+      }
+    };
+    request.onsuccess = () => {
+      const database = request.result;
+      database.onversionchange = () => database.close();
+      resolve(database);
+    };
+    request.onerror = () => reject(request.error ?? new Error("Failed to open voice storage."));
+    request.onblocked = () => reject(new Error("Voice recording storage upgrade is blocked."));
+  });
+}
+function requestResult(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("Voice recording storage failed."));
+  });
+}
+function transactionComplete(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onabort = () => reject(transaction.error ?? new Error("Voice storage aborted."));
+    transaction.onerror = () => reject(transaction.error ?? new Error("Voice storage failed."));
+  });
+}
+
 // src/hooks/use-transcription.ts
 import {
   authorizeTranscriptionAdapter,
@@ -590,7 +930,192 @@ function transcriptionPolicyRevision(policy, selection) {
 
 // src/hooks/use-voice-input.ts
 import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/voice-recording-owner.ts
+var VOICE_RECORDING_OWNER_SESSION_KEY = "opengeni.voice-recording-owner.v1";
+var VOICE_RECORDING_OWNER_LOCK_PREFIX = "opengeni.voice-recording-owner:";
+var VOICE_RECORDING_OWNER_CHANNEL = "opengeni.voice-recording-owner.v1";
+var OWNER_LOCK_RELOAD_GRACE_MILLISECONDS = 250;
+var OWNER_LOCK_RELOAD_NAVIGATION_MILLISECONDS = 5e3;
+var OWNER_BROADCAST_PROBE_MILLISECONDS = 100;
+var OWNER_BROADCAST_RELOAD_ATTEMPTS = 10;
+var sharedLeasePromise = null;
+var sharedLeaseConsumers = 0;
+async function acquireDefaultVoiceRecordingOwnerLease() {
+  sharedLeaseConsumers += 1;
+  sharedLeasePromise ??= createUnderlyingOwnerLease();
+  let underlying;
+  try {
+    underlying = await sharedLeasePromise;
+  } catch (error) {
+    sharedLeaseConsumers -= 1;
+    if (sharedLeaseConsumers === 0) sharedLeasePromise = null;
+    throw error;
+  }
+  let released = false;
+  return {
+    ownerId: underlying.ownerId,
+    release: () => {
+      if (released) return;
+      released = true;
+      sharedLeaseConsumers = Math.max(0, sharedLeaseConsumers - 1);
+      if (sharedLeaseConsumers === 0) {
+        sharedLeasePromise = null;
+        underlying.release();
+      }
+    }
+  };
+}
+async function createUnderlyingOwnerLease() {
+  const candidate = readSessionOwnerId() ?? crypto.randomUUID();
+  const reloadNavigation = isReloadNavigation();
+  if (hasWebLocks()) {
+    const retained = await tryAcquireWebLock(
+      candidate,
+      reloadNavigation ? OWNER_LOCK_RELOAD_NAVIGATION_MILLISECONDS : OWNER_LOCK_RELOAD_GRACE_MILLISECONDS
+    );
+    if (retained) {
+      writeSessionOwnerId(candidate);
+      return retained;
+    }
+    const rotated = crypto.randomUUID();
+    writeSessionOwnerId(rotated);
+    const acquired = await tryAcquireWebLock(rotated, OWNER_LOCK_RELOAD_GRACE_MILLISECONDS);
+    if (acquired) return acquired;
+  }
+  const broadcastLease = await tryAcquireBroadcastLease(
+    readSessionOwnerId() ?? candidate,
+    reloadNavigation ? OWNER_BROADCAST_RELOAD_ATTEMPTS : 0
+  );
+  if (broadcastLease) return broadcastLease;
+  const ownerId = crypto.randomUUID();
+  writeSessionOwnerId(ownerId);
+  return { ownerId, release: () => void 0 };
+}
+function hasWebLocks() {
+  return typeof navigator !== "undefined" && navigator.locks !== null && navigator.locks !== void 0 && typeof navigator.locks.request === "function";
+}
+async function tryAcquireWebLock(ownerId, waitMilliseconds) {
+  if (!hasWebLocks()) return null;
+  return await new Promise((resolve) => {
+    const controller = new AbortController();
+    let settled = false;
+    const settle = (lease) => {
+      if (settled) return;
+      settled = true;
+      resolve(lease);
+    };
+    const timeout = setTimeout(() => controller.abort(), waitMilliseconds);
+    void navigator.locks.request(
+      `${VOICE_RECORDING_OWNER_LOCK_PREFIX}${ownerId}`,
+      { mode: "exclusive", signal: controller.signal },
+      async () => {
+        clearTimeout(timeout);
+        let releaseLock = null;
+        const held = new Promise((release) => {
+          releaseLock = release;
+        });
+        settle({
+          ownerId,
+          release: () => releaseLock?.()
+        });
+        await held;
+      }
+    ).catch(() => {
+      clearTimeout(timeout);
+      settle(null);
+    });
+  });
+}
+async function tryAcquireBroadcastLease(initialOwnerId, retainCandidateAttempts) {
+  const BroadcastChannelConstructor = typeof window !== "undefined" ? window.BroadcastChannel : void 0;
+  if (!BroadcastChannelConstructor) return null;
+  let ownerId = initialOwnerId;
+  for (let attempt = 0; attempt < retainCandidateAttempts + 3; attempt += 1) {
+    const channel = new BroadcastChannelConstructor(VOICE_RECORDING_OWNER_CHANNEL);
+    const instanceId = crypto.randomUUID();
+    let occupied = false;
+    const onMessage = (event) => {
+      const message = ownerCoordinationMessage(event.data);
+      if (!message || message.ownerId !== ownerId) return;
+      if (message.type === "voice-recording-owner.probe") {
+        if (message.instanceId === instanceId) return;
+        channel.postMessage({
+          type: "voice-recording-owner.occupied",
+          ownerId,
+          targetInstanceId: message.instanceId
+        });
+        return;
+      }
+      if (message.targetInstanceId === instanceId) occupied = true;
+    };
+    channel.addEventListener("message", onMessage);
+    channel.postMessage({
+      type: "voice-recording-owner.probe",
+      ownerId,
+      instanceId
+    });
+    await delay(OWNER_BROADCAST_PROBE_MILLISECONDS);
+    if (!occupied) {
+      writeSessionOwnerId(ownerId);
+      return {
+        ownerId,
+        release: () => {
+          channel.removeEventListener("message", onMessage);
+          channel.close();
+        }
+      };
+    }
+    channel.removeEventListener("message", onMessage);
+    channel.close();
+    if (attempt < retainCandidateAttempts) continue;
+    ownerId = crypto.randomUUID();
+    writeSessionOwnerId(ownerId);
+  }
+  return null;
+}
+function isReloadNavigation() {
+  if (typeof performance === "undefined") return false;
+  return performance.getEntriesByType("navigation").some((entry) => {
+    return "type" in entry && entry.type === "reload";
+  });
+}
+function ownerCoordinationMessage(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  if (candidate.type === "voice-recording-owner.probe" && typeof candidate.ownerId === "string" && typeof candidate.instanceId === "string") {
+    return candidate;
+  }
+  if (candidate.type === "voice-recording-owner.occupied" && typeof candidate.ownerId === "string" && typeof candidate.targetInstanceId === "string") {
+    return candidate;
+  }
+  return null;
+}
+function readSessionOwnerId() {
+  try {
+    return typeof window === "undefined" ? null : window.sessionStorage.getItem(VOICE_RECORDING_OWNER_SESSION_KEY);
+  } catch {
+    return null;
+  }
+}
+function writeSessionOwnerId(ownerId) {
+  try {
+    window.sessionStorage.setItem(VOICE_RECORDING_OWNER_SESSION_KEY, ownerId);
+  } catch {
+  }
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+// src/hooks/use-voice-input.ts
+var VOICE_RECORDING_TIMESLICE_MILLISECONDS = 5e3;
+var VOICE_RECORDING_OWNER_HEARTBEAT_MILLISECONDS = 5e3;
+var VOICE_RECORDING_OWNER_STALE_MILLISECONDS = 3e4;
+var VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS = 600;
 var MIME_PREFERENCES = ["audio/webm;codecs=opus", "audio/mp4", "audio/ogg;codecs=opus"];
+var createDefaultVoiceRecordingId = () => crypto.randomUUID();
+var currentDate = () => /* @__PURE__ */ new Date();
 function useVoiceInput({
   client,
   workspaceId,
@@ -599,120 +1124,738 @@ function useVoiceInput({
   value,
   setValue,
   focusInput,
-  disabled = false
+  disabled = false,
+  createRecordingStore,
+  createRecordingId = createDefaultVoiceRecordingId,
+  createOwnerId,
+  now = currentDate
 }) {
   const [status, setStatus] = useState2("idle");
   const [error, setError] = useState2(null);
   const [stream, setStream] = useState2(null);
+  const [recordingId, setRecordingId] = useState2(null);
+  const [durationSeconds, setDurationSeconds] = useState2(0);
+  const [locallySaved, setLocallySaved] = useState2(false);
+  const [storageAvailable, setStorageAvailable] = useState2(
+    () => Boolean(createRecordingStore) || typeof globalThis.indexedDB !== "undefined"
+  );
+  const createRecordingStoreRef = useRef2(createRecordingStore);
+  createRecordingStoreRef.current = createRecordingStore;
+  const nowRef = useRef2(now);
+  nowRef.current = now;
+  const readNow = useCallback2(() => nowRef.current(), []);
   const generationRef = useRef2(0);
+  const workspaceIdRef = useRef2(workspaceId);
+  const ownerIdRef = useRef2(null);
+  const ownerLeaseRef = useRef2(null);
+  const ownerIdPromiseRef = useRef2(null);
+  const createOwnerIdRef = useRef2(createOwnerId);
   const recorderRef = useRef2(null);
   const streamRef = useRef2(null);
   const timerRef = useRef2(null);
+  const ownerHeartbeatTimerRef = useRef2(null);
   const controllerRef = useRef2(null);
   const valueRef = useRef2(value);
+  const storeRef = useRef2(null);
+  const storePromiseRef = useRef2(null);
+  const ownsStoreRef = useRef2(false);
+  const manifestRef = useRef2(null);
+  const persistenceQueueRef = useRef2(Promise.resolve());
+  const persistenceErrorRef = useRef2(null);
+  const captureLimitErrorRef = useRef2(null);
+  const captureSettledRef = useRef2(Promise.resolve());
+  const resolveCaptureSettledRef = useRef2(null);
+  const statusRef = useRef2(status);
   valueRef.current = value;
-  const clearRuntime = useCallback2(() => {
+  statusRef.current = status;
+  workspaceIdRef.current = workspaceId;
+  const ensureOwnerId = useCallback2(async () => {
+    if (ownerIdRef.current) return ownerIdRef.current;
+    ownerIdPromiseRef.current ??= (async () => {
+      const injectedOwnerId = createOwnerIdRef.current?.();
+      if (injectedOwnerId) {
+        ownerIdRef.current = injectedOwnerId;
+        return injectedOwnerId;
+      }
+      const lease = await acquireDefaultVoiceRecordingOwnerLease();
+      ownerLeaseRef.current = lease;
+      ownerIdRef.current = lease.ownerId;
+      return lease.ownerId;
+    })();
+    return await ownerIdPromiseRef.current;
+  }, []);
+  const stopOwnerHeartbeat = useCallback2(() => {
+    if (ownerHeartbeatTimerRef.current) clearInterval(ownerHeartbeatTimerRef.current);
+    ownerHeartbeatTimerRef.current = null;
+  }, []);
+  const clearCaptureRuntime = useCallback2((expectedStream) => {
+    const captureStream = expectedStream ?? streamRef.current;
+    captureStream?.getTracks().forEach((track) => track.stop());
+    if (expectedStream && streamRef.current !== expectedStream) return;
     if (timerRef.current) clearTimeout(timerRef.current);
     timerRef.current = null;
-    streamRef.current?.getTracks().forEach((track) => track.stop());
     streamRef.current = null;
     recorderRef.current = null;
     setStream(null);
   }, []);
-  const cancel = useCallback2(() => {
-    generationRef.current += 1;
-    controllerRef.current?.abort();
-    controllerRef.current = null;
-    const recorder = recorderRef.current;
-    clearRuntime();
-    if (recorder && recorder.state !== "inactive") recorder.stop();
-    setStatus("idle");
-    setError(null);
-    focusInput();
-  }, [clearRuntime, focusInput]);
-  const stop = () => {
+  const clearVisibleRecording = useCallback2(() => {
+    stopOwnerHeartbeat();
+    manifestRef.current = null;
+    setRecordingId(null);
+    setDurationSeconds(0);
+    setLocallySaved(false);
+  }, [stopOwnerHeartbeat]);
+  const ensureStore = useCallback2(async () => {
+    if (storeRef.current) return storeRef.current;
+    if (!storePromiseRef.current) {
+      storePromiseRef.current = Promise.resolve().then(() => {
+        const factory = createRecordingStoreRef.current;
+        const store = factory?.() ?? new IndexedDbVoiceRecordingStore();
+        ownsStoreRef.current = factory === void 0;
+        storeRef.current = store;
+        setStorageAvailable(true);
+        return store;
+      });
+    }
+    try {
+      return await storePromiseRef.current;
+    } catch (reason) {
+      storePromiseRef.current = null;
+      if (reason instanceof VoiceRecordingStorageUnavailableError) setStorageAvailable(false);
+      throw reason;
+    }
+  }, []);
+  const rememberManifest = useCallback2((manifest) => {
+    manifestRef.current = manifest;
+    setRecordingId(manifest.recordingId);
+    setDurationSeconds(manifest.totalDurationMilliseconds / 1e3);
+    setLocallySaved(manifest.chunkCount > 0);
+  }, []);
+  const beginOwnerHeartbeat = useCallback2(
+    (manifest) => {
+      stopOwnerHeartbeat();
+      ownerHeartbeatTimerRef.current = setInterval(() => {
+        if (manifestRef.current?.recordingId !== manifest.recordingId || manifestRef.current.ownerId !== ownerIdRef.current) {
+          stopOwnerHeartbeat();
+          return;
+        }
+        const updatedAt = readNow().toISOString();
+        void ensureStore().then(
+          (store) => store.updateManifest(
+            manifest.recordingId,
+            { ownerHeartbeatAt: updatedAt },
+            updatedAt,
+            ownerIdRef.current ?? void 0
+          )
+        ).then((updated) => {
+          if (manifestRef.current?.recordingId === updated.recordingId) {
+            manifestRef.current = updated;
+          }
+        }).catch(() => void 0);
+      }, VOICE_RECORDING_OWNER_HEARTBEAT_MILLISECONDS);
+    },
+    [ensureStore, readNow, stopOwnerHeartbeat]
+  );
+  const preserveForRetry = useCallback2(
+    async (manifest, code, generation) => {
+      if (generation !== generationRef.current) return;
+      rememberManifest(manifest);
+      const transcriptReady = manifest.finalizationState === "transcript-ready" && manifest.transcriptText !== null;
+      setStatus(transcriptReady ? "transcript-ready" : code ? "error" : "recovered");
+      setError(transcriptReady ? "handoff_uncertain" : code);
+      focusInput();
+    },
+    [focusInput, rememberManifest]
+  );
+  const updateManifestBestEffort = useCallback2(
+    async (manifest, update) => {
+      try {
+        return await (await ensureStore()).updateManifest(
+          manifest.recordingId,
+          update,
+          readNow().toISOString(),
+          ownerIdRef.current ?? void 0
+        );
+      } catch {
+        return manifest;
+      }
+    },
+    [ensureStore, readNow]
+  );
+  const loadNextRecoverable = useCallback2(
+    async (generation) => {
+      const active = () => generation === generationRef.current && workspaceIdRef.current === workspaceId;
+      const [store, ownerId] = await Promise.all([ensureStore(), ensureOwnerId()]);
+      if (!active()) return;
+      const staleBefore = new Date(
+        readNow().getTime() - VOICE_RECORDING_OWNER_STALE_MILLISECONDS
+      ).toISOString();
+      await store.cleanupHandedOffManifests({ ownerId, staleBefore }).catch(() => void 0);
+      if (!active()) return;
+      const manifests = await store.listRecoverableManifests(workspaceId, {
+        ownerId,
+        staleBefore
+      });
+      if (!active()) return;
+      for (const candidate of manifests) {
+        try {
+          const claimedAt = readNow().toISOString();
+          const claimed = await store.claimManifest(
+            candidate.recordingId,
+            ownerId,
+            claimedAt,
+            staleBefore
+          );
+          if (!active()) {
+            await store.updateManifest(
+              claimed.recordingId,
+              { ownerId: null, ownerHeartbeatAt: null },
+              readNow().toISOString(),
+              ownerId
+            ).catch(() => void 0);
+            return;
+          }
+          rememberManifest(claimed);
+          beginOwnerHeartbeat(claimed);
+          setStatus(
+            claimed.finalizationState === "transcript-ready" && claimed.transcriptText !== null ? "transcript-ready" : "recovered"
+          );
+          setError(null);
+          return;
+        } catch (reason) {
+          if (reason instanceof VoiceRecordingOwnedError) continue;
+          throw reason;
+        }
+      }
+      if (active() && !manifestRef.current) {
+        setStatus("idle");
+        setError(null);
+      }
+    },
+    [beginOwnerHeartbeat, ensureOwnerId, ensureStore, readNow, rememberManifest, workspaceId]
+  );
+  const finalizePersistedRecording = useCallback2(
+    async (generation) => {
+      const manifest = manifestRef.current;
+      const maxSizeBytes = capability?.maxSizeBytes;
+      if (!manifest || !client || !maxSizeBytes || manifest.workspaceId !== workspaceId) return;
+      const controller = new AbortController();
+      controllerRef.current?.abort();
+      controllerRef.current = controller;
+      const active = () => generation === generationRef.current && workspaceIdRef.current === workspaceId && !controller.signal.aborted && manifestRef.current?.recordingId === manifest.recordingId && manifestRef.current.workspaceId === workspaceId;
+      let transcribing = manifest;
+      try {
+        const store = await ensureStore();
+        if (!active()) return;
+        transcribing = await store.updateManifest(
+          manifest.recordingId,
+          {
+            captureState: "stopped",
+            uploadState: "syncing",
+            transcriptionState: "transcribing",
+            ownerHeartbeatAt: readNow().toISOString()
+          },
+          readNow().toISOString(),
+          ownerIdRef.current ?? void 0
+        );
+        if (!active()) return;
+        rememberManifest(transcribing);
+        setStatus("transcribing");
+        setError(null);
+        if (transcribing.totalBytes > maxSizeBytes) {
+          throw { code: "too_large" };
+        }
+        const chunks = await store.listChunks(transcribing.recordingId);
+        if (!active()) return;
+        if (chunks.length === 0) {
+          const retained = await store.updateManifest(
+            transcribing.recordingId,
+            { uploadState: "retrying", transcriptionState: "retrying" },
+            readNow().toISOString(),
+            ownerIdRef.current ?? void 0
+          );
+          if (!active()) return;
+          await preserveForRetry(retained, "invalid_audio", generation);
+          return;
+        }
+        const audio = new Blob(
+          chunks.sort((left, right) => left.chunkNumber - right.chunkNumber).map((chunk) => chunk.audio),
+          { type: transcribing.mimeType }
+        );
+        if (!active()) return;
+        if (audio.size > maxSizeBytes) throw { code: "too_large" };
+        const response = await client.transcribeAudio(workspaceId, {
+          audio,
+          mimeType: audio.type,
+          durationSeconds: transcribing.totalDurationMilliseconds / 1e3,
+          signal: controller.signal
+        });
+        if (!active()) return;
+        const ready = await store.updateManifest(
+          transcribing.recordingId,
+          {
+            uploadState: "complete",
+            transcriptionState: "complete",
+            finalizationState: "transcript-ready",
+            transcriptText: response.text,
+            ownerHeartbeatAt: readNow().toISOString()
+          },
+          readNow().toISOString(),
+          ownerIdRef.current ?? void 0
+        );
+        if (!active()) return;
+        rememberManifest(ready);
+        const next = appendFinalTranscript(valueRef.current, response.text);
+        if (next !== valueRef.current) {
+          valueRef.current = next;
+          setValue(next);
+        }
+        let handedOff;
+        try {
+          handedOff = await store.updateManifest(
+            ready.recordingId,
+            { finalizationState: "handed-off" },
+            readNow().toISOString(),
+            ownerIdRef.current ?? void 0
+          );
+        } catch {
+          if (!active()) return;
+          rememberManifest(ready);
+          setStatus("transcript-ready");
+          setError("handoff_uncertain");
+          focusInput();
+          return;
+        }
+        if (!active()) return;
+        rememberManifest(handedOff);
+        await store.discard(handedOff.recordingId, ownerIdRef.current ?? void 0).catch(() => void 0);
+        if (!active()) return;
+        clearVisibleRecording();
+        setStatus("idle");
+        setError(null);
+        focusInput();
+        await loadNextRecoverable(generation);
+      } catch (reason) {
+        if (!active()) return;
+        const retained = await updateManifestBestEffort(transcribing, {
+          uploadState: "retrying",
+          transcriptionState: "retrying"
+        });
+        if (!active()) return;
+        await preserveForRetry(
+          retained,
+          controller.signal.aborted ? null : errorCode(reason),
+          generation
+        );
+      } finally {
+        if (controllerRef.current === controller) controllerRef.current = null;
+      }
+    },
+    [
+      capability?.maxSizeBytes,
+      clearVisibleRecording,
+      client,
+      ensureStore,
+      focusInput,
+      loadNextRecoverable,
+      readNow,
+      preserveForRetry,
+      rememberManifest,
+      setValue,
+      updateManifestBestEffort,
+      workspaceId
+    ]
+  );
+  const stop = useCallback2(() => {
     const recorder = recorderRef.current;
     if (!recorder || recorder.state === "inactive") return;
     if (timerRef.current) clearTimeout(timerRef.current);
     timerRef.current = null;
-    setStatus("transcribing");
+    setStatus("saving");
     recorder.stop();
-  };
-  const start = async () => {
-    if (disabled || !client || !enabled || !capability?.available || status === "requesting-permission" || status === "recording" || status === "transcribing" || !navigator.mediaDevices?.getUserMedia || typeof MediaRecorder === "undefined") {
+  }, []);
+  const start = useCallback2(async () => {
+    if (disabled || !client || !enabled || !capability?.available || manifestRef.current !== null || status === "requesting-permission" || status === "recording" || status === "saving" || status === "transcribing" || !navigator.mediaDevices?.getUserMedia || typeof MediaRecorder === "undefined") {
+      return false;
+    }
+    const prerequisiteGeneration = generationRef.current;
+    let store;
+    let ownerId;
+    try {
+      [store, ownerId] = await Promise.all([ensureStore(), ensureOwnerId()]);
+    } catch (reason) {
+      setStatus("error");
+      setError(
+        reason instanceof VoiceRecordingStorageUnavailableError ? "storage_unavailable" : errorCode(reason)
+      );
+      return false;
+    }
+    if (prerequisiteGeneration !== generationRef.current || workspaceIdRef.current !== workspaceId || ownerIdRef.current !== ownerId || manifestRef.current !== null || statusRef.current === "requesting-permission" || statusRef.current === "recording" || statusRef.current === "saving" || statusRef.current === "transcribing") {
       return false;
     }
-    const voiceClient = client;
     const generation = ++generationRef.current;
+    const startAttemptIsCurrent = () => generation === generationRef.current && workspaceIdRef.current === workspaceId && ownerIdRef.current === ownerId;
+    let attemptStream = null;
+    let attemptRecorder = null;
+    let attemptPersistenceQueue = Promise.resolve();
+    let attemptPersistenceError = null;
+    let attemptCaptureLimitError = null;
+    const attemptCaptureSettlement = { resolve: null };
+    const attemptManifest = { current: null };
+    let attemptNextChunkNumber = 0;
+    let attemptLastChunkEndMilliseconds = 0;
+    let attemptRecordingStartedAt = 0;
+    const attemptOwnsSharedCapture = () => startAttemptIsCurrent() && attemptStream !== null && streamRef.current === attemptStream && attemptRecorder !== null && recorderRef.current === attemptRecorder && attemptManifest.current !== null && manifestRef.current?.recordingId === attemptManifest.current.recordingId && manifestRef.current.workspaceId === workspaceId && manifestRef.current.ownerId === ownerId;
     setStatus("requesting-permission");
     setError(null);
+    let acquiredStream = null;
+    let recorderStarted = false;
     try {
       const mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
-      if (generation !== generationRef.current) {
+      acquiredStream = mediaStream;
+      attemptStream = mediaStream;
+      if (!startAttemptIsCurrent()) {
         mediaStream.getTracks().forEach((track) => track.stop());
         return false;
       }
+      streamRef.current = mediaStream;
+      setStream(mediaStream);
       const mimeType = chooseMimeType(capability.acceptedMimeTypes);
       const recorder = new MediaRecorder(mediaStream, mimeType ? { mimeType } : void 0);
-      const chunks = [];
-      const startedAt = Date.now();
-      streamRef.current = mediaStream;
+      attemptRecorder = recorder;
+      const createdAt = readNow();
+      const manifest = createVoiceRecordingManifest({
+        recordingId: createRecordingId(),
+        workspaceId,
+        mimeType: recorder.mimeType || mimeType || "audio/webm",
+        createdAt: createdAt.toISOString(),
+        ownerId
+      });
+      attemptManifest.current = manifest;
+      await store.createManifest(manifest);
+      if (!startAttemptIsCurrent()) {
+        await store.discard(manifest.recordingId, ownerId);
+        clearCaptureRuntime(mediaStream);
+        return false;
+      }
+      rememberManifest(manifest);
+      beginOwnerHeartbeat(manifest);
+      persistenceQueueRef.current = attemptPersistenceQueue;
+      persistenceErrorRef.current = null;
+      captureLimitErrorRef.current = null;
       recorderRef.current = recorder;
-      setStream(mediaStream);
       recorder.ondataavailable = (event) => {
-        if (event.data.size > 0) chunks.push(event.data);
-      };
-      recorder.onstop = () => {
-        clearRuntime();
-        if (generation !== generationRef.current) return;
-        const audio = new Blob(chunks, { type: recorder.mimeType || mimeType || "audio/webm" });
-        if (audio.size === 0) {
-          setStatus("error");
-          setError("invalid_audio");
+        if (event.data.size === 0 || attemptPersistenceError || attemptCaptureLimitError) {
           return;
         }
-        const controller = new AbortController();
-        controllerRef.current = controller;
-        void voiceClient.transcribeAudio(workspaceId, {
-          audio,
-          mimeType: audio.type,
-          durationSeconds: Math.max(0, (Date.now() - startedAt) / 1e3),
-          signal: controller.signal
-        }).then((response) => {
-          if (generation !== generationRef.current || controller.signal.aborted) return;
-          const next = appendFinalTranscript(valueRef.current, response.text);
-          if (next !== valueRef.current) {
-            valueRef.current = next;
-            setValue(next);
+        const chunkNumber = attemptNextChunkNumber++;
+        const elapsed = Math.max(0, readNow().getTime() - attemptRecordingStartedAt);
+        const eventTimecode = Number.isFinite(event.timecode) ? Math.max(0, event.timecode) : 0;
+        const endMilliseconds = Math.max(attemptLastChunkEndMilliseconds, eventTimecode, elapsed);
+        const startMilliseconds = attemptLastChunkEndMilliseconds;
+        const durationMilliseconds = Math.max(0, endMilliseconds - startMilliseconds);
+        attemptLastChunkEndMilliseconds = endMilliseconds;
+        attemptPersistenceQueue = attemptPersistenceQueue.then(async () => {
+          const result = await store.persistChunk({
+            recordingId: manifest.recordingId,
+            ownerId,
+            chunkNumber,
+            capturedAt: readNow().toISOString(),
+            startMilliseconds,
+            durationMilliseconds,
+            mimeType: manifest.mimeType,
+            audio: event.data
+          });
+          if (!startAttemptIsCurrent()) return;
+          rememberManifest(result.manifest);
+          if (result.manifest.totalBytes > capability.maxSizeBytes) {
+            attemptCaptureLimitError = "too_large";
+            if (attemptOwnsSharedCapture()) captureLimitErrorRef.current = "too_large";
+            if (recorder.state !== "inactive") recorder.stop();
           }
-          setStatus("idle");
-          focusInput();
         }).catch((reason) => {
-          if (generation !== generationRef.current || controller.signal.aborted) return;
-          setStatus("error");
-          setError(errorCode(reason));
-        }).finally(() => {
-          if (controllerRef.current === controller) controllerRef.current = null;
+          attemptPersistenceError = reason;
+          if (attemptOwnsSharedCapture()) persistenceErrorRef.current = reason;
+          if (recorder.state !== "inactive") recorder.stop();
+        });
+        if (attemptOwnsSharedCapture()) {
+          persistenceQueueRef.current = attemptPersistenceQueue;
+        }
+      };
+      recorder.onstop = () => {
+        if (attemptOwnsSharedCapture()) {
+          clearCaptureRuntime(mediaStream);
+        } else {
+          mediaStream.getTracks().forEach((track) => track.stop());
+        }
+        void attemptPersistenceQueue.catch((reason) => {
+          attemptPersistenceError = reason;
+        }).then(async () => {
+          const resolveSettled = attemptCaptureSettlement.resolve;
+          attemptCaptureSettlement.resolve = null;
+          resolveSettled?.();
+          if (resolveCaptureSettledRef.current === resolveSettled) {
+            resolveCaptureSettledRef.current = null;
+          }
+          const stoppedCaptureIsCurrent = () => generation === generationRef.current && workspaceIdRef.current === workspaceId && ownerIdRef.current === ownerId && manifestRef.current?.recordingId === manifest.recordingId && manifestRef.current.workspaceId === workspaceId && manifestRef.current.ownerId === ownerId;
+          if (!stoppedCaptureIsCurrent()) return;
+          const current = manifestRef.current;
+          if (!current) return;
+          const stopped = await updateManifestBestEffort(current, { captureState: "stopped" });
+          if (!stoppedCaptureIsCurrent() || stopped.recordingId !== manifest.recordingId || stopped.workspaceId !== workspaceId || stopped.ownerId !== ownerId) {
+            return;
+          }
+          rememberManifest(stopped);
+          if (attemptPersistenceError) {
+            await preserveForRetry(stopped, "storage_unavailable", generation);
+            return;
+          }
+          if (attemptCaptureLimitError) {
+            await preserveForRetry(stopped, attemptCaptureLimitError, generation);
+            return;
+          }
+          await finalizePersistedRecording(generation);
         });
       };
-      recorder.start();
+      captureSettledRef.current = new Promise((resolve) => {
+        attemptCaptureSettlement.resolve = resolve;
+        resolveCaptureSettledRef.current = resolve;
+      });
+      attemptRecordingStartedAt = readNow().getTime();
+      recorder.start(VOICE_RECORDING_TIMESLICE_MILLISECONDS);
+      recorderStarted = true;
       setStatus("recording");
       timerRef.current = setTimeout(
-        () => stop(),
-        Math.min(capability.maxDurationSeconds, 60) * 1e3
+        stop,
+        Math.min(capability.maxDurationSeconds, VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS) * 1e3
       );
       return true;
     } catch (reason) {
+      const resolveSettled = attemptCaptureSettlement.resolve;
+      attemptCaptureSettlement.resolve = null;
+      resolveSettled?.();
+      if (resolveCaptureSettledRef.current === resolveSettled) {
+        resolveCaptureSettledRef.current = null;
+      }
+      if (acquiredStream) {
+        if (startAttemptIsCurrent() && streamRef.current === acquiredStream) {
+          clearCaptureRuntime(acquiredStream);
+        } else {
+          acquiredStream.getTracks().forEach((track) => track.stop());
+        }
+      }
+      const failedManifest = attemptManifest.current;
+      if (failedManifest && !recorderStarted) {
+        const discarded = await store.discard(failedManifest.recordingId, ownerId).then(() => true).catch(() => false);
+        if (!discarded) {
+          await store.updateManifest(
+            failedManifest.recordingId,
+            { captureState: "stopped", ownerId: null, ownerHeartbeatAt: null },
+            readNow().toISOString(),
+            ownerId
+          ).catch(() => void 0);
+        }
+      }
       if (generation !== generationRef.current) return false;
-      clearRuntime();
+      const visibleManifest = manifestRef.current;
+      if (failedManifest && visibleManifest?.recordingId === failedManifest.recordingId) {
+        clearVisibleRecording();
+      }
       setStatus("error");
-      setError(errorCode(reason));
+      setError(
+        reason instanceof VoiceRecordingStorageUnavailableError ? "storage_unavailable" : errorCode(reason)
+      );
       return false;
     }
-  };
+  }, [
+    capability,
+    beginOwnerHeartbeat,
+    clearCaptureRuntime,
+    clearVisibleRecording,
+    client,
+    createRecordingId,
+    disabled,
+    enabled,
+    ensureOwnerId,
+    ensureStore,
+    finalizePersistedRecording,
+    readNow,
+    preserveForRetry,
+    rememberManifest,
+    status,
+    stop,
+    updateManifestBestEffort,
+    workspaceId
+  ]);
+  const retry = useCallback2(() => {
+    if (!manifestRef.current || manifestRef.current.finalizationState === "transcript-ready" || manifestRef.current.workspaceId !== workspaceId || !client || disabled || !enabled || status === "saving" || status === "transcribing") {
+      return;
+    }
+    const generation = ++generationRef.current;
+    controllerRef.current?.abort();
+    setError(null);
+    void finalizePersistedRecording(generation);
+  }, [client, disabled, enabled, finalizePersistedRecording, status, workspaceId]);
+  const insertSavedTranscript = useCallback2(async () => {
+    const manifest = manifestRef.current;
+    if (!manifest || manifest.workspaceId !== workspaceId || manifest.finalizationState !== "transcript-ready" || manifest.transcriptText === null) {
+      return;
+    }
+    const generation = ++generationRef.current;
+    controllerRef.current?.abort();
+    controllerRef.current = null;
+    const store = await ensureStore();
+    if (generation !== generationRef.current) return;
+    const next = appendFinalTranscript(valueRef.current, manifest.transcriptText);
+    if (next !== valueRef.current) {
+      valueRef.current = next;
+      setValue(next);
+    }
+    let handedOff;
+    try {
+      handedOff = await store.updateManifest(
+        manifest.recordingId,
+        { finalizationState: "handed-off" },
+        readNow().toISOString(),
+        ownerIdRef.current ?? void 0
+      );
+    } catch {
+      if (generation !== generationRef.current) return;
+      rememberManifest(manifest);
+      setStatus("transcript-ready");
+      setError("handoff_uncertain");
+      focusInput();
+      return;
+    }
+    if (generation !== generationRef.current) return;
+    await store.discard(handedOff.recordingId, ownerIdRef.current ?? void 0).catch(() => void 0);
+    if (generation !== generationRef.current) return;
+    clearVisibleRecording();
+    setStatus("idle");
+    setError(null);
+    focusInput();
+    await loadNextRecoverable(generation);
+  }, [
+    clearVisibleRecording,
+    ensureStore,
+    focusInput,
+    loadNextRecoverable,
+    readNow,
+    rememberManifest,
+    setValue,
+    workspaceId
+  ]);
+  const discard = useCallback2(async () => {
+    const manifest = manifestRef.current;
+    const generation = ++generationRef.current;
+    controllerRef.current?.abort();
+    controllerRef.current = null;
+    const recorder = recorderRef.current;
+    let captureSettled = persistenceQueueRef.current;
+    if (recorder && recorder.state !== "inactive") {
+      captureSettled = captureSettledRef.current;
+      recorder.stop();
+    }
+    clearCaptureRuntime();
+    await captureSettled.catch(() => void 0);
+    if (generation !== generationRef.current) return;
+    if (manifest) {
+      try {
+        await (await ensureStore()).discard(manifest.recordingId, ownerIdRef.current ?? void 0);
+      } catch {
+        if (generation !== generationRef.current) return;
+        rememberManifest(manifest);
+        setStatus("error");
+        setError("storage_unavailable");
+        focusInput();
+        return;
+      }
+    }
+    clearVisibleRecording();
+    persistenceErrorRef.current = null;
+    captureLimitErrorRef.current = null;
+    setStatus("idle");
+    setError(null);
+    focusInput();
+    await loadNextRecoverable(generation);
+  }, [
+    clearCaptureRuntime,
+    clearVisibleRecording,
+    ensureStore,
+    focusInput,
+    loadNextRecoverable,
+    rememberManifest
+  ]);
+  const cancel = useCallback2(() => {
+    if (status === "recording" || status === "requesting-permission") {
+      void discard();
+      return;
+    }
+    if (status === "saving" || status === "transcribing") {
+      const generation = ++generationRef.current;
+      controllerRef.current?.abort();
+      controllerRef.current = null;
+      const captureSettled = status === "saving" ? captureSettledRef.current : Promise.resolve();
+      void captureSettled.then(async () => {
+        const manifest = manifestRef.current;
+        if (!manifest) return;
+        const retained = await updateManifestBestEffort(manifest, {
+          captureState: "stopped",
+          uploadState: "retrying",
+          transcriptionState: "retrying"
+        });
+        await preserveForRetry(retained, null, generation);
+      });
+    }
+  }, [discard, preserveForRetry, status, updateManifestBestEffort]);
+  useEffect2(() => {
+    const current = manifestRef.current;
+    const generation = ++generationRef.current;
+    if (current && current.workspaceId !== workspaceId) {
+      controllerRef.current?.abort();
+      controllerRef.current = null;
+      const recorder = recorderRef.current;
+      let captureSettled = persistenceQueueRef.current;
+      if (recorder && recorder.state !== "inactive") {
+        captureSettled = captureSettledRef.current;
+        recorder.stop();
+      }
+      clearCaptureRuntime();
+      clearVisibleRecording();
+      setStatus("idle");
+      setError(null);
+      void captureSettled.catch(() => void 0).then(async () => {
+        const store = await ensureStore();
+        const wasProcessing = current.uploadState === "syncing" || current.transcriptionState === "transcribing";
+        await store.updateManifest(
+          current.recordingId,
+          {
+            ...current.captureState === "capturing" ? { captureState: "stopped" } : {},
+            ...wasProcessing ? { uploadState: "retrying", transcriptionState: "retrying" } : {},
+            ownerId: null,
+            ownerHeartbeatAt: null
+          },
+          readNow().toISOString(),
+          ownerIdRef.current ?? void 0
+        );
+      }).catch(() => void 0);
+    }
+    if (!manifestRef.current) {
+      void loadNextRecoverable(generation).catch((reason) => {
+        if (reason instanceof VoiceRecordingStorageUnavailableError) setStorageAvailable(false);
+      });
+    }
+  }, [
+    clearCaptureRuntime,
+    clearVisibleRecording,
+    ensureStore,
+    loadNextRecoverable,
+    readNow,
+    workspaceId
+  ]);
   useEffect2(() => {
     const onKeyDown = (event) => {
-      if (event.key === "Escape" && status !== "idle") {
+      if (event.key === "Escape" && (status === "requesting-permission" || status === "recording" || status === "saving" || status === "transcribing")) {
         event.preventDefault();
         cancel();
       }
@@ -724,20 +1867,61 @@ function useVoiceInput({
     () => () => {
       generationRef.current += 1;
       controllerRef.current?.abort();
+      controllerRef.current = null;
+      const manifest = manifestRef.current;
+      const ownerReady = ownerIdPromiseRef.current;
+      stopOwnerHeartbeat();
       const recorder = recorderRef.current;
-      clearRuntime();
-      if (recorder && recorder.state !== "inactive") recorder.stop();
+      let captureSettled = persistenceQueueRef.current;
+      if (recorder && recorder.state !== "inactive") {
+        captureSettled = captureSettledRef.current;
+        recorder.stop();
+      }
+      clearCaptureRuntime();
+      void captureSettled.catch(() => void 0).then(async () => {
+        const ownerId = ownerIdRef.current ?? (ownerReady ? await ownerReady.catch(() => null) : null);
+        const store = storeRef.current;
+        if (store && manifest && ownerId) {
+          const wasProcessing = statusRef.current === "saving" || statusRef.current === "transcribing";
+          await store.updateManifest(
+            manifest.recordingId,
+            {
+              ...manifest.captureState === "capturing" ? { captureState: "stopped" } : {},
+              ...wasProcessing ? {
+                uploadState: "retrying",
+                transcriptionState: "retrying"
+              } : {},
+              ownerId: null,
+              ownerHeartbeatAt: null
+            },
+            readNow().toISOString(),
+            ownerId
+          ).catch(() => void 0);
+        }
+        if (ownsStoreRef.current) await store?.close();
+      }).catch(() => void 0).finally(() => {
+        ownerLeaseRef.current?.release();
+        ownerLeaseRef.current = null;
+      });
     },
-    [clearRuntime]
+    [clearCaptureRuntime, readNow, stopOwnerHeartbeat]
   );
   return {
     status,
     error,
-    available: Boolean(capability?.available && enabled && !disabled),
+    available: Boolean(capability?.available && enabled && !disabled && storageAvailable),
     stream,
+    recordingId,
+    durationSeconds,
+    locallySaved,
+    hasRecoverableRecording: manifestRef.current !== null && status !== "recording",
+    savedTranscript: manifestRef.current?.finalizationState === "transcript-ready" ? manifestRef.current.transcriptText : null,
     start,
     stop,
-    cancel
+    retry,
+    insertSavedTranscript,
+    cancel,
+    discard
   };
 }
 function chooseMimeType(accepted) {
@@ -2503,7 +3687,15 @@ function HelpPanel({
 }
 
 // src/components/composer-transcription-control.tsx
-import { LoaderCircleIcon as LoaderCircleIcon2, MicIcon, SquareIcon, XIcon as XIcon2 } from "lucide-react";
+import {
+  ClipboardPasteIcon,
+  LoaderCircleIcon as LoaderCircleIcon2,
+  MicIcon,
+  RefreshCwIcon,
+  SquareIcon,
+  Trash2Icon,
+  XIcon as XIcon2
+} from "lucide-react";
 import { AnimatePresence as AnimatePresence3, motion as motion3 } from "motion/react";
 import { useEffect as useEffect4, useState as useState5 } from "react";
 import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
@@ -2520,7 +3712,12 @@ var defaultMessages = {
   retry: "Retry voice input",
   requestingPermission: "Requesting microphone\u2026",
   recording: "Recording. Press Escape to cancel.",
+  saving: "Saving audio locally\u2026",
   transcribing: "Transcribing\u2026",
+  recovered: "Recording recovered and saved locally.",
+  recoveredTranscript: "Transcript saved locally. Check your draft before inserting.",
+  insertRecoveredTranscript: "Insert saved transcript",
+  discardRecovered: "Discard saved recording",
   unavailableDisabled: "Voice input is unavailable while the composer is disabled.",
   unavailable: "Voice input is unavailable for this workspace.",
   errorPermissionDenied: "Microphone permission was denied. Your draft was not changed.",
@@ -2528,6 +3725,9 @@ var defaultMessages = {
   errorUnavailable: "Voice input is not configured.",
   errorTooLarge: "Recording is too large. Try a shorter message.",
   errorInvalidAudio: "The recording could not be read. Try again.",
+  errorStorageUnavailable: "Voice input stopped because audio could not be saved safely.",
+  errorRetryable: "Recording is saved locally. Retry transcription when ready.",
+  errorHandoffUncertain: "Transcript is saved. Check your draft before inserting it again.",
   errorUnknown: "Voice input could not start. Try again."
 };
 var WAVEFORM_BARS = 18;
@@ -2541,7 +3741,9 @@ function ComposerTranscriptionControl({
   capability = null,
   workspaceEnabled = false,
   messages: overrides,
-  className
+  className,
+  createRecordingStore,
+  createOwnerId
 }) {
   const composer = useChatComposer();
   const messages = { ...defaultMessages, ...overrides };
@@ -2553,14 +3755,18 @@ function ComposerTranscriptionControl({
     value: composer.value,
     setValue: composer.setValue,
     focusInput: composer.focusInput,
-    disabled: composer.disabled
+    disabled: composer.disabled,
+    createRecordingStore,
+    createOwnerId
   });
   const { status } = transcription;
-  const active = status === "requesting-permission" || status === "recording" || status === "transcribing";
-  const unavailableMessage = composer.disabled ? messages.unavailableDisabled : !capability?.available || !workspaceEnabled ? messages.unavailable : null;
+  const active = status === "requesting-permission" || status === "recording" || status === "saving" || status === "transcribing";
+  const recoverable = transcription.hasRecoverableRecording && (status === "recovered" || status === "transcript-ready" || status === "error");
+  const savedTranscript = status === "transcript-ready" && transcription.savedTranscript !== null;
+  const unavailableMessage = composer.disabled ? messages.unavailableDisabled : !capability?.available || !workspaceEnabled ? messages.unavailable : !transcription.available ? messages.errorStorageUnavailable : null;
   const idleLabel = unavailableMessage ?? (status === "error" ? messages.retry : messages.start);
   const errorMessage3 = transcription.error ? transcriptionErrorMessage(transcription.error, messages) : null;
-  const announcement = status === "requesting-permission" ? messages.requestingPermission : status === "recording" ? messages.recording : status === "transcribing" ? messages.transcribing : status === "error" ? errorMessage3 ?? messages.errorUnknown : unavailableMessage;
+  const announcement = status === "requesting-permission" ? messages.requestingPermission : status === "recording" ? messages.recording : status === "saving" ? messages.saving : status === "transcribing" ? messages.transcribing : status === "recovered" ? messages.recovered : status === "transcript-ready" ? messages.recoveredTranscript : status === "error" ? errorMessage3 ?? messages.errorUnknown : unavailableMessage;
   function start(event) {
     if (unavailableMessage) {
       event.preventDefault();
@@ -2574,7 +3780,51 @@ function ComposerTranscriptionControl({
       className: cn("inline-flex min-w-0 items-center gap-1.5", className),
       "data-transcription-status": status,
       children: [
-        /* @__PURE__ */ jsx4(AnimatePresence3, { mode: "popLayout", initial: false, children: active ? /* @__PURE__ */ jsxs4(
+        /* @__PURE__ */ jsx4(AnimatePresence3, { mode: "popLayout", initial: false, children: recoverable ? /* @__PURE__ */ jsxs4(
+          motion3.span,
+          {
+            initial: { opacity: 0, scale: 0.96 },
+            animate: { opacity: 1, scale: 1 },
+            exit: { opacity: 0, scale: 0.96 },
+            transition: { duration: 0.16, ease: [0.22, 1, 0.36, 1] },
+            className: cn(
+              "inline-flex h-8 min-w-0 items-center gap-1 rounded-og-md border border-og-border/80",
+              "bg-og-surface-2/70 pl-2 pr-1 pointer-coarse:h-11"
+            ),
+            children: [
+              /* @__PURE__ */ jsx4("span", { className: "max-w-44 truncate text-og-xs text-og-fg-muted max-sm:max-w-28", children: savedTranscript ? errorMessage3 ?? messages.recoveredTranscript : status === "error" ? errorMessage3 ?? messages.errorRetryable : messages.recovered }),
+              /* @__PURE__ */ jsx4(Tip, { tip: savedTranscript ? messages.insertRecoveredTranscript : messages.retry, children: /* @__PURE__ */ jsx4(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => savedTranscript ? void transcription.insertSavedTranscript() : transcription.retry(),
+                  "aria-label": savedTranscript ? messages.insertRecoveredTranscript : messages.retry,
+                  className: cn(
+                    "inline-flex size-7 shrink-0 items-center justify-center rounded-og-sm",
+                    "bg-og-fg text-og-bg transition-colors duration-150 motion-reduce:transition-none",
+                    "hover:bg-og-fg-muted pointer-coarse:size-11"
+                  ),
+                  children: savedTranscript ? /* @__PURE__ */ jsx4(ClipboardPasteIcon, { className: "size-3.5" }) : /* @__PURE__ */ jsx4(RefreshCwIcon, { className: "size-3.5" })
+                }
+              ) }),
+              /* @__PURE__ */ jsx4(Tip, { tip: messages.discardRecovered, children: /* @__PURE__ */ jsx4(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => void transcription.discard(),
+                  "aria-label": messages.discardRecovered,
+                  className: cn(
+                    "inline-flex size-7 shrink-0 items-center justify-center rounded-og-sm",
+                    "text-og-fg-muted transition-colors duration-150 motion-reduce:transition-none",
+                    "hover:bg-og-surface-3 hover:text-og-status-failed pointer-coarse:size-11"
+                  ),
+                  children: /* @__PURE__ */ jsx4(Trash2Icon, { className: "size-3.5" })
+                }
+              ) })
+            ]
+          },
+          "recovered"
+        ) : active ? /* @__PURE__ */ jsxs4(
           motion3.span,
           {
             initial: { opacity: 0, scale: 0.96 },
@@ -2583,7 +3833,7 @@ function ComposerTranscriptionControl({
             transition: { duration: 0.16, ease: [0.22, 1, 0.36, 1] },
             className: cn(
               "inline-flex h-8 items-center gap-1 rounded-og-md border border-og-border/80",
-              "bg-og-surface-2/70 pl-2 pr-1 pointer-coarse:h-9"
+              "bg-og-surface-2/70 pl-2 pr-1 pointer-coarse:h-11"
             ),
             children: [
               status === "requesting-permission" ? /* @__PURE__ */ jsx4(
@@ -2604,7 +3854,7 @@ function ComposerTranscriptionControl({
                   VoiceWaveform,
                   {
                     stream: status === "recording" ? transcription.stream : null,
-                    mode: status === "transcribing" ? "transcribing" : "recording"
+                    mode: status === "recording" ? "recording" : "transcribing"
                   }
                 )
               ] }),
@@ -2619,7 +3869,7 @@ function ComposerTranscriptionControl({
                     className: cn(
                       "inline-flex size-7 shrink-0 items-center justify-center rounded-og-sm",
                       "text-og-fg-muted transition-colors duration-150 motion-reduce:transition-none",
-                      "hover:bg-og-surface-3 hover:text-og-fg pointer-coarse:size-9"
+                      "hover:bg-og-surface-3 hover:text-og-fg pointer-coarse:size-11"
                     ),
                     children: /* @__PURE__ */ jsx4(XIcon2, { className: "size-3.5" })
                   }
@@ -2633,15 +3883,15 @@ function ComposerTranscriptionControl({
                     className: cn(
                       "inline-flex size-7 shrink-0 items-center justify-center rounded-og-sm",
                       "bg-og-fg text-og-bg transition-colors duration-150 motion-reduce:transition-none",
-                      "hover:bg-og-fg-muted pointer-coarse:size-9"
+                      "hover:bg-og-fg-muted pointer-coarse:size-11"
                     ),
                     children: /* @__PURE__ */ jsx4(SquareIcon, { className: "size-2.5 fill-current" })
                   }
                 ) })
-              ] }) : status === "transcribing" ? /* @__PURE__ */ jsx4("span", { className: "og-shimmer-text px-1.5 text-og-xs font-medium whitespace-nowrap", children: messages.transcribing }) : /* @__PURE__ */ jsx4("span", { className: "px-1.5 text-og-xs text-og-fg-muted whitespace-nowrap", children: messages.requestingPermission })
+              ] }) : status === "transcribing" || status === "saving" ? /* @__PURE__ */ jsx4("span", { className: "og-shimmer-text px-1.5 text-og-xs font-medium whitespace-nowrap", children: status === "saving" ? messages.saving : messages.transcribing }) : /* @__PURE__ */ jsx4("span", { className: "px-1.5 text-og-xs text-og-fg-muted whitespace-nowrap", children: messages.requestingPermission })
             ]
           },
-          status === "transcribing" ? "transcribing" : "capture"
+          status === "transcribing" || status === "saving" ? "processing" : "capture"
         ) : /* @__PURE__ */ jsx4(Tip, { tip: idleLabel, children: /* @__PURE__ */ jsx4(
           motion3.button,
           {
@@ -2655,14 +3905,14 @@ function ComposerTranscriptionControl({
             "aria-pressed": false,
             "aria-disabled": unavailableMessage !== null,
             className: cn(
-              "inline-flex size-8 shrink-0 items-center justify-center rounded-og-md pointer-coarse:size-9",
+              "inline-flex size-8 shrink-0 items-center justify-center rounded-og-md pointer-coarse:size-11",
               "text-og-fg-muted transition-colors duration-150 motion-reduce:transition-none",
               unavailableMessage ? "cursor-not-allowed opacity-45" : "hover:bg-og-surface-2 hover:text-og-fg"
             ),
             children: /* @__PURE__ */ jsx4(MicIcon, { className: "size-4" })
           }
         ) }, "idle") }),
-        status === "error" && errorMessage3 ? /* @__PURE__ */ jsx4(Tip, { tip: errorMessage3, children: /* @__PURE__ */ jsx4(
+        status === "error" && errorMessage3 && !recoverable ? /* @__PURE__ */ jsx4(Tip, { tip: errorMessage3, children: /* @__PURE__ */ jsx4(
           "span",
           {
             "aria-hidden": "true",
@@ -2772,6 +4022,14 @@ function transcriptionErrorMessage(code, messages) {
       return messages.errorTooLarge;
     case "invalid_audio":
       return messages.errorInvalidAudio;
+    case "storage_unavailable":
+      return messages.errorStorageUnavailable;
+    case "network":
+    case "provider":
+    case "timeout":
+      return messages.errorRetryable;
+    case "handoff_uncertain":
+      return messages.errorHandoffUncertain;
     case "unknown":
       return messages.errorUnknown;
     default:
@@ -2780,10 +4038,23 @@ function transcriptionErrorMessage(code, messages) {
 }
 
 export {
+  VoiceRecordingStorageUnavailableError,
+  VoiceRecordingNotFoundError,
+  VoiceRecordingChunkConflictError,
+  VoiceRecordingChunkSequenceError,
+  VoiceRecordingOwnedError,
+  createVoiceRecordingManifest,
+  prepareVoiceRecordingChunk,
+  planVoiceRecordingChunkCommit,
+  IndexedDbVoiceRecordingStore,
   INITIAL_TRANSCRIPTION_CONTROL_STATE,
   transitionTranscriptionControl,
   appendFinalTranscript,
   useTranscription,
+  VOICE_RECORDING_TIMESLICE_MILLISECONDS,
+  VOICE_RECORDING_OWNER_HEARTBEAT_MILLISECONDS,
+  VOICE_RECORDING_OWNER_STALE_MILLISECONDS,
+  VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS,
   useVoiceInput,
   OPEN_WORKSTREAM_CONTROL_EVENT,
   parseCommandLine,
@@ -2820,4 +4091,4 @@ export {
   Status,
   ComposerTranscriptionControl
 };
-//# sourceMappingURL=chunk-OMCFRWHL.js.map
+//# sourceMappingURL=chunk-UWYTCQWW.js.map