@agent-native/core 0.87.0 → 0.90.1

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

@@ -787,6 +787,44 @@ const migrations = runMigrations(
         `CREATE INDEX IF NOT EXISTS recording_bug_reports_project_idx ON recording_bug_reports (project_id, updated_at)`,
       ].join("; "),
     },
+    {
+      version: 45,
+      name: "recording-transcripts-retry-count",
+      sql: `ALTER TABLE recording_transcripts ADD COLUMN IF NOT EXISTS retry_count INTEGER NOT NULL DEFAULT 0`,
+    },
+    // ---------------------------------------------------------------------------
+    // Per-view records — append-only log of counted views (who viewed a clip
+    // and when), backing the owner-facing "Viewed by" popover and the
+    // `list-clip-views` action. Newer rows include a per-player-open
+    // view_session_id so returning viewers can appear again while duplicate
+    // threshold posts for the same open are idempotent.
+    // ---------------------------------------------------------------------------
+    {
+      version: 46,
+      name: "recording-views-per-view-log",
+      sql: [
+        `CREATE TABLE IF NOT EXISTS recording_views (
+          id TEXT PRIMARY KEY,
+          recording_id TEXT NOT NULL,
+          viewer_id TEXT NOT NULL,
+          viewer_key TEXT,
+          view_session_id TEXT,
+          viewer_email TEXT,
+          viewer_name TEXT,
+          viewed_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )`,
+        `CREATE INDEX IF NOT EXISTS recording_views_recording_idx ON recording_views (recording_id, viewed_at)`,
+      ].join("; "),
+    },
+    {
+      version: 47,
+      name: "recording-views-session-idempotency",
+      sql: [
+        `ALTER TABLE recording_views ADD COLUMN IF NOT EXISTS viewer_key TEXT`,
+        `ALTER TABLE recording_views ADD COLUMN IF NOT EXISTS view_session_id TEXT`,
+        `CREATE UNIQUE INDEX IF NOT EXISTS recording_views_session_unique_idx ON recording_views (recording_id, viewer_key, view_session_id)`,
+      ].join("; "),
+    },
   ],
   { table: "clips_migrations" },
 );
@@ -1198,6 +1236,158 @@ async function sweepOrphanedRecordingChunks(): Promise<void> {
   }
 }
 
