@agent-native/core 0.134.1 → 0.135.0

package/corpus/templates/clips/server/lib/upload-lease.ts

@@ -12,7 +12,7 @@
  */
 
 import { getDbExec, isPostgres } from "@agent-native/core/db";
-import { and, eq, inArray, sql } from "drizzle-orm";
+import { and, eq, inArray, isNull, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../db/index.js";
 
@@ -37,6 +37,7 @@ export type UploadLeaseResult =
   | { held: true }
   | {
       held: false;
+      staleAttempt: boolean;
       status: string | null;
       failureReason: string | null;
       videoUrl: string | null;
@@ -53,7 +54,12 @@ export type UploadLeaseResult =
  */
 export async function renewUploadLease(
   recordingId: string,
-  options: { now?: number; uploadProgress?: number } = {},
+  options: {
+    now?: number;
+    uploadProgress?: number;
+    attemptId?: string | null;
+    generationId?: string | null;
+  } = {},
 ): Promise<UploadLeaseResult> {
   const now = options.now ?? Date.now();
   const held = await getDb()
@@ -72,6 +78,23 @@ export async function renewUploadLease(
       and(
         eq(schema.recordings.id, recordingId),
         inArray(schema.recordings.status, [...IN_PROGRESS_STATUSES]),
+        ...(options.attemptId === undefined
+          ? []
+          : [
+              options.attemptId === null
+                ? isNull(schema.recordings.uploadAttemptId)
+                : eq(schema.recordings.uploadAttemptId, options.attemptId),
+            ]),
+        ...(options.generationId === undefined
+          ? []
+          : [
+              options.generationId === null
+                ? isNull(schema.recordings.uploadGenerationId)
+                : eq(
+                    schema.recordings.uploadGenerationId,
+                    options.generationId,
+                  ),
+            ]),
       ),
     )
     .returning({ id: schema.recordings.id });
@@ -87,12 +110,23 @@ export async function renewUploadLease(
       videoUrl: schema.recordings.videoUrl,
       videoSizeBytes: schema.recordings.videoSizeBytes,
       durationMs: schema.recordings.durationMs,
+      uploadAttemptId: schema.recordings.uploadAttemptId,
+      uploadGenerationId: schema.recordings.uploadGenerationId,
     })
     .from(schema.recordings)
     .where(eq(schema.recordings.id, recordingId));
 
   return {
     held: false,
+    staleAttempt:
+      (options.attemptId !== undefined || options.generationId !== undefined) &&
+      IN_PROGRESS_STATUSES.includes(
+        row?.status as (typeof IN_PROGRESS_STATUSES)[number],
+      ) &&
+      ((options.attemptId !== undefined &&
+        row?.uploadAttemptId !== options.attemptId) ||
+        (options.generationId !== undefined &&
+          row?.uploadGenerationId !== options.generationId)),
     status: row?.status ?? null,
     failureReason: row?.failureReason ?? null,
     videoUrl: row?.videoUrl ?? null,
@@ -106,6 +140,7 @@ export interface ReapedUpload {
   ownerEmail: string;
   status: string;
   leaseExpiresAt: string;
+  uploadGenerationId: string | null;
 }
 
 export interface ReapResult {
@@ -137,7 +172,7 @@ export async function reapExpiredUploads(
 
   // guard:allow-unscoped — system upload reaper, owner-agnostic by design.
   const probe = await exec.execute({
-    sql: `SELECT id, owner_email, status, upload_lease_expires_at
+    sql: `SELECT id, owner_email, status, upload_lease_expires_at, upload_generation_id
           FROM recordings
           WHERE status IN ('uploading', 'processing')
             AND upload_lease_expires_at IS NOT NULL
@@ -154,6 +189,10 @@ export async function reapExpiredUploads(
     ownerEmail: String(row.owner_email ?? ""),
     status: String(row.status ?? ""),
     leaseExpiresAt: String(row.upload_lease_expires_at ?? ""),
+    uploadGenerationId:
+      typeof row.upload_generation_id === "string"
+        ? row.upload_generation_id
+        : null,
   }));
 
   let failed = 0;
@@ -184,9 +223,16 @@ export async function reapExpiredUploads(
     failed = terminated.size;
 
     for (const id of terminated) {
+      const generationId = expired.find(
+        (row) => row.id === id,
+      )?.uploadGenerationId;
       await exec.execute({
         sql: `DELETE FROM application_state WHERE key = ${p(1)}`,
-        args: [`resumable-session-${id}`],
+        args: [
+          generationId
+            ? `resumable-session-${id}-${generationId}`
+            : `resumable-session-${id}`,
+        ],
       });
     }
   }

package/corpus/templates/clips/server/lib/video-filmstrip-sprite.ts

@@ -0,0 +1,207 @@
+/**
+ * Generate a filmstrip sprite — one JPEG holding a grid of evenly-spaced video
+ * frames — so the editor timeline renders thumbnails as a single cached image
+ * request instead of decoding the video in the browser.
+ *
+ * Why a sprite rather than per-frame files: one ffmpeg pass, one upload, one
+ * HTTP request, and the grid geometry is enough for CSS `background-position`
+ * to address any cell. The browser fallback in `app/lib/video-filmstrip.ts`
+ * needs one seek per frame and cannot read cross-origin media at all.
+ *
+ * Three constraints worth keeping in mind:
+ *
+ *   - Cells are padded to an exact size (`force_original_aspect_ratio=decrease`
+ *     plus `pad`) so the returned grid geometry is exact without probing the
+ *     source. Letterboxed bars on odd aspect ratios are the deliberate cost of
+ *     not having to decode the output to learn its dimensions.
+ *   - Sampling starts half a cell in, matching the browser fallback: cell `i`
+ *     shows the midpoint of the time slot it occupies, not its leading edge.
+ *   - Input arrives as bytes and is written to a temp file, like every other
+ *     ffmpeg path here. That means the whole file is buffered in memory by the
+ *     caller, which is the practical ceiling on this approach for long
+ *     recordings on small hosts.
+ */
+
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { isFfmpegAvailable, runFfmpeg, withRemuxSlot } from "./video-remux.js";
+
+const SPRITE_TIMEOUT_MS = 90_000;
+
+export const DEFAULT_FILMSTRIP_FRAME_COUNT = 40;
+// A sprite is decoded whole by the browser, so cap the grid: 120 cells at the
+// default size is already a ~1600x1080 image.
+export const MAX_FILMSTRIP_FRAME_COUNT = 120;
+export const DEFAULT_FILMSTRIP_FRAME_WIDTH = 160;
+export const DEFAULT_FILMSTRIP_FRAME_HEIGHT = 90;
+export const DEFAULT_FILMSTRIP_COLUMNS = 10;
+
+export type FilmstripSpriteStatus =
+  | "generated"
+  | "skipped-no-ffmpeg"
+  | "skipped-no-duration"
+  | "skipped-no-media"
+  | "failed-ffmpeg"
+  | "failed-empty-output";
+
+/** Everything the UI needs to address one cell of the sprite. */
+export interface FilmstripSpriteGrid {
+  frameCount: number;
+  columns: number;
+  rows: number;
+  frameWidth: number;
+  frameHeight: number;
+}
+
+export interface FilmstripSpriteResult {
+  status: FilmstripSpriteStatus;
+  /** Present only when `status === "generated"`. */
+  sprite?: { bytes: Uint8Array; grid: FilmstripSpriteGrid };
+  detail?: string;
+}
+
+export interface GenerateFilmstripSpriteInput {
+  mediaBytes: Uint8Array;
+  durationMs: number;
+  frameCount?: number;
+  frameWidth?: number;
+  frameHeight?: number;
+  columns?: number;
+}
+
+/**
+ * Lay `frameCount` cells out into a grid no wider than `columns`. Exported so
+ * callers can compute the same geometry the sprite will have without
+ * regenerating it.
+ */
+export function filmstripGrid(input: {
+  frameCount: number;
+  columns: number;
+  frameWidth: number;
+  frameHeight: number;
+}): FilmstripSpriteGrid {
+  const frameCount = Math.min(
+    MAX_FILMSTRIP_FRAME_COUNT,
+    Math.max(1, Math.floor(input.frameCount)),
+  );
+  const columns = Math.max(1, Math.min(input.columns, frameCount));
+  return {
+    frameCount,
+    columns,
+    rows: Math.ceil(frameCount / columns),
+    frameWidth: input.frameWidth,
+    frameHeight: input.frameHeight,
+  };
+}
+
+/**
+ * Build the ffmpeg filter chain that samples `frameCount` frames across
+ * `durationMs` and tiles them into `grid`. Exported for tests: the sampling
+ * offset and rate are the parts most likely to drift from the browser
+ * fallback's expectations.
+ */
+export function filmstripSpriteFilter(input: {
+  durationMs: number;
+  grid: FilmstripSpriteGrid;
+}): { seekSeconds: string; filter: string } {
+  const { durationMs, grid } = input;
+  const cellMs = durationMs / grid.frameCount;
+  const fps = grid.frameCount / (durationMs / 1000);
+
+  return {
+    // Half a cell in, so each tile is the midpoint of its slot.
+    seekSeconds: (cellMs / 2 / 1000).toFixed(6),
+    filter: [
+      `fps=${fps.toFixed(6)}`,
+      `scale=${grid.frameWidth}:${grid.frameHeight}:force_original_aspect_ratio=decrease`,
+      `pad=${grid.frameWidth}:${grid.frameHeight}:-1:-1:color=black`,
+      `tile=${grid.columns}x${grid.rows}`,
+    ].join(","),
+  };
+}
+
+export async function generateFilmstripSprite(
+  input: GenerateFilmstripSpriteInput,
+): Promise<FilmstripSpriteResult> {
+  const {
+    mediaBytes,
+    durationMs,
+    frameCount = DEFAULT_FILMSTRIP_FRAME_COUNT,
+    frameWidth = DEFAULT_FILMSTRIP_FRAME_WIDTH,
+    frameHeight = DEFAULT_FILMSTRIP_FRAME_HEIGHT,
+    columns = DEFAULT_FILMSTRIP_COLUMNS,
+  } = input;
+
+  if (mediaBytes.byteLength === 0) {
+    return { status: "skipped-no-media" };
+  }
+  if (!Number.isFinite(durationMs) || durationMs <= 0) {
+    return { status: "skipped-no-duration" };
+  }
+  if (!isFfmpegAvailable()) {
+    return {
+      status: "skipped-no-ffmpeg",
+      detail:
+        "No ffmpeg binary available; the editor falls back to browser-side frame extraction.",
+    };
+  }
+
+  const grid = filmstripGrid({ frameCount, columns, frameWidth, frameHeight });
+  const { seekSeconds, filter } = filmstripSpriteFilter({ durationMs, grid });
+
+  const dir = await mkdtemp(join(tmpdir(), "clips-filmstrip-"));
+  const inputPath = join(dir, "input.media");
+  const outputPath = join(dir, "sprite.jpg");
+
+  try {
+    await writeFile(inputPath, mediaBytes);
+    await withRemuxSlot(() =>
+      runFfmpeg(
+        [
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-nostdin",
+          "-y",
+          // Input seeking: cheap, and puts the first sample at a cell midpoint.
+          "-ss",
+          seekSeconds,
+          "-i",
+          inputPath,
+          "-an",
+          "-sn",
+          "-vf",
+          filter,
+          // The tile filter emits the finished grid as a single frame.
+          "-frames:v",
+          "1",
+          "-q:v",
+          "4",
+          "-f",
+          "image2",
+          outputPath,
+        ],
+        { timeoutMs: SPRITE_TIMEOUT_MS, label: "filmstrip sprite" },
+      ),
+    );
+
+    const bytes = new Uint8Array(await readFile(outputPath));
+    if (bytes.byteLength === 0) {
+      return {
+        status: "failed-empty-output",
+        detail: "ffmpeg reported success but wrote an empty sprite",
+      };
+    }
+
+    return { status: "generated", sprite: { bytes, grid } };
+  } catch (err) {
+    return {
+      status: "failed-ffmpeg",
+      detail: err instanceof Error ? err.message : String(err),
+    };
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+}

package/corpus/templates/clips/server/lib/video-remux.ts

@@ -125,7 +125,11 @@ function startsWithMagic(bytes: Uint8Array, magic: number[]): boolean {
   return true;
 }
 
-async function runFfmpeg(args: string[]): Promise<void> {
+export async function runFfmpeg(
+  args: string[],
+  options: { timeoutMs?: number; label?: string } = {},
+): Promise<void> {
+  const { timeoutMs = REMUX_TIMEOUT_MS, label = "remux" } = options;
   await new Promise<void>((resolve, reject) => {
     const child = spawn(ffmpegCommand(), args, {
       stdio: ["ignore", "ignore", "pipe"],
@@ -133,8 +137,8 @@ async function runFfmpeg(args: string[]): Promise<void> {
     let stderr = "";
     const timeout = setTimeout(() => {
       child.kill("SIGKILL");
-      reject(new Error(`ffmpeg remux timed out\n${stderr}`));
-    }, REMUX_TIMEOUT_MS);
+      reject(new Error(`ffmpeg ${label} timed out\n${stderr}`));
+    }, timeoutMs);
 
     child.stderr?.on("data", (chunk: Buffer) => {
       stderr = (stderr + chunk.toString("utf8")).slice(-STDERR_LIMIT);
@@ -244,7 +248,12 @@ export async function probeHasAudioStream(
   }
 }
 
-async function withRemuxSlot<T>(fn: () => Promise<T>): Promise<T> {
+/**
+ * Bound concurrent ffmpeg invocations process-wide. Every ffmpeg caller must go
+ * through this, including non-remux jobs — the limit protects the box, not the
+ * remux path specifically.
+ */
+export async function withRemuxSlot<T>(fn: () => Promise<T>): Promise<T> {
   if (activeRemuxes >= MAX_CONCURRENT_REMUXES) {
     await new Promise<void>((resolve) => remuxWaiters.push(resolve));
   }

package/corpus/templates/clips/server/plugins/db.ts

@@ -193,6 +193,12 @@ const migrations = runMigrations(
       description TEXT NOT NULL DEFAULT '',
       thumbnail_url TEXT,
       animated_thumbnail_url TEXT,
+      filmstrip_url TEXT,
+      filmstrip_frame_count INTEGER NOT NULL DEFAULT 0,
+      filmstrip_columns INTEGER NOT NULL DEFAULT 0,
+      filmstrip_rows INTEGER NOT NULL DEFAULT 0,
+      filmstrip_frame_width INTEGER NOT NULL DEFAULT 0,
+      filmstrip_frame_height INTEGER NOT NULL DEFAULT 0,
       duration_ms INTEGER NOT NULL DEFAULT 0,
       video_url TEXT,
       video_format TEXT NOT NULL DEFAULT 'webm',
@@ -899,6 +905,16 @@ const migrations = runMigrations(
         `UPDATE recordings SET upload_lease_expires_at = '${uploadLeaseExpiry()}' WHERE upload_lease_expires_at IS NULL AND status IN ('uploading', 'processing')`,
       ].join("; "),
     },
+    {
+      version: 54,
+      name: "recording-upload-attempt-fence",
+      sql: `ALTER TABLE recordings ADD COLUMN IF NOT EXISTS upload_attempt_id TEXT`,
+    },
+    {
+      version: 55,
+      name: "recording-upload-generation-fence",
+      sql: `ALTER TABLE recordings ADD COLUMN IF NOT EXISTS upload_generation_id TEXT`,
+    },
   ],
   { table: "clips_migrations" },
 );

package/corpus/templates/clips/server/routes/api/_agent-native-background/post-finalize-worker.post.ts

@@ -66,6 +66,7 @@ export default defineEventHandler(async (event: H3Event) => {
       ownerEmail: schema.recordings.ownerEmail,
       orgId: schema.recordings.orgId,
       status: schema.recordings.status,
+      uploadGenerationId: schema.recordings.uploadGenerationId,
     })
     .from(schema.recordings)
     .where(eq(schema.recordings.id, recordingId))
@@ -120,6 +121,9 @@ export default defineEventHandler(async (event: H3Event) => {
         const result = await finalizeRecording.run({
           id: recordingId,
           mediaVerificationRetryAttempt: retryAttempt ?? 1,
+          ...(recording.uploadGenerationId
+            ? { uploadGenerationId: recording.uploadGenerationId }
+            : {}),
         });
         return { ok: true, kind, result };
       }

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/abort.post.ts

@@ -6,14 +6,13 @@
  */
 
 import {
-  deleteAppState,
+  compareAndSetManyAppState,
   readAppState,
   writeAppState,
-  deleteAppStateByPrefix,
 } from "@agent-native/core/application-state";
 import { runWithRequestContext } from "@agent-native/core/server";
 import { isStoredButUnservableFinalizeError } from "@shared/finalize-recovery.js";
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import {
   defineEventHandler,
   getRouterParam,
@@ -24,6 +23,7 @@ import {
 
 import { getDb, schema } from "../../../../db/index.js";
 import { mediaVerificationStateKey } from "../../../../lib/media-verification-state.js";
+import { deleteRecordingChunks } from "../../../../lib/recording-upload-state.js";
 import {
   getEventOwnerContext,
   ownerEmailMatches,
@@ -44,11 +44,25 @@ export default defineEventHandler(async (event: H3Event) => {
   const { userEmail: ownerEmail, orgId } = await getEventOwnerContext(event);
   const body = (await readBody(event).catch(() => null)) as {
     reason?: unknown;
+    attemptId?: unknown;
+    uploadGenerationId?: unknown;
   } | null;
   const failureReason =
     typeof body?.reason === "string" && body.reason.trim()
       ? body.reason.trim().slice(0, 1000)
       : "Upload aborted by user";
+  const requestedAttemptId =
+    typeof body?.attemptId === "string" &&
+    body.attemptId.length > 0 &&
+    body.attemptId.length <= 128
+      ? body.attemptId
+      : null;
+  const requestedGenerationId =
+    typeof body?.uploadGenerationId === "string" &&
+    body.uploadGenerationId.length > 0 &&
+    body.uploadGenerationId.length <= 128
+      ? body.uploadGenerationId
+      : null;
 
   return runWithRequestContext({ userEmail: ownerEmail, orgId }, async () => {
     const db = getDb();
@@ -59,6 +73,8 @@ export default defineEventHandler(async (event: H3Event) => {
         status: schema.recordings.status,
         videoUrl: schema.recordings.videoUrl,
         failureReason: schema.recordings.failureReason,
+        uploadAttemptId: schema.recordings.uploadAttemptId,
+        uploadGenerationId: schema.recordings.uploadGenerationId,
       })
       .from(schema.recordings)
       .where(
@@ -73,17 +89,43 @@ export default defineEventHandler(async (event: H3Event) => {
       return { error: "Recording not found" };
     }
 
+    const existingAttemptId = existing.uploadAttemptId ?? null;
+    const existingGenerationId = existing.uploadGenerationId ?? null;
+    if (
+      requestedAttemptId !== existingAttemptId ||
+      requestedGenerationId !== existingGenerationId
+    ) {
+      setResponseStatus(event, 409);
+      return {
+        error: "A newer upload retry is already active.",
+        staleAttempt: true,
+      };
+    }
+
     if (existing.status === "ready" && existing.videoUrl) {
       return { ok: true, recordingId, alreadyReady: true, chunksCleared: 0 };
     }
 
-    const existingUploadStateRaw = await readAppState(
-      `recording-upload-${recordingId}`,
-    ).catch(() => null);
+    const uploadStateKey = `recording-upload-${recordingId}`;
+    const verificationStateKey = mediaVerificationStateKey(recordingId);
+    const [existingUploadStateRaw, existingVerificationStateRaw] =
+      await Promise.all([
+        readAppState(uploadStateKey),
+        readAppState(verificationStateKey),
+      ]);
     const existingUploadState =
       existingUploadStateRaw && typeof existingUploadStateRaw === "object"
         ? (existingUploadStateRaw as Record<string, unknown>)
         : {};
+    const existingUploadStateSnapshot =
+      existingUploadStateRaw && typeof existingUploadStateRaw === "object"
+        ? (existingUploadStateRaw as Record<string, unknown>)
+        : null;
+    const existingVerificationStateSnapshot =
+      existingVerificationStateRaw &&
+      typeof existingVerificationStateRaw === "object"
+        ? (existingVerificationStateRaw as Record<string, unknown>)
+        : null;
     if (
       existing.status === "processing" &&
       existingUploadState.pendingMediaVerification === true
@@ -99,46 +141,87 @@ export default defineEventHandler(async (event: H3Event) => {
     const preserveRecoveryState =
       isStoredButUnservableFinalizeError(failureReason) ||
       isStoredButUnservableFinalizeError(existing.failureReason);
-    const resumableSession = preserveRecoveryState
+    let resumableSession = preserveRecoveryState
       ? null
-      : await getResumableSession(recordingId).catch(() => null);
-
-    // Already a terminal failure (e.g. a duplicate/retried abort call, or
-    // finalize's own failChunkAssembly already flipped it) — no-op unless a
-    // prior provider cleanup failure intentionally retained a resumable
-    // session for this retry.
-    if (
-      existing.status === "failed" &&
-      !preserveRecoveryState &&
-      !resumableSession
-    ) {
-      return { ok: true, recordingId, alreadyFailed: true, chunksCleared: 0 };
-    }
+      : await getResumableSession(recordingId, existingGenerationId);
 
     const now = new Date().toISOString();
-    await db
+    const aborted = await db
       .update(schema.recordings)
       .set({
         status: "failed",
         failureReason,
         updatedAt: now,
       })
-      .where(eq(schema.recordings.id, recordingId));
-
-    await writeAppState(`recording-upload-${recordingId}`, {
-      ...existingUploadState,
-      recordingId,
-      status: "failed",
-      failureReason,
-      updatedAt: now,
-    });
-    await deleteAppState(mediaVerificationStateKey(recordingId)).catch(
-      () => {},
-    );
+      .where(
+        and(
+          eq(schema.recordings.id, recordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+          eq(schema.recordings.status, existing.status),
+          existingAttemptId === null
+            ? isNull(schema.recordings.uploadAttemptId)
+            : eq(schema.recordings.uploadAttemptId, existingAttemptId),
+          existingGenerationId === null
+            ? isNull(schema.recordings.uploadGenerationId)
+            : eq(schema.recordings.uploadGenerationId, existingGenerationId),
+        ),
+      )
+      .returning({ id: schema.recordings.id });
+
+    if (aborted.length !== 1) {
+      setResponseStatus(event, 409);
+      return {
+        error: "A newer upload retry is already active.",
+        staleAttempt: true,
+      };
+    }
+
+    const auxiliaryStateUpdated = await compareAndSetManyAppState([
+      {
+        key: uploadStateKey,
+        expectedValue: existingUploadStateSnapshot,
+        nextValue: {
+          ...existingUploadState,
+          recordingId,
+          status: "failed",
+          failureReason,
+          updatedAt: now,
+        },
+      },
+      ...(existingVerificationStateSnapshot
+        ? [
+            {
+              key: verificationStateKey,
+              expectedValue: existingVerificationStateSnapshot,
+              nextValue: null,
+            },
+          ]
+        : []),
+    ]);
+    if (!auxiliaryStateUpdated) {
+      console.info(
+        `[abort] upload state changed after abort claim; preserving replacement state for ${recordingId}`,
+      );
+    }
+
+    // Reset may have started this exact generation's provider session after
+    // our preflight read but before the abort claim. Re-read after the row CAS
+    // so either abort observes the late handle or reset observes the lost row
+    // claim and compensates it.
+    if (!preserveRecoveryState) {
+      resumableSession = await getResumableSession(
+        recordingId,
+        existingGenerationId,
+      );
+    }
 
     const cleared = preserveRecoveryState
       ? 0
-      : await deleteAppStateByPrefix(`recording-chunks-${recordingId}-`);
+      : await deleteRecordingChunks(
+          ownerEmail,
+          recordingId,
+          existingGenerationId,
+        );
     if (!preserveRecoveryState) {
       if (resumableSession) {
         const provider = await resolveResumableUploadProvider(
@@ -166,10 +249,14 @@ export default defineEventHandler(async (event: H3Event) => {
         // retry can still address the multipart upload. Deleting it here would
         // permanently orphan the provider-side session.
         if (providerCleanupSucceeded) {
-          await deleteResumableSession(recordingId).catch(() => {});
+          await deleteResumableSession(recordingId, existingGenerationId).catch(
+            () => {},
+          );
         }
       } else {
-        await deleteResumableSession(recordingId).catch(() => {});
+        await deleteResumableSession(recordingId, existingGenerationId).catch(
+          () => {},
+        );
       }
     }
     await writeAppState("refresh-signal", { ts: Date.now() });