@memberjunction/realtime-runtime 6.2.0-edge.4 → 6.2.0-edge.5

package/dist/session/RecordingShardDrain.js

@@ -0,0 +1,135 @@
+import { CreateRecordingShardStore } from './RecordingShardStore.js';
+import { FetchRecordingTransport, RecordingBaseURLFromGraphQLURL } from './RecordingTransport.js';
+/** Most stored shards one drain pass re-uploads; the rest wait for the next pass or load. */
+export const MAX_DRAINED_SHARDS_PER_LOAD = 50;
+function describeFailure(failure) {
+    return failure instanceof Error ? failure.message : String(failure);
+}
+/**
+ * The default recording transport for a provider: MJAPI's REST recording routes, derived from the
+ * provider's GraphQL URL, with credentials read per request so a refreshed token is used. Null when
+ * the provider has no URL (a test double, a provider that is not GraphQL, or one not configured yet).
+ */
+export function CreateRecordingTransportForProvider(provider) {
+    // Typed as GraphQL, but read defensively: a test double or a non-GraphQL provider has no ConfigData.
+    const graphQL = provider;
+    const url = graphQL?.ConfigData?.URL;
+    if (!graphQL || !url) {
+        return null;
+    }
+    return new FetchRecordingTransport({
+        BaseURL: RecordingBaseURLFromGraphQLURL(url),
+        Headers: () => {
+            const config = graphQL.ConfigData;
+            const headers = {};
+            if (config?.Token)
+                headers.authorization = `Bearer ${config.Token}`;
+            if (config?.MJAPIKey)
+                headers['x-mj-api-key'] = config.MJAPIKey;
+            if (config?.UserAPIKey)
+                headers['x-api-key'] = config.UserAPIKey;
+            return headers;
+        },
+    });
+}
+/**
+ * One drain pass over `userID`'s stored shards, oldest first, each under its own session and index. A
+ * shard the server acknowledges or refuses for good (see {@link RecordingUploadOutcome}) leaves the
+ * store; one that may still succeed stays for the next pass or load. Never rejects for an upload or
+ * delete failure (each is logged); a store whose listing throws rejects.
+ */
+export async function DrainStoredRecordingShardsOnce(store, transport, userID) {
+    const pending = await store.ListOldest(MAX_DRAINED_SHARDS_PER_LOAD, userID);
+    let delivered = 0;
+    let refused = 0;
+    for (const shard of pending) {
+        let outcome = 'Retry';
+        try {
+            outcome = await transport.UploadShard(shard.SessionID, shard);
+        }
+        catch (error) {
+            console.warn(`[RealtimeSession] Re-uploading stored recording shard ${shard.SessionID}/${shard.Index} failed: ${describeFailure(error)}; it stays stored for the next load.`, error);
+        }
+        if (outcome === 'Acked') {
+            await DeleteStoredRecordingShard(store, shard.SessionID, shard.Index);
+            delivered++;
+        }
+        else if (outcome === 'Refused') {
+            console.warn(`[RealtimeSession] The server refused stored recording shard ${shard.SessionID}/${shard.Index} for good; deleting it so it no longer holds back the shards behind it.`);
+            await DeleteStoredRecordingShard(store, shard.SessionID, shard.Index);
+            refused++;
+        }
+    }
+    if (pending.length > 0) {
+        console.log(`[RealtimeSession] Re-uploaded ${delivered}/${pending.length} stored recording shard(s); ${refused} refused and deleted.`);
+    }
+    return { Listed: pending.length, Delivered: delivered, Refused: refused };
+}
+/** Removes one shard from the store. Never rejects: a failed delete only costs a duplicate re-upload. */
+export async function DeleteStoredRecordingShard(store, sessionId, index) {
+    try {
+        await store.Delete(sessionId, index);
+    }
+    catch (error) {
+        // Harmless beyond a wasted re-upload on the next load: the server acks a duplicate.
+        console.warn(`[RealtimeSession] Failed to delete recording shard ${sessionId}/${index} from the local store:`, error);
+    }
+}
+/** Most drain passes a logout runs before it deletes what is left (each pass is itself bounded). */
+const MAX_LOGOUT_DRAIN_PASSES = 3;
+/**
+ * For logout: tries to deliver `userID`'s stored shards within `timeoutMs`, then deletes every shard
+ * of that user that is still stored, so their call audio neither stays on a shared browser's disk nor
+ * waits for a later login. Other users' shards are untouched. Never rejects and never takes longer
+ * than `timeoutMs` plus the delete.
+ */
+export async function ReleaseUserRecordingShards(store, transport, userID, timeoutMs) {
+    let delivered = 0;
+    let timedOut = false;
+    if (transport) {
+        let timer;
+        const deadline = new Promise((resolve) => {
+            timer = setTimeout(() => resolve('timeout'), timeoutMs);
+        });
+        const attempt = (async () => {
+            for (let pass = 1; pass <= MAX_LOGOUT_DRAIN_PASSES; pass++) {
+                const result = await DrainStoredRecordingShardsOnce(store, transport, userID);
+                delivered += result.Delivered;
+                // Another pass only reaches shards beyond this pass's page, and only when this one made room;
+                // a shard that answered Retry is not retried within the logout.
+                if (result.Listed < MAX_DRAINED_SHARDS_PER_LOAD || result.Delivered + result.Refused === 0) {
+                    return;
+                }
+            }
+        })().catch((error) => {
+            console.warn(`[RealtimeSession] Sending stored recording shards at logout failed for user ${userID ?? '(none)'}: ${describeFailure(error)}; deleting them.`, error);
+        });
+        try {
+            timedOut = (await Promise.race([attempt, deadline])) === 'timeout';
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (timedOut) {
+            console.warn(`[RealtimeSession] Sending stored recording shards at logout took over ${timeoutMs} ms for user ${userID ?? '(none)'}; deleting what is left.`);
+        }
+    }
+    try {
+        await store.DeleteForUser(userID);
+    }
+    catch (error) {
+        console.warn(`[RealtimeSession] Failed to delete the stored recording shards of user ${userID ?? '(none)'} at logout:`, error);
+    }
+    return { Delivered: delivered, TimedOut: timedOut };
+}
+/** How long a logout waits for stored shards to upload before it deletes them. */
+export const RECORDING_LOGOUT_SEND_TIMEOUT_MS = 3000;
+/**
+ * A host's logout step: {@link ReleaseUserRecordingShards} for the provider's signed-in user, with the
+ * browser's IndexedDB store and the provider's recording transport. Call it while the provider is
+ * still authenticated (before its token is dropped). Never rejects.
+ */
+export function ReleaseRecordingShardsAtLogout(provider, timeoutMs = RECORDING_LOGOUT_SEND_TIMEOUT_MS) {
+    return ReleaseUserRecordingShards(CreateRecordingShardStore(globalThis.indexedDB), CreateRecordingTransportForProvider(provider), provider?.CurrentUser?.ID ?? null, timeoutMs);
+}
+//# sourceMappingURL=RecordingShardDrain.js.map

package/dist/session/RecordingShardDrain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordingShardDrain.js","sourceRoot":"","sources":["../../src/session/RecordingShardDrain.ts"],"names":[],"mappings":"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"}

package/dist/session/RecordingShardQueue.d.ts

@@ -1,76 +1,93 @@
 /**
- * @fileoverview Retry queue for crash-recovery audio shards.
+ * @fileoverview Retry queue for indexed recording shards.
  *
- * The browser recorder is snapshotted every ~15 s and each snapshot ("shard") is uploaded so a tab
- * crash loses at most one window of audio. Before this queue a failed upload was never retried, so a
- * single transient error left a permanent gap in the recovered recording (#5197). The queue keeps
- * failed shards and resends them, oldest first, on later flushes — bounded so a dead server cannot
- * grow memory without limit.
+ * The recorder cuts the call's Opus stream into already-indexed `MJOPUS1` shards (see
+ * {@link RecordingShardWindow}) and each one is uploaded as it seals. Before this queue a failed
+ * upload was never retried, so a single transient error left a permanent gap in the recovered
+ * recording (#5197). The queue keeps failed shards and resends them, oldest first, on later
+ * flushes — bounded so a dead server cannot grow memory without limit. A shard the queue gives up on
+ * is not lost: it stays in the IndexedDB store, and the owner is told so it can re-send it from there
+ * once uploads succeed again (or a later load drains it).
  *
  * @module @memberjunction/realtime-runtime
  */
-/** Takes the audio recorded since the previous snapshot as base64, or null/'' when there is none. */
-export type ShardSnapshot = () => Promise<string | null>;
+import type { RecordingShard } from './RecordingShardWindow.js';
 /** Resolves true when the server stored the shard; false or a throw are both failures. */
-export type ShardUpload = (segmentIndex: number, audioBase64: string) => Promise<boolean>;
+export type ShardUpload = (shard: RecordingShard) => Promise<boolean>;
+/**
+ * Told about shards the queue stops retrying while the recording is live (attempts used up, or the
+ * retry list overflowed). They are still in the store; the owner re-sends them once uploads work.
+ */
+export type ShardsGivenUp = (shards: RecordingShard[]) => void;
 /** Total upload attempts per shard (the first try plus retries) before it is dropped. */
 export declare const MAX_SHARD_UPLOAD_ATTEMPTS = 3;
 /**
- * Flushes allowed in flight at once. Ticks are 15 s apart, so overlap only happens when an upload is
- * slower than a tick; an unbounded pile-up on a dead network would snapshot (and hold in memory) a
- * new window every tick. A skipped tick costs nothing: the recorder keeps the audio and the next
- * flush ships the larger window. While both slots are pinned the recorder cursor does not advance,
- * so the next capture is one larger window (bounded by the upload timeout x attempts); if that
- * shard is later dropped, recovery fills a correspondingly longer gap with silence.
+ * Flushes allowed in flight at once. Flushes are ~5 s apart, so overlap only happens when an upload
+ * is slower than a tick; an unbounded pile-up on a dead network would start a new batch of uploads
+ * every tick. A flush that arrives at capacity does not upload, but it does not lose its shards
+ * either: they are retained and the next flush that has a free slot sends them, oldest first.
  */
 export declare const MAX_CONCURRENT_FLUSHES = 2;
 /**
  * Per-attempt upload deadline. A hung request would otherwise pin one of the
  * {@link MAX_CONCURRENT_FLUSHES} slots forever and silently stop all later shards. A timeout counts
  * as a failed attempt; if the request later succeeds anyway that is harmless, because the server
- * key is per-index and a resend is an idempotent overwrite. The timeout is logical only:
- * `ExecuteGQL` accepts no AbortSignal, so a timed-out request may still be on the wire. Requests
- * stay rate-bounded regardless (at most {@link MAX_CONCURRENT_FLUSHES} flushes, each sending at
- * most one batch, per timeout window), and a late success is an idempotent same-index overwrite.
+ * key is per-index and a resend of the same bytes is an idempotent overwrite. The timeout is
+ * logical only: the transport may accept no AbortSignal, so a timed-out request may still be on the
+ * wire. Requests stay rate-bounded regardless (at most {@link MAX_CONCURRENT_FLUSHES} flushes, each
+ * sending at most one batch, per timeout window).
  */
 export declare const SHARD_UPLOAD_TIMEOUT_MS = 60000;
 /**
- * Assigns chronological indexes to crash-recovery shards, uploads them, and retains failures for
- * retry on later flushes. Safe to call {@link Flush} from an overlapping timer.
+ * Cap on shards held for retry: 10 minutes of 5 s shards. A dead network with flushes at capacity
+ * would otherwise grow the retained list (and its bytes) without bound. Overflow drops the oldest;
+ * dropped shards remain in the IndexedDB store for the next-load drain.
+ */
+export declare const MAX_RETAINED_SHARDS = 120;
+/**
+ * Uploads indexed shards and retains failures for retry on later flushes. A retry keeps its shard's
+ * index and bytes. Safe to call {@link Flush} from an overlapping timer.
  */
 export declare class RecordingShardQueue {
-    private nextIndex;
+    private readonly upload;
+    private readonly onGivenUp;
     private retained;
+    /** Every shard handed to the queue and not yet acknowledged or given up on, by index. */
+    private readonly outstanding;
     private inFlight;
     /** True once a capacity stall has been logged; cleared when a flush actually runs. */
     private capacityWarned;
-    /** Set by {@link Close} when the recording ends; nothing is snapshotted, sent or retained after it. */
+    /** Set by {@link Close} when the recording ends; nothing is sent or retained after it. */
     private closed;
     /**
-     * Serializes "take a snapshot, then assign an index". The recorder advances its cursor
-     * synchronously but encodes asynchronously, so two overlapping snapshots could resolve out of
-     * order and give newer audio an older index. Never rejected: the link catches internally.
+     * @param upload sends one shard
+     * @param onGivenUp told about every shard dropped while the recording is live (not on {@link Close})
      */
-    private captureChain;
+    constructor(upload: ShardUpload, onGivenUp?: ShardsGivenUp);
     /** Shards awaiting a retry (for tests and diagnostics). */
     get RetainedCount(): number;
     /**
-     * Takes ownership of retained shards and uploads them oldest-first, then captures a new window
-     * and uploads it. Retained shards go first so a hung snapshot cannot strand them. A failure never
-     * stops the rest of the flush. Skips entirely (no snapshot) when
-     * {@link MAX_CONCURRENT_FLUSHES} are already running. Never rejects.
+     * Every shard the queue still holds without an acknowledgement — on the wire, waiting in a flush's
+     * batch, or retained for a retry — oldest first. A page that is about to unload re-sends these with
+     * `keepalive`, because its ordinary requests are aborted with it.
+     */
+    Unacknowledged(): RecordingShard[];
+    /**
+     * Uploads retained shards oldest-first, then `fresh`. A failure never stops the rest of the
+     * flush. At {@link MAX_CONCURRENT_FLUSHES} in flight nothing is uploaded and `fresh` is retained
+     * for the next flush instead. Never rejects.
      */
-    Flush(snapshot: ShardSnapshot, upload: ShardUpload): Promise<void>;
+    Flush(fresh: RecordingShard[]): Promise<void>;
     /**
      * Ends the queue with its recording: discards retained shards and stops any flush in flight from
-     * sending more. An upload already on the wire cannot be aborted (`ExecuteGQL` takes no
-     * AbortSignal), so at most that one request can still land.
+     * sending more. An upload already on the wire cannot be aborted, so at most that one request can
+     * still land. Discarded shards remain in the IndexedDB store and are drained on a later load.
      */
     Close(): void;
-    /** Warns once per stall so a wedged uploader is visible without logging every 15 s tick. */
+    /** Sorted re-insert: concurrent flushes can fail out of index order, and the oldest must go first. */
+    private retain;
+    /** Warns once per stall so a wedged uploader is visible without logging every tick. */
     private warnCapacitySkip;
-    private captureShard;
-    private takeIndexedSnapshot;
     private uploadWithTimeout;
     private send;
 }

package/dist/session/RecordingShardQueue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RecordingShardQueue.d.ts","sourceRoot":"","sources":["../../src/session/RecordingShardQueue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,qGAAqG;AACrG,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAEzD,0FAA0F;AAC1F,MAAM,MAAM,WAAW,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAE1F,yFAAyF;AACzF,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAa9C;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,QAAQ,CAAK;IACrB,sFAAsF;IACtF,OAAO,CAAC,cAAc,CAAS;IAC/B,uGAAuG;IACvG,OAAO,CAAC,MAAM,CAAS;IACvB;;;;OAIG;IACH,OAAO,CAAC,YAAY,CAAoC;IAExD,2DAA2D;IAC3D,IAAW,aAAa,IAAI,MAAM,CAEjC;IAED;;;;;OAKG;IACU,KAAK,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA+B/E;;;;OAIG;IACI,KAAK,IAAI,IAAI;IAKpB,4FAA4F;IAC5F,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,YAAY;YAMN,mBAAmB;YAanB,iBAAiB;YAYjB,IAAI;CAkCnB"}
+{"version":3,"file":"RecordingShardQueue.d.ts","sourceRoot":"","sources":["../../src/session/RecordingShardQueue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,0FAA0F;AAC1F,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtE;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,IAAI,CAAC;AAE/D,yFAAyF;AACzF,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAYvC;;;GAGG;AACH,qBAAa,mBAAmB;IAclB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAAe,OAAO,CAAC,QAAQ,CAAC,SAAS;IAb5E,OAAO,CAAC,QAAQ,CAAsB;IACtC,yFAAyF;IACzF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqC;IACjE,OAAO,CAAC,QAAQ,CAAK;IACrB,sFAAsF;IACtF,OAAO,CAAC,cAAc,CAAS;IAC/B,0FAA0F;IAC1F,OAAO,CAAC,MAAM,CAAS;IAEvB;;;OAGG;gBAC0B,MAAM,EAAE,WAAW,EAAmB,SAAS,GAAE,aAA+B;IAE7G,2DAA2D;IAC3D,IAAW,aAAa,IAAI,MAAM,CAEjC;IAED;;;;OAIG;IACI,cAAc,IAAI,cAAc,EAAE;IAIzC;;;;OAIG;IACU,KAAK,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC1D;;;;OAIG;IACI,KAAK,IAAI,IAAI;IAMpB,sGAAsG;IACtG,OAAO,CAAC,MAAM;IAgBd,uFAAuF;IACvF,OAAO,CAAC,gBAAgB;YAUV,iBAAiB;YAYjB,IAAI;CAoCnB"}

package/dist/session/RecordingShardQueue.js

@@ -1,71 +1,83 @@
-/**
- * @fileoverview Retry queue for crash-recovery audio shards.
- *
- * The browser recorder is snapshotted every ~15 s and each snapshot ("shard") is uploaded so a tab
- * crash loses at most one window of audio. Before this queue a failed upload was never retried, so a
- * single transient error left a permanent gap in the recovered recording (#5197). The queue keeps
- * failed shards and resends them, oldest first, on later flushes — bounded so a dead server cannot
- * grow memory without limit.
- *
- * @module @memberjunction/realtime-runtime
- */
 /** Total upload attempts per shard (the first try plus retries) before it is dropped. */
 export const MAX_SHARD_UPLOAD_ATTEMPTS = 3;
 /**
- * Flushes allowed in flight at once. Ticks are 15 s apart, so overlap only happens when an upload is
- * slower than a tick; an unbounded pile-up on a dead network would snapshot (and hold in memory) a
- * new window every tick. A skipped tick costs nothing: the recorder keeps the audio and the next
- * flush ships the larger window. While both slots are pinned the recorder cursor does not advance,
- * so the next capture is one larger window (bounded by the upload timeout x attempts); if that
- * shard is later dropped, recovery fills a correspondingly longer gap with silence.
+ * Flushes allowed in flight at once. Flushes are ~5 s apart, so overlap only happens when an upload
+ * is slower than a tick; an unbounded pile-up on a dead network would start a new batch of uploads
+ * every tick. A flush that arrives at capacity does not upload, but it does not lose its shards
+ * either: they are retained and the next flush that has a free slot sends them, oldest first.
  */
 export const MAX_CONCURRENT_FLUSHES = 2;
 /**
  * Per-attempt upload deadline. A hung request would otherwise pin one of the
  * {@link MAX_CONCURRENT_FLUSHES} slots forever and silently stop all later shards. A timeout counts
  * as a failed attempt; if the request later succeeds anyway that is harmless, because the server
- * key is per-index and a resend is an idempotent overwrite. The timeout is logical only:
- * `ExecuteGQL` accepts no AbortSignal, so a timed-out request may still be on the wire. Requests
- * stay rate-bounded regardless (at most {@link MAX_CONCURRENT_FLUSHES} flushes, each sending at
- * most one batch, per timeout window), and a late success is an idempotent same-index overwrite.
+ * key is per-index and a resend of the same bytes is an idempotent overwrite. The timeout is
+ * logical only: the transport may accept no AbortSignal, so a timed-out request may still be on the
+ * wire. Requests stay rate-bounded regardless (at most {@link MAX_CONCURRENT_FLUSHES} flushes, each
+ * sending at most one batch, per timeout window).
  */
 export const SHARD_UPLOAD_TIMEOUT_MS = 60_000;
+/**
+ * Cap on shards held for retry: 10 minutes of 5 s shards. A dead network with flushes at capacity
+ * would otherwise grow the retained list (and its bytes) without bound. Overflow drops the oldest;
+ * dropped shards remain in the IndexedDB store for the next-load drain.
+ */
+export const MAX_RETAINED_SHARDS = 120;
 /** One-line reason for a warn message; the raw value is still passed along for its stack. */
 function describeFailure(failure) {
     return failure instanceof Error ? failure.message : String(failure);
 }
 /**
- * Assigns chronological indexes to crash-recovery shards, uploads them, and retains failures for
- * retry on later flushes. Safe to call {@link Flush} from an overlapping timer.
+ * Uploads indexed shards and retains failures for retry on later flushes. A retry keeps its shard's
+ * index and bytes. Safe to call {@link Flush} from an overlapping timer.
  */
 export class RecordingShardQueue {
-    constructor() {
-        this.nextIndex = 0;
+    /**
+     * @param upload sends one shard
+     * @param onGivenUp told about every shard dropped while the recording is live (not on {@link Close})
+     */
+    constructor(upload, onGivenUp = () => undefined) {
+        this.upload = upload;
+        this.onGivenUp = onGivenUp;
         this.retained = [];
+        /** Every shard handed to the queue and not yet acknowledged or given up on, by index. */
+        this.outstanding = new Map();
         this.inFlight = 0;
         /** True once a capacity stall has been logged; cleared when a flush actually runs. */
         this.capacityWarned = false;
-        /** Set by {@link Close} when the recording ends; nothing is snapshotted, sent or retained after it. */
+        /** Set by {@link Close} when the recording ends; nothing is sent or retained after it. */
         this.closed = false;
-        /**
-         * Serializes "take a snapshot, then assign an index". The recorder advances its cursor
-         * synchronously but encodes asynchronously, so two overlapping snapshots could resolve out of
-         * order and give newer audio an older index. Never rejected: the link catches internally.
-         */
-        this.captureChain = Promise.resolve();
     }
     /** Shards awaiting a retry (for tests and diagnostics). */
     get RetainedCount() {
         return this.retained.length;
     }
     /**
-     * Takes ownership of retained shards and uploads them oldest-first, then captures a new window
-     * and uploads it. Retained shards go first so a hung snapshot cannot strand them. A failure never
-     * stops the rest of the flush. Skips entirely (no snapshot) when
-     * {@link MAX_CONCURRENT_FLUSHES} are already running. Never rejects.
+     * Every shard the queue still holds without an acknowledgement — on the wire, waiting in a flush's
+     * batch, or retained for a retry — oldest first. A page that is about to unload re-sends these with
+     * `keepalive`, because its ordinary requests are aborted with it.
      */
-    async Flush(snapshot, upload) {
+    Unacknowledged() {
+        return [...this.outstanding.values()].sort((a, b) => a.Index - b.Index);
+    }
+    /**
+     * Uploads retained shards oldest-first, then `fresh`. A failure never stops the rest of the
+     * flush. At {@link MAX_CONCURRENT_FLUSHES} in flight nothing is uploaded and `fresh` is retained
+     * for the next flush instead. Never rejects.
+     */
+    async Flush(fresh) {
+        if (this.closed) {
+            if (fresh.length > 0) {
+                console.warn(`[RealtimeSession] Recording flush after the recording ended; shard(s) ${fresh.map((s) => s.Index).join(', ')} not sent — they stay in the local store and are drained later.`);
+            }
+            return;
+        }
+        const freshPending = fresh.map((shard) => ({ Shard: shard, Attempts: 0 }));
+        for (const shard of fresh) {
+            this.outstanding.set(shard.Index, shard);
+        }
         if (this.inFlight >= MAX_CONCURRENT_FLUSHES) {
+            this.retain(freshPending);
             this.warnCapacitySkip();
             return;
         }
@@ -73,22 +85,15 @@ export class RecordingShardQueue {
         this.inFlight++;
         try {
             // Swap the array out so a concurrent flush only sees shards nobody is currently sending.
-            const batch = this.retained;
+            const batch = [...this.retained, ...freshPending].sort((a, b) => a.Shard.Index - b.Shard.Index);
             this.retained = [];
-            // Retained shards go first, BEFORE the capture: a snapshot that never resolves must not strand
-            // shards that already failed. Index order is unaffected — indexes are assigned in capture order
-            // on the serialized chain, and every retained shard already has an older index.
-            // `closed` is re-checked before every send: a flush running when the recording ends must not
-            // keep uploading, or a resend could land after the end-of-call upload has deleted the shards.
-            for (const shard of batch) {
+            for (const pending of batch) {
+                // Re-checked before every send: a flush running when the recording ends must not keep
+                // uploading shards the terminal request is about to supersede.
                 if (this.closed) {
                     return;
                 }
-                await this.send(shard, upload);
-            }
-            const fresh = this.closed ? null : await this.captureShard(snapshot);
-            if (fresh && !this.closed) {
-                await this.send(fresh, upload);
+                await this.send(pending);
             }
         }
         finally {
@@ -97,76 +102,75 @@ export class RecordingShardQueue {
     }
     /**
      * Ends the queue with its recording: discards retained shards and stops any flush in flight from
-     * sending more. An upload already on the wire cannot be aborted (`ExecuteGQL` takes no
-     * AbortSignal), so at most that one request can still land.
+     * sending more. An upload already on the wire cannot be aborted, so at most that one request can
+     * still land. Discarded shards remain in the IndexedDB store and are drained on a later load.
      */
     Close() {
         this.closed = true;
         this.retained = [];
+        this.outstanding.clear();
+    }
+    /** Sorted re-insert: concurrent flushes can fail out of index order, and the oldest must go first. */
+    retain(pending) {
+        this.retained.push(...pending);
+        this.retained.sort((a, b) => a.Shard.Index - b.Shard.Index);
+        const overflow = this.retained.length - MAX_RETAINED_SHARDS;
+        if (overflow > 0) {
+            const dropped = this.retained.splice(0, overflow);
+            for (const pending of dropped) {
+                this.outstanding.delete(pending.Shard.Index);
+            }
+            console.warn(`[RealtimeSession] Retry queue over ${MAX_RETAINED_SHARDS} shards; dropped oldest shard(s) ${dropped.map((p) => p.Shard.Index).join(', ')} from memory — they stay in the local IndexedDB store and are re-sent from it once uploads succeed again.`);
+            this.onGivenUp(dropped.map((p) => p.Shard));
+        }
     }
-    /** Warns once per stall so a wedged uploader is visible without logging every 15 s tick. */
+    /** Warns once per stall so a wedged uploader is visible without logging every tick. */
     warnCapacitySkip() {
         if (this.capacityWarned) {
             return;
         }
         this.capacityWarned = true;
-        console.warn(`[RealtimeSession] Recording flush skipped: at capacity with ${this.inFlight}/${MAX_CONCURRENT_FLUSHES} flushes in flight and ${this.retained.length} shard(s) retained. The recorder keeps the audio for the next flush.`);
-    }
-    captureShard(snapshot) {
-        const capture = this.captureChain.then(() => this.takeIndexedSnapshot(snapshot));
-        this.captureChain = capture.then(() => undefined);
-        return capture;
-    }
-    async takeIndexedSnapshot(snapshot) {
-        try {
-            const audio = await snapshot();
-            if (!audio) {
-                return null;
-            }
-            return { Index: this.nextIndex++, AudioBase64: audio, Attempts: 0 };
-        }
-        catch (error) {
-            console.warn('[RealtimeSession] Failed to snapshot recording shard:', error);
-            return null;
-        }
+        console.warn(`[RealtimeSession] Recording flush at capacity: ${this.inFlight}/${MAX_CONCURRENT_FLUSHES} flushes in flight, ${this.retained.length} shard(s) retained. Retained shards are sent by the next flush with a free slot.`);
     }
-    async uploadWithTimeout(upload, shard) {
+    async uploadWithTimeout(shard) {
         let timer;
         const deadline = new Promise((_, reject) => {
             timer = setTimeout(() => reject(new Error(`upload timed out after ${SHARD_UPLOAD_TIMEOUT_MS}ms`)), SHARD_UPLOAD_TIMEOUT_MS);
         });
         try {
-            return await Promise.race([upload(shard.Index, shard.AudioBase64), deadline]);
+            return await Promise.race([this.upload(shard), deadline]);
         }
         finally {
             clearTimeout(timer);
         }
     }
-    async send(shard, upload) {
-        shard.Attempts++;
+    async send(pending) {
+        const { Shard: shard } = pending;
+        pending.Attempts++;
         let stored = false;
         let failure = 'server refused the shard';
         try {
-            stored = await this.uploadWithTimeout(upload, shard);
+            stored = await this.uploadWithTimeout(shard);
         }
         catch (error) {
             failure = error;
         }
         if (stored) {
+            this.outstanding.delete(shard.Index);
             return;
         }
         if (this.closed) {
-            console.warn(`[RealtimeSession] Recording shard ${shard.Index} upload failed after the recording ended (${describeFailure(failure)}); not retried — the end-of-call upload supersedes it:`, failure);
+            console.warn(`[RealtimeSession] Recording shard ${shard.Index} upload failed after the recording ended (${describeFailure(failure)}); not retried — it stays in the local store and is drained later:`, failure);
             return;
         }
-        if (shard.Attempts >= MAX_SHARD_UPLOAD_ATTEMPTS) {
-            console.warn(`[RealtimeSession] Dropping recording shard ${shard.Index} after ${shard.Attempts}/${MAX_SHARD_UPLOAD_ATTEMPTS} failed uploads (${describeFailure(failure)}); recovery will fill the gap with silence:`, failure);
+        if (pending.Attempts >= MAX_SHARD_UPLOAD_ATTEMPTS) {
+            console.warn(`[RealtimeSession] Dropping recording shard ${shard.Index} from the retry queue after ${pending.Attempts}/${MAX_SHARD_UPLOAD_ATTEMPTS} failed uploads (${describeFailure(failure)}); it stays in the local store and is re-sent from it once uploads succeed again:`, failure);
+            this.outstanding.delete(shard.Index);
+            this.onGivenUp([shard]);
             return;
         }
-        console.warn(`[RealtimeSession] Recording shard ${shard.Index} upload failed (attempt ${shard.Attempts}/${MAX_SHARD_UPLOAD_ATTEMPTS}: ${describeFailure(failure)}); will retry next flush:`, failure);
-        // Sorted re-insert: concurrent flushes can fail out of index order, and the oldest must go first.
-        this.retained.push(shard);
-        this.retained.sort((a, b) => a.Index - b.Index);
+        console.warn(`[RealtimeSession] Recording shard ${shard.Index} upload failed (attempt ${pending.Attempts}/${MAX_SHARD_UPLOAD_ATTEMPTS}: ${describeFailure(failure)}); will retry next flush:`, failure);
+        this.retain([pending]);
     }
 }
 //# sourceMappingURL=RecordingShardQueue.js.map

package/dist/session/RecordingShardQueue.js.map

@@ -1 +1 @@
-{"version":3,"file":"RecordingShardQueue.js","sourceRoot":"","sources":["../../src/session/RecordingShardQueue.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"RecordingShardQueue.js","sourceRoot":"","sources":["../../src/session/RecordingShardQueue.ts"],"names":[],"mappings":"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"}