+function rowNumber(value: unknown): number {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+
+/**
+ * Sweep orphaned resumable upload sessions out of `application_state`.
+ *
+ * The streaming upload path stores provider session handles under
+ * `resumable-session-<recordingId>` and deletes them after finalize commits a
+ * ready recording. Crashes between those two steps can strand small session
+ * rows forever. We only delete sessions whose recording row is gone, or whose
+ * recording reached a terminal status more than an hour ago. Abandoned browser
+ * uploads can leave the recording stuck in `uploading`, so those are swept only
+ * after a much longer grace window.
+ */
+async function sweepOrphanedResumableSessions(): Promise<void> {
+  const exec = getDbExec();
+  const pg = isPostgres();
+
+  let sessionRows: Array<{
+    session_id?: unknown;
+    key?: unknown;
+    updated_at?: unknown;
+  }> = [];
+  try {
+    const probe = await exec.execute({
+      sql: `SELECT session_id, key, updated_at FROM application_state WHERE key LIKE 'resumable-session-%'`,
+      args: [],
+    });
+    sessionRows =
+      (probe.rows as Array<{
+        session_id?: unknown;
+        key?: unknown;
+        updated_at?: unknown;
+      }>) ?? [];
+  } catch (err) {
+    const message = (err as Error)?.message ?? String(err);
+    if (
+      /no such table:\s*application_state/i.test(message) ||
+      /relation ["']?application_state["']? does not exist/i.test(message)
+    ) {
+      return;
+    }
+    console.warn(
+      "[db] resumable-session sweep: application_state probe failed",
+      message,
+    );
+    return;
+  }
+
+  if (sessionRows.length === 0) return;
+
+  const prefix = "resumable-session-";
+  const oneHourAgoIso = new Date(Date.now() - 60 * 60 * 1000).toISOString();
+  const staleInProgressIso = new Date(
+    Date.now() - 24 * 60 * 60 * 1000,
+  ).toISOString();
+  let totalDeleted = 0;
+
+  for (const row of sessionRows) {
+    const key = typeof row.key === "string" ? row.key : "";
+    if (!key.startsWith(prefix)) continue;
+    const recordingId = key.slice(prefix.length);
+    if (!recordingId) continue;
+
+    let shouldSweep = false;
+    try {
+      const probe = await exec.execute({
+        sql: pg
+          ? `SELECT status, updated_at FROM recordings WHERE id = $1 LIMIT 1`
+          : `SELECT status, updated_at FROM recordings WHERE id = ? LIMIT 1`,
+        args: [recordingId],
+      });
+      const recording = (
+        probe.rows as Array<{ status?: string; updated_at?: string }>
+      )[0];
+      if (!recording) {
+        shouldSweep = true;
+      } else if (
+        (recording.status === "ready" || recording.status === "failed") &&
+        (recording.updated_at ?? "") < oneHourAgoIso
+      ) {
+        shouldSweep = true;
+      } else if (
+        (recording.status === "uploading" ||
+          recording.status === "processing") &&
+        (recording.updated_at ?? "") < staleInProgressIso
+      ) {
+        try {
+          await exec.execute({
+            sql: pg
+              ? `UPDATE recordings SET status = 'failed', failure_reason = $1, updated_at = $2 WHERE id = $3 AND status = $4`
+              : `UPDATE recordings SET status = 'failed', failure_reason = ?, updated_at = ? WHERE id = ? AND status = ?`,
+            args: [
+              "Upload did not finish before the resumable upload cleanup window.",
+              new Date().toISOString(),
+              recordingId,
+              recording.status,
+            ],
+          });
+        } catch (err) {
+          console.warn(
+            "[db] resumable-session sweep: stale upload mark-failed failed",
+            {
+              recordingId,
+              status: recording.status,
+              err: (err as Error)?.message ?? err,
+            },
+          );
+        }
+        shouldSweep = true;
+      }
+    } catch (err) {
+      console.warn("[db] resumable-session sweep: recording probe failed", {
+        recordingId,
+        err: (err as Error)?.message ?? err,
+      });
+      continue;
+    }
+
+    if (!shouldSweep) continue;
+
+    try {
+      await exec.execute({
+        sql: pg
+          ? `DELETE FROM application_state WHERE session_id = $1 AND key = $2`
+          : `DELETE FROM application_state WHERE session_id = ? AND key = ?`,
+        args: [String(row.session_id ?? ""), key],
+      });
+      totalDeleted += 1;
+    } catch (err) {
+      console.warn("[db] resumable-session sweep: delete failed", {
+        key,
+        updatedAt: rowNumber(row.updated_at),
+        err: (err as Error)?.message ?? err,
+      });
+    }
+  }
+
+  if (totalDeleted > 0) {
+    console.log("[db] swept orphaned resumable upload sessions", {
+      totalDeleted,
+    });
+  }
+}
+
 async function backfillRecordingOrgId(): Promise<void> {
   const exec = getDbExec();
   try {
@@ -1459,6 +1649,12 @@ export default async (nitroApp: any): Promise<void> => {
   sweepOrphanedRecordingChunks().catch((err) => {
     console.warn("[db] chunk sweep failed:", (err as Error)?.message ?? err);
   });
+  sweepOrphanedResumableSessions().catch((err) => {
+    console.warn(
+      "[db] resumable-session sweep failed:",
+      (err as Error)?.message ?? err,
+    );
+  });
 
   try {
     const summary = await ensureAdditiveColumns({

package/corpus/templates/clips/server/register-secrets.ts

@@ -218,3 +218,81 @@ registerRequiredSecret({
   kind: "api-key",
   required: false,
 });
+
+// ── Dark-launched media worker plumbing ──────────────────────────────
+// These are optional until the ai-services worker is deployed. When enabled,
+// Clips enqueues background video compression jobs there instead of using
+// Builder's existing compress-media endpoint.
+
+registerRequiredSecret({
+  key: "CLIPS_DISABLE_BUILDER_COMPRESSION",
+  label: "Disable Builder media compression",
+  description:
+    "Emergency kill switch for Clips background calls to Builder's compress-media endpoint.",
+  scope: "workspace",
+  kind: "api-key",
+  required: false,
+  validator: (value) => {
+    if (!value) return true;
+    const normalized = value.trim().toLowerCase();
+    return ["true", "1", "yes", "on", "false", "0", "no", "off"].includes(
+      normalized,
+    )
+      ? true
+      : { ok: false, error: "Use true/1/yes/on or false/0/no/off." };
+  },
+});
+
+registerRequiredSecret({
+  key: "CLIPS_MEDIA_WORKER_ENABLED",
+  label: "Clips media worker enabled",
+  description:
+    "Boolean flag for the upcoming ai-services media worker. Leave unset or false until the worker endpoint is deployed.",
+  scope: "workspace",
+  kind: "api-key",
+  required: false,
+  validator: (value) => {
+    if (!value) return true;
+    const normalized = value.trim().toLowerCase();
+    return ["true", "1", "yes", "on", "false", "0", "no", "off"].includes(
+      normalized,
+    )
+      ? true
+      : { ok: false, error: "Use true/1/yes/on or false/0/no/off." };
+  },
+});
+
+registerRequiredSecret({
+  key: "CLIPS_MEDIA_WORKER_URL",
+  label: "Clips media worker URL",
+  description:
+    "Absolute enqueue endpoint URL for the upcoming ai-services media worker.",
+  scope: "workspace",
+  kind: "api-key",
+  required: false,
+  validator: (value) => {
+    if (!value) return true;
+    try {
+      new URL(value);
+      return true;
+    } catch {
+      return { ok: false, error: "Enter an absolute URL." };
+    }
+  },
+});
+
+registerRequiredSecret({
+  key: "CLIPS_MEDIA_WORKER_SECRET",
+  label: "Clips media worker signing secret",
+  description:
+    "Shared HMAC secret used to sign media-worker enqueue requests and verify callbacks.",
+  scope: "workspace",
+  kind: "api-key",
+  required: false,
+  validator: (value) => {
+    if (!value) return true;
+    return value.length >= 24
+      ? true
+      : { ok: false, error: "Use at least 24 characters." };
+  },
+});

package/corpus/templates/clips/server/routes/_agent-native/clips/user-prefs.get.ts

@@ -0,0 +1,15 @@
+import { getSession } from "@agent-native/core/server";
+import { getUserSetting } from "@agent-native/core/settings";
+import { defineEventHandler, setResponseStatus } from "h3";
+
+const CLIPS_USER_PREFS_KEY = "clips-user-prefs";
+
+export default defineEventHandler(async (event) => {
+  const session = await getSession(event);
+  if (!session?.email) {
+    setResponseStatus(event, 401);
+    return { error: "unauthorized" };
+  }
+
+  return (await getUserSetting(session.email, CLIPS_USER_PREFS_KEY)) ?? {};
+});

package/corpus/templates/clips/server/routes/_agent-native/clips/user-prefs.put.ts

@@ -0,0 +1,27 @@
+import { getSession } from "@agent-native/core/server";
+import { putUserSetting } from "@agent-native/core/settings";
+import { defineEventHandler, getHeader, readBody, setResponseStatus } from "h3";
+
+const CLIPS_USER_PREFS_KEY = "clips-user-prefs";
+
+export default defineEventHandler(async (event) => {
+  const session = await getSession(event);
+  if (!session?.email) {
+    setResponseStatus(event, 401);
+    return { error: "unauthorized" };
+  }
+
+  const body = await readBody(event).catch(() => null);
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    setResponseStatus(event, 400);
+    return { error: "Invalid settings payload" };
+  }
+
+  await putUserSetting(
+    session.email,
+    CLIPS_USER_PREFS_KEY,
+    body as Record<string, unknown>,
+    { requestSource: getHeader(event, "x-request-source") || undefined },
+  );
+  return body;
+});

package/corpus/templates/clips/server/routes/api/media-worker/callback.post.ts

@@ -0,0 +1,88 @@
+import {
+  resolveSecret,
+  runWithRequestContext,
+} from "@agent-native/core/server";
+import { eq } from "drizzle-orm";
+import {
+  defineEventHandler,
+  getRequestHeader,
+  readRawBody,
+  setResponseStatus,
+  type H3Event,
+} from "h3";
+
+import {
+  MEDIA_WORKER_SIGNATURE_HEADER,
+  MEDIA_WORKER_TIMESTAMP_HEADER,
+  parseMediaWorkerCallback,
+  verifyMediaWorkerSignature,
+} from "../../../../shared/media-worker-contract.js";
+import { getDb, schema } from "../../../db/index.js";
+import { applyMediaWorkerCallback } from "../../../lib/builder-media-compression.js";
+import {
+  CLIPS_MEDIA_WORKER_SECRET,
+  mediaWorkerJobRecordingId,
+} from "../../../lib/media-worker.js";
+
+export default defineEventHandler(async (event: H3Event) => {
+  const rawBody = (await readRawBody(event)) ?? "";
+  let parsed: unknown = null;
+  try {
+    parsed = JSON.parse(rawBody);
+  } catch {
+    setResponseStatus(event, 400);
+    return { ok: false, error: "Invalid JSON body" };
+  }
+
+  const callback = parseMediaWorkerCallback(parsed);
+  if (!callback) {
+    setResponseStatus(event, 400);
+    return { ok: false, error: "Invalid media worker callback payload" };
+  }
+
+  const recordingId = mediaWorkerJobRecordingId(callback.jobId, "compress");
+  if (!recordingId) {
+    setResponseStatus(event, 400);
+    return { ok: false, error: "Invalid media worker jobId" };
+  }
+
+  const db = getDb();
+  const [recording] = await db
+    .select({
+      ownerEmail: schema.recordings.ownerEmail,
+      orgId: schema.recordings.orgId,
+    })
+    .from(schema.recordings)
+    .where(eq(schema.recordings.id, recordingId))
+    .limit(1);
+  if (!recording) {
+    setResponseStatus(event, 404);
+    return { ok: false, error: "Recording not found" };
+  }
+
+  return runWithRequestContext(
+    { userEmail: recording.ownerEmail, orgId: recording.orgId ?? undefined },
+    async () => {
+      const secret = await resolveSecret(CLIPS_MEDIA_WORKER_SECRET);
+      const signature = verifyMediaWorkerSignature({
+        rawBody,
+        secret,
+        timestamp: getRequestHeader(event, MEDIA_WORKER_TIMESTAMP_HEADER),
+        signature: getRequestHeader(event, MEDIA_WORKER_SIGNATURE_HEADER),
+      });
+      if (!signature.ok) {
+        setResponseStatus(event, secret ? 401 : 503);
+        return {
+          ok: false,
+          error: secret
+            ? "Invalid media worker signature"
+            : "Media worker secret is not configured",
+        };
+      }
+
+      const result = await applyMediaWorkerCallback(callback);
+      setResponseStatus(event, result.status);
+      return result;
+    },
+  );
+});

package/corpus/templates/clips/server/routes/api/public-recording.get.ts

@@ -41,7 +41,11 @@ import {
 } from "../../../shared/transcript-segments.js";
 import { getDb, schema } from "../../db/index.js";
 import { resolvePlayerVideoUrl } from "../../lib/player-video-url.js";
-import { parseSpaceIds, sameOwnerEmail } from "../../lib/recordings.js";
+import {
+  getOrganizationRoleForEmail,
+  parseSpaceIds,
+  sameOwnerEmail,
+} from "../../lib/recordings.js";
 import { verifySharePassword } from "../../lib/share-password.js";
 
 function appPath(path: string): string {
@@ -104,6 +108,52 @@ function setProtectedMediaAccessCookie(
   return token;
 }
 
+// Best-effort, per-instance (not distributed) throttle on wrong-password
+// attempts against a password-protected share. Keyed by IP + recordingId so
+// one abusive client/recording pair can't brute-force unlimited guesses
+// against a single server instance. Mirrors the limiter in view-event.post.ts.
+const PASSWORD_ATTEMPT_WINDOW_MS = 60_000;
+const PASSWORD_ATTEMPT_MAX = 10;
+// Cap on the number of tracked IP+recording buckets. This is a process-local,
+// best-effort limiter (not distributed), so we only need to keep it from
+// growing unbounded over the life of an instance — not enforce the cap
+// precisely. When we cross it, sweep once and drop every expired bucket.
+const PASSWORD_ATTEMPT_MAX_BUCKETS = 5000;
+const passwordAttemptBuckets = new Map<
+  string,
+  { count: number; reset: number }
+>();
+
+function pruneExpiredPasswordAttemptBuckets(now: number): void {
+  for (const [key, bucket] of passwordAttemptBuckets) {
+    if (bucket.reset < now) passwordAttemptBuckets.delete(key);
+  }
+}
+
+function passwordAttemptAllowed(key: string): boolean {
+  const now = Date.now();
+  const existing = passwordAttemptBuckets.get(key);
+  if (!existing || existing.reset < now) {
+    if (passwordAttemptBuckets.size >= PASSWORD_ATTEMPT_MAX_BUCKETS) {
+      pruneExpiredPasswordAttemptBuckets(now);
+    }
+    passwordAttemptBuckets.set(key, {
+      count: 1,
+      reset: now + PASSWORD_ATTEMPT_WINDOW_MS,
+    });
+    return true;
+  }
+  if (existing.count >= PASSWORD_ATTEMPT_MAX) return false;
+  existing.count += 1;
+  return true;
+}
+
+function requestIp(event: H3Event): string {
+  const xff = getHeader(event, "x-forwarded-for");
+  if (xff) return String(xff).split(",")[0].trim();
+  return event.node?.req?.socket?.remoteAddress || "unknown";
+}
+
 function appendQueryParam(url: string, key: string, value: string): string {
   const sep = url.includes("?") ? "&" : "?";
   return `${url}${sep}${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
@@ -170,9 +220,25 @@ export default defineEventHandler(async (event) => {
       }).ok
     : false;
 
+  let viewerIsOrgMember = false;
+  if (session?.email && rec.visibility === "org" && rec.organizationId) {
+    try {
+      const role = await getOrganizationRoleForEmail(
+        rec.organizationId,
+        session.email,
+      );
+      viewerIsOrgMember = Boolean(role);
+    } catch {
+      // Never fail the request for anonymous/unauthenticated viewers or if
+      // org lookup is unavailable — just fall through to the existing gate.
+      viewerIsOrgMember = false;
+    }
+  }
+
   if (
     rec.visibility !== "public" &&
     !viewerIsOwner &&
+    !viewerIsOrgMember &&
     !tokenAllowsAgentAccess
   ) {
     setResponseStatus(event, 404);
@@ -191,12 +257,26 @@ export default defineEventHandler(async (event) => {
   // Password check
   let protectedMediaToken: string | null = null;
   if (rec.password && !viewerIsOwner) {
-    if (
-      !tokenAllowsAgentAccess &&
-      (!password || !verifySharePassword(password, rec.password))
-    ) {
-      setResponseStatus(event, 401);
-      return { error: "Password required", passwordRequired: true };
+    if (!tokenAllowsAgentAccess) {
+      if (!password) {
+        // No password supplied at all — this is the initial load or a
+        // background poll sitting on the password prompt, not a guess. Don't
+        // touch the throttle, or a viewer who never submits anything would
+        // eventually get 429'd just for polling.
+        setResponseStatus(event, 401);
+        return { error: "Password required", passwordRequired: true };
+      }
+      if (!verifySharePassword(password, rec.password)) {
+        // Only a supplied-and-wrong password counts against the throttle, so
+        // a viewer who supplies the correct password is never rate-limited.
+        const attemptKey = `${requestIp(event)}:${recordingId}`;
+        if (!passwordAttemptAllowed(attemptKey)) {
+          setResponseStatus(event, 429);
+          return { error: "Too many attempts, try again later" };
+        }
+        setResponseStatus(event, 401);
+        return { error: "Password required", passwordRequired: true };
+      }
     }
     protectedMediaToken = setProtectedMediaAccessCookie(event, recordingId);
   } else if (tokenAllowsAgentAccess && !viewerIsOwner) {

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

@@ -68,6 +68,13 @@ export default defineEventHandler(async (event: H3Event) => {
       return { ok: true, recordingId, alreadyReady: true, chunksCleared: 0 };
     }
 
+    // Already a terminal failure (e.g. a duplicate/retried abort call, or
+    // finalize's own failChunkAssembly already flipped it) — no-op instead of
+    // re-clearing chunk state and overwriting the original failureReason.
+    if (existing.status === "failed") {
+      return { ok: true, recordingId, alreadyFailed: true, chunksCleared: 0 };
+    }
+
     const cleared = await deleteAppStateByPrefix(
       `recording-chunks-${recordingId}-`,
     );

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

@@ -484,6 +484,16 @@ export default defineEventHandler(async (event: H3Event) => {
           recordingId,
           videoUrl: (result as any)?.videoUrl,
         });
+        if ((result as any)?.status === "failed") {
+          setResponseStatus(event, 409);
+          return {
+            ok: false,
+            finalized: false,
+            aborted: true,
+            status: "failed",
+            error: "Recording was cancelled before it finished saving.",
+          };
+        }
         const waitingForStorage =
           (result as any)?.status === "waiting_storage" ||
           (result as any)?.storageSetupRequired === true;
@@ -592,19 +602,20 @@ function buildFinalizeArgs(
   mimeType: string,
   query: Record<string, unknown>,
 ) {
+  const queryBoolean = (value: unknown): boolean | undefined => {
+    if (value === undefined) return undefined;
+    if (Array.isArray(value)) return queryBoolean(value[0]);
+    return value === "1" || value === "true" || value === true;
+  };
+
   return {
     id: recordingId,
     durationMs: normalizeChunkUploadNumber(query.durationMs),
     width: normalizeChunkUploadNumber(query.width),
     height: normalizeChunkUploadNumber(query.height),
-    hasAudio:
-      query.hasAudio === undefined
-        ? undefined
-        : query.hasAudio === "1" || query.hasAudio === "true",
-    hasCamera:
-      query.hasCamera === undefined
-        ? undefined
-        : query.hasCamera === "1" || query.hasCamera === "true",
+    hasAudio: queryBoolean(query.hasAudio),
+    hasCamera: queryBoolean(query.hasCamera),
+    locallyTranscoded: queryBoolean(query.locallyTranscoded),
     mimeType,
   };
 }
@@ -622,6 +633,10 @@ async function handleResumableChunk(
   ownerEmail: string,
 ) {
   const uploadProvider = getActiveFileUploadProvider();
+  if (!uploadProvider?.resumable) {
+    setResponseStatus(event, 502);
+    return { ok: false, error: "Upload storage is not configured" };
+  }
   console.log(
     `[resumable-chunk-${recordingId}] resumable session exists - bytesUploaded=${session.bytesUploaded} index=${index} isFinal=${isFinal}`,
   );
@@ -644,7 +659,7 @@ async function handleResumableChunk(
     // 0-byte sentinel from the recorder after stop(). All data chunks have
     // already been PUT to the provider; send Content-Range: bytes */<total>
     // to close the session before handing off to finalize-recording.
-    const closeRes = await uploadProvider!.resumable!.relayChunk(
+    const closeRes = await uploadProvider.resumable.relayChunk(
       { sessionId: session.sessionId, meta: session.meta },
       `bytes */${session.bytesUploaded}`,
       new Uint8Array(0),
@@ -690,7 +705,7 @@ async function handleResumableChunk(
         : `bytes ${start}-${end}/*`;
 
       const putT0 = Date.now();
-      const putResult = await uploadProvider!.resumable!.relayChunk(
+      const putResult = await uploadProvider.resumable.relayChunk(
         { sessionId: session.sessionId, meta: session.meta },
         contentRange,
         bytes,
@@ -732,6 +747,16 @@ async function handleResumableChunk(
     const result = await finalizeRecording.run(
       buildFinalizeArgs(recordingId, mimeType, query),
     );
+    if ((result as any)?.status === "failed") {
+      setResponseStatus(event, 409);
+      return {
+        ok: false,
+        finalized: false,
+        aborted: true,
+        status: "failed",
+        error: "Recording was cancelled before it finished saving.",
+      };
+    }
     return { ok: true, finalized: true, ...result };
   } catch (err) {
     console.error(`[resumable-chunk-${recordingId}] finalize failed:`, err);