@agent-native/core 0.84.13 → 0.84.16

package/corpus/templates/analytics/server/lib/first-party-analytics.ts

@@ -50,6 +50,10 @@ function nowIso(): string {
   return new Date().toISOString();
 }
 
+function todayIsoDate(): string {
+  return nowIso().slice(0, 10);
+}
+
 function randomHex(bytes: number): string {
   const arr = new Uint8Array(bytes);
   if (!globalThis.crypto?.getRandomValues) {
@@ -204,17 +208,30 @@ function asString(value: unknown): string | null {
   return null;
 }
 
-function normalizeTimestamp(value: unknown): string {
-  if (value instanceof Date) return value.toISOString();
+export function normalizeAnalyticsTimestamp(
+  value: unknown,
+  receivedAt = nowIso(),
+): string {
+  const fallback = (() => {
+    const date = new Date(receivedAt);
+    return Number.isNaN(date.getTime()) ? nowIso() : date.toISOString();
+  })();
+  const fallbackTime = new Date(fallback).getTime();
+  const normalize = (date: Date) => {
+    if (Number.isNaN(date.getTime())) return fallback;
+    return date.getTime() > fallbackTime ? fallback : date.toISOString();
+  };
+
+  if (value instanceof Date) return normalize(value);
   if (typeof value === "number") {
     const d = new Date(value);
-    return Number.isNaN(d.getTime()) ? nowIso() : d.toISOString();
+    return normalize(d);
   }
   if (typeof value === "string" && value.trim()) {
     const d = new Date(value);
-    return Number.isNaN(d.getTime()) ? nowIso() : d.toISOString();
+    return normalize(d);
   }
-  return nowIso();
+  return fallback;
 }
 
 function eventDateFromTimestamp(timestamp: string): string {
@@ -362,7 +379,7 @@ export async function recordAnalyticsEvents(
       asString((properties as any).anonymousId) ??
       asString((properties as any).distinctId);
     const userKey = userId || anonymousId;
-    const timestamp = normalizeTimestamp(event.timestamp);
+    const timestamp = normalizeAnalyticsTimestamp(event.timestamp, receivedAt);
 
     return {
       id: id("evt"),
@@ -516,9 +533,17 @@ function scopeClause(scope: AnalyticsScope): {
   };
 }
 
-function scopedAnalyticsSql(
+function freshnessClause(tableName: string): string {
+  if (tableName === "analytics_events") {
+    return "(COALESCE(NULLIF(event_date, ''), substr(timestamp, 1, 10)) <= ?)";
+  }
+  return "(substr(started_at, 1, 10) <= ?)";
+}
+
+export function scopedAnalyticsSql(
   sql: string,
   scope: AnalyticsScope,
+  today = todayIsoDate(),
 ): { sql: string; args: Array<string | null> } {
   const args: Array<string | null> = [];
   const aliasRe =
@@ -536,8 +561,8 @@ function scopedAnalyticsSql(
           ? aliasPart
           : ` AS ${normalizedTable}`;
       const scopeDef = scopeClause(scope);
-      args.push(...scopeDef.args);
-      return `${keyword} (SELECT * FROM ${normalizedTable} WHERE ${scopeDef.sql})${usableAlias}`;
+      args.push(...scopeDef.args, today);
+      return `${keyword} (SELECT * FROM ${normalizedTable} WHERE ${scopeDef.sql} AND ${freshnessClause(normalizedTable)})${usableAlias}`;
     },
   );
   return { sql: rewritten, args };

package/corpus/templates/analytics/server/lib/first-party-metric-catalog.ts

@@ -128,6 +128,10 @@ function daysAgoSql(days: number): string {
   return `to_char(CURRENT_DATE - INTERVAL '${days} ${unit}', 'YYYY-MM-DD')`;
 }
 
+function todaySql(): string {
+  return "to_char(CURRENT_DATE, 'YYYY-MM-DD')";
+}
+
 function windowStartFilter(days: number): string {
   return `${EVENT_DATE_SQL} >= ${daysAgoSql(days)}`;
 }
@@ -140,14 +144,14 @@ function rollingWindowStartSql(
 }
 
 function dashboardTimeRangeFilter(dateExpr = EVENT_DATE_FILTER_SQL): string {
-  return `('{{timeRange}}' IN ('', 'all') OR ('{{timeRange}}' = '7d' AND ${dateExpr} >= ${daysAgoSql(7)}) OR ('{{timeRange}}' = '30d' AND ${dateExpr} >= ${daysAgoSql(30)}) OR ('{{timeRange}}' = '90d' AND ${dateExpr} >= ${daysAgoSql(90)}) OR ('{{timeRange}}' = '180d' AND ${dateExpr} >= ${daysAgoSql(180)}) OR ('{{timeRange}}' = '365d' AND ${dateExpr} >= ${daysAgoSql(365)}))`;
+  return `(${dateExpr} <= ${todaySql()} AND ('{{timeRange}}' IN ('', 'all') OR ('{{timeRange}}' = '7d' AND ${dateExpr} >= ${daysAgoSql(7)}) OR ('{{timeRange}}' = '30d' AND ${dateExpr} >= ${daysAgoSql(30)}) OR ('{{timeRange}}' = '90d' AND ${dateExpr} >= ${daysAgoSql(90)}) OR ('{{timeRange}}' = '180d' AND ${dateExpr} >= ${daysAgoSql(180)}) OR ('{{timeRange}}' = '365d' AND ${dateExpr} >= ${daysAgoSql(365)})))`;
 }
 
 function dashboardLookbackTimeRangeFilter(
   dateExpr = EVENT_DATE_FILTER_SQL,
   lookbackDays = 0,
 ): string {
-  return `('{{timeRange}}' IN ('', 'all') OR ('{{timeRange}}' = '7d' AND ${dateExpr} >= ${daysAgoSql(7 + lookbackDays)}) OR ('{{timeRange}}' = '30d' AND ${dateExpr} >= ${daysAgoSql(30 + lookbackDays)}) OR ('{{timeRange}}' = '90d' AND ${dateExpr} >= ${daysAgoSql(90 + lookbackDays)}) OR ('{{timeRange}}' = '180d' AND ${dateExpr} >= ${daysAgoSql(180 + lookbackDays)}) OR ('{{timeRange}}' = '365d' AND ${dateExpr} >= ${daysAgoSql(365 + lookbackDays)}))`;
+  return `(${dateExpr} <= ${todaySql()} AND ('{{timeRange}}' IN ('', 'all') OR ('{{timeRange}}' = '7d' AND ${dateExpr} >= ${daysAgoSql(7 + lookbackDays)}) OR ('{{timeRange}}' = '30d' AND ${dateExpr} >= ${daysAgoSql(30 + lookbackDays)}) OR ('{{timeRange}}' = '90d' AND ${dateExpr} >= ${daysAgoSql(90 + lookbackDays)}) OR ('{{timeRange}}' = '180d' AND ${dateExpr} >= ${daysAgoSql(180 + lookbackDays)}) OR ('{{timeRange}}' = '365d' AND ${dateExpr} >= ${daysAgoSql(365 + lookbackDays)})))`;
 }
 
 const DASHBOARD_TIME_RANGE_FILTER = dashboardTimeRangeFilter();

package/corpus/templates/analytics/server/lib/session-replay.ts

@@ -275,6 +275,53 @@ function replayMaxIso(values: Array<string | null | undefined>): string | null {
   return present.reduce((max, value) => (value > max ? value : max));
 }
 
+function replayClampIso(
+  value: string | null | undefined,
+  latestIso: string,
+): string | null {
+  if (!value) return null;
+  const parsed = Date.parse(value);
+  const latest = Date.parse(latestIso);
+  if (!Number.isFinite(parsed)) return null;
+  if (!Number.isFinite(latest)) return value;
+  return parsed > latest ? latestIso : value;
+}
+
+function clampReplayChunkTiming(
+  chunk: NormalizedSessionReplayChunk,
+  latestIso: string,
+): NormalizedSessionReplayChunk {
+  const startedAt = replayClampIso(chunk.startedAt, latestIso);
+  let endedAt = replayClampIso(chunk.endedAt, latestIso);
+  if (startedAt && endedAt && endedAt < startedAt) {
+    endedAt = startedAt;
+  }
+  return { ...chunk, startedAt, endedAt };
+}
+
+function clampReplayIngestTiming(
+  input: ParsedSessionReplayIngest,
+  latestIso: string,
+): ParsedSessionReplayIngest {
+  const chunks = input.chunks.map((chunk) =>
+    clampReplayChunkTiming(chunk, latestIso),
+  );
+  const startedAt =
+    replayMinIso([
+      replayClampIso(input.startedAt, latestIso),
+      ...chunks.map((chunk) => chunk.startedAt),
+    ]) ?? latestIso;
+  let endedAt = replayMaxIso([
+    replayClampIso(input.endedAt, latestIso),
+    ...chunks.map((chunk) => chunk.endedAt),
+  ]);
+  if (endedAt && endedAt < startedAt) endedAt = startedAt;
+  const durationMs = endedAt
+    ? Math.max(0, Date.parse(endedAt) - Date.parse(startedAt))
+    : input.durationMs;
+  return { ...input, startedAt, endedAt, durationMs, chunks };
+}
+
 function normalizeReplayUrl(url: string | null): {
   url: string | null;
   path: string | null;
@@ -1101,7 +1148,8 @@ export async function recordSessionReplayChunks(
 }> {
   const key = await resolveReplayPublicKey(input.publicKey, context);
   const db = getDb() as any;
-  const ingestedAt = replayNowIso();
+  const ingestedAt = replayTimestamp(context.now) ?? replayNowIso();
+  const clampedInput = clampReplayIngestTiming(input, ingestedAt);
 
   let [recording] = await db
     .select()
@@ -1109,7 +1157,10 @@ export async function recordSessionReplayChunks(
     .where(
       and(
         eq(schema.sessionRecordings.publicKeyId, key.id),
-        eq(schema.sessionRecordings.clientRecordingId, input.clientRecordingId),
+        eq(
+          schema.sessionRecordings.clientRecordingId,
+          clampedInput.clientRecordingId,
+        ),
       ),
     )
     .limit(1);
@@ -1121,27 +1172,27 @@ export async function recordSessionReplayChunks(
       .values({
         id: newRecordingId,
         publicKeyId: key.id,
-        clientRecordingId: input.clientRecordingId,
-        sessionId: input.sessionId,
-        userId: input.userId,
-        anonymousId: input.anonymousId,
-        userKey: input.userKey,
-        startedAt: input.startedAt,
-        endedAt: input.endedAt,
-        durationMs: input.durationMs,
-        pageCount: input.pageCount,
-        errorCount: input.errorCount,
-        rageClickCount: input.rageClickCount,
-        privacyMode: input.privacyMode,
-        firstUrl: input.url,
-        lastUrl: input.url,
-        path: input.path,
-        hostname: input.hostname,
-        referrer: input.referrer,
-        app: input.app,
-        template: input.template,
-        status: input.status,
-        metadata: JSON.stringify(input.metadata),
+        clientRecordingId: clampedInput.clientRecordingId,
+        sessionId: clampedInput.sessionId,
+        userId: clampedInput.userId,
+        anonymousId: clampedInput.anonymousId,
+        userKey: clampedInput.userKey,
+        startedAt: clampedInput.startedAt,
+        endedAt: clampedInput.endedAt,
+        durationMs: clampedInput.durationMs,
+        pageCount: clampedInput.pageCount,
+        errorCount: clampedInput.errorCount,
+        rageClickCount: clampedInput.rageClickCount,
+        privacyMode: clampedInput.privacyMode,
+        firstUrl: clampedInput.url,
+        lastUrl: clampedInput.url,
+        path: clampedInput.path,
+        hostname: clampedInput.hostname,
+        referrer: clampedInput.referrer,
+        app: clampedInput.app,
+        template: clampedInput.template,
+        status: clampedInput.status,
+        metadata: JSON.stringify(clampedInput.metadata),
         lastIngestedAt: ingestedAt,
         ownerEmail: key.ownerEmail,
         orgId: key.orgId,
@@ -1162,7 +1213,7 @@ export async function recordSessionReplayChunks(
           eq(schema.sessionRecordings.publicKeyId, key.id),
           eq(
             schema.sessionRecordings.clientRecordingId,
-            input.clientRecordingId,
+            clampedInput.clientRecordingId,
           ),
         ),
       )
@@ -1193,7 +1244,7 @@ export async function recordSessionReplayChunks(
     existingChunks.length === 0;
 
   try {
-    for (const rawChunk of input.chunks) {
+    for (const rawChunk of clampedInput.chunks) {
       const existing = existingBySeq.get(rawChunk.seq);
       if (existing) {
         if (existing.checksum !== rawChunk.checksum) {
@@ -1272,13 +1323,15 @@ export async function recordSessionReplayChunks(
     id: replayId("sri"),
     publicKeyId: key.id,
     recordingId: recording.id,
-    byteLength: replayIngestByteLength(input, context),
+    byteLength: replayIngestByteLength(clampedInput, context),
     createdAt: ingestedAt,
     ownerEmail: key.ownerEmail,
     orgId: key.orgId,
   });
 
-  const allChunks = [...existingChunks, ...rowsToInsert];
+  const allChunks = [...existingChunks, ...rowsToInsert].map((chunk: any) =>
+    clampReplayChunkTiming(chunk, ingestedAt),
+  );
   const chunkCount = allChunks.length;
   const eventCount = allChunks.reduce(
     (sum, chunk: any) => sum + Number(chunk.eventCount ?? 0),
@@ -1291,57 +1344,63 @@ export async function recordSessionReplayChunks(
   const startedAt =
     replayMinIso([
       recording.startedAt,
-      input.startedAt,
+      clampedInput.startedAt,
       ...allChunks.map((chunk: any) => chunk.startedAt),
-    ]) ?? input.startedAt;
+    ]) ?? clampedInput.startedAt;
   const endedAt =
     replayMaxIso([
       recording.endedAt,
-      input.endedAt,
+      clampedInput.endedAt,
       ...allChunks.map((chunk: any) => chunk.endedAt),
     ]) ?? null;
   const durationMs =
-    input.durationMs ??
+    clampedInput.durationMs ??
     (endedAt
       ? Math.max(0, Date.parse(endedAt) - Date.parse(startedAt))
       : (recording.durationMs ?? null));
   const metadata = mergeReplayMetadata(
     parseRecordingMetadata(recording),
-    input.metadata,
+    clampedInput.metadata,
   );
 
   await db
     .update(schema.sessionRecordings)
     .set({
-      sessionId: input.sessionId,
-      userId: input.userId ?? recording.userId ?? null,
-      anonymousId: input.anonymousId ?? recording.anonymousId ?? null,
-      userKey: input.userKey ?? recording.userKey ?? null,
+      sessionId: clampedInput.sessionId,
+      userId: clampedInput.userId ?? recording.userId ?? null,
+      anonymousId: clampedInput.anonymousId ?? recording.anonymousId ?? null,
+      userKey: clampedInput.userKey ?? recording.userKey ?? null,
       startedAt,
       endedAt,
       durationMs,
       chunkCount,
       eventCount,
       totalBytes,
-      pageCount: Math.max(Number(recording.pageCount ?? 0), input.pageCount),
-      errorCount: Math.max(Number(recording.errorCount ?? 0), input.errorCount),
+      pageCount: Math.max(
+        Number(recording.pageCount ?? 0),
+        clampedInput.pageCount,
+      ),
+      errorCount: Math.max(
+        Number(recording.errorCount ?? 0),
+        clampedInput.errorCount,
+      ),
       rageClickCount: Math.max(
         Number(recording.rageClickCount ?? 0),
-        input.rageClickCount,
+        clampedInput.rageClickCount,
       ),
       privacyMode:
-        input.privacyMode !== "unknown"
-          ? input.privacyMode
+        clampedInput.privacyMode !== "unknown"
+          ? clampedInput.privacyMode
           : (recording.privacyMode ?? "unknown"),
-      firstUrl: recording.firstUrl ?? input.url,
-      lastUrl: input.url ?? recording.lastUrl ?? null,
-      path: input.path ?? recording.path ?? null,
-      hostname: input.hostname ?? recording.hostname ?? null,
-      referrer: input.referrer ?? recording.referrer ?? null,
-      app: input.app ?? recording.app ?? null,
-      template: input.template ?? recording.template ?? null,
+      firstUrl: recording.firstUrl ?? clampedInput.url,
+      lastUrl: clampedInput.url ?? recording.lastUrl ?? null,
+      path: clampedInput.path ?? recording.path ?? null,
+      hostname: clampedInput.hostname ?? recording.hostname ?? null,
+      referrer: clampedInput.referrer ?? recording.referrer ?? null,
+      app: clampedInput.app ?? recording.app ?? null,
+      template: clampedInput.template ?? recording.template ?? null,
       status:
-        input.status === "completed" || recording.status === "completed"
+        clampedInput.status === "completed" || recording.status === "completed"
           ? "completed"
           : "active",
       metadata: JSON.stringify(metadata),
@@ -1364,7 +1423,7 @@ export async function recordSessionReplayChunks(
 
   return {
     recordingId: recording.id,
-    sessionId: input.sessionId,
+    sessionId: clampedInput.sessionId,
     acceptedChunks: rowsToInsert.length,
     duplicateChunks,
     chunkCount,

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

@@ -492,6 +492,27 @@ export default runMigrations(
       version: 71,
       sql: `CREATE INDEX IF NOT EXISTS session_replay_ingests_recording_idx ON session_replay_ingests (recording_id)`,
     },
+    {
+      version: 72,
+      sql: {
+        postgres: `UPDATE analytics_events SET timestamp = COALESCE(NULLIF(received_at, ''), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')), event_date = substr(COALESCE(NULLIF(received_at, ''), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')), 1, 10) WHERE COALESCE(NULLIF(event_date, ''), substr(timestamp, 1, 10)) > to_char(CURRENT_DATE, 'YYYY-MM-DD')`,
+        sqlite: `UPDATE analytics_events SET timestamp = COALESCE(NULLIF(received_at, ''), datetime('now')), event_date = substr(COALESCE(NULLIF(received_at, ''), date('now')), 1, 10) WHERE COALESCE(NULLIF(event_date, ''), substr(timestamp, 1, 10)) > date('now')`,
+      },
+    },
+    {
+      version: 73,
+      sql: {
+        postgres: `UPDATE session_recordings SET started_at = CASE WHEN substr(started_at, 1, 10) > to_char(CURRENT_DATE, 'YYYY-MM-DD') THEN LEAST(COALESCE(NULLIF(last_ingested_at, ''), NULLIF(updated_at, ''), NULLIF(created_at, ''), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')) ELSE started_at END, ended_at = CASE WHEN ended_at IS NOT NULL AND substr(ended_at, 1, 10) > to_char(CURRENT_DATE, 'YYYY-MM-DD') THEN LEAST(COALESCE(NULLIF(last_ingested_at, ''), NULLIF(updated_at, ''), NULLIF(created_at, ''), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')) ELSE ended_at END WHERE (owner_email IS NOT NULL OR org_id IS NOT NULL) AND (substr(started_at, 1, 10) > to_char(CURRENT_DATE, 'YYYY-MM-DD') OR (ended_at IS NOT NULL AND substr(ended_at, 1, 10) > to_char(CURRENT_DATE, 'YYYY-MM-DD')))`,
+        sqlite: `UPDATE session_recordings SET started_at = CASE WHEN substr(started_at, 1, 10) > date('now') THEN min(COALESCE(NULLIF(last_ingested_at, ''), NULLIF(updated_at, ''), NULLIF(created_at, ''), datetime('now')), datetime('now')) ELSE started_at END, ended_at = CASE WHEN ended_at IS NOT NULL AND substr(ended_at, 1, 10) > date('now') THEN min(COALESCE(NULLIF(last_ingested_at, ''), NULLIF(updated_at, ''), NULLIF(created_at, ''), datetime('now')), datetime('now')) ELSE ended_at END WHERE (owner_email IS NOT NULL OR org_id IS NOT NULL) AND (substr(started_at, 1, 10) > date('now') OR (ended_at IS NOT NULL AND substr(ended_at, 1, 10) > date('now')))`,
+      },
+    },
+    {
+      version: 74,
+      sql: {
+        postgres: `UPDATE session_replay_chunks SET started_at = CASE WHEN started_at IS NOT NULL AND substr(started_at, 1, 10) > to_char(CURRENT_DATE, 'YYYY-MM-DD') THEN LEAST(COALESCE(NULLIF(created_at, ''), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')) ELSE started_at END, ended_at = CASE WHEN ended_at IS NOT NULL AND substr(ended_at, 1, 10) > to_char(CURRENT_DATE, 'YYYY-MM-DD') THEN LEAST(COALESCE(NULLIF(created_at, ''), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')), to_char(CURRENT_TIMESTAMP AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')) ELSE ended_at END WHERE (started_at IS NOT NULL AND substr(started_at, 1, 10) > to_char(CURRENT_DATE, 'YYYY-MM-DD')) OR (ended_at IS NOT NULL AND substr(ended_at, 1, 10) > to_char(CURRENT_DATE, 'YYYY-MM-DD'))`,
+        sqlite: `UPDATE session_replay_chunks SET started_at = CASE WHEN started_at IS NOT NULL AND substr(started_at, 1, 10) > date('now') THEN min(COALESCE(NULLIF(created_at, ''), datetime('now')), datetime('now')) ELSE started_at END, ended_at = CASE WHEN ended_at IS NOT NULL AND substr(ended_at, 1, 10) > date('now') THEN min(COALESCE(NULLIF(created_at, ''), datetime('now')), datetime('now')) ELSE ended_at END WHERE (started_at IS NOT NULL AND substr(started_at, 1, 10) > date('now')) OR (ended_at IS NOT NULL AND substr(ended_at, 1, 10) > date('now'))`,
+      },
+    },
   ],
   { table: "analytics_migrations" },
 );

package/corpus/templates/clips/changelog/2026-07-01-chrome-extension-recordings-stream-uploads-while-recording.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Chrome extension recordings now stream uploads while recording so saving is less likely to time out.

package/corpus/templates/clips/chrome-extension/public/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "Agent-Native Clips",
   "short_name": "Clips",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Start Clips recordings from Chrome, capture optional diagnostics, and preview Clips links on GitHub.",
   "minimum_chrome_version": "116",
   "action": {

package/corpus/templates/clips/chrome-extension/src/background.ts

@@ -32,6 +32,7 @@ const UNQUOTED_SECRET_VALUE_RE = new RegExp(
 type CaptureSurface = "browser" | "window" | "monitor" | "camera";
 type ConsoleLevel = "debug" | "log" | "info" | "warn" | "error";
 type NetworkType = "fetch" | "xhr";
+type UploadMode = "streaming" | "buffered";
 
 type ExtensionSettings = {
   clipsBaseUrl: string;
@@ -134,6 +135,7 @@ type NativeRecording = {
   recordingId: string;
   clipsBaseUrl: string;
   uploadUrl: string;
+  uploadMode: UploadMode;
   targetTabId: number;
   targetTitle: string | null;
   targetUrl: string | null;
@@ -1049,6 +1051,7 @@ async function armRecording(args: {
     id?: string;
     uploadChunkUrl?: string;
     abortUrl?: string;
+    uploadMode?: UploadMode;
   };
   let created: CreatedRecording;
   try {
@@ -1061,6 +1064,8 @@ async function armRecording(args: {
       hasAudio:
         settings.includeMicrophone || settings.captureSurface !== "camera",
       visibility: "public",
+      mimeType: "video/webm",
+      requestStreaming: true,
     });
   } catch (err) {
     captureExtensionError(err, {
@@ -1091,6 +1096,7 @@ async function armRecording(args: {
     recordingId: created.id,
     clipsBaseUrl: settings.clipsBaseUrl,
     uploadUrl,
+    uploadMode: created.uploadMode ?? "buffered",
     targetTabId: tab.id as number,
     targetTitle: tab.title?.trim() || null,
     targetUrl: tab.url?.trim() || null,
@@ -1122,6 +1128,7 @@ async function armRecording(args: {
       sessionId,
       recordingId: created.id,
       uploadUrl,
+      uploadMode: created.uploadMode ?? "buffered",
       hasCamera: cameraInvolved,
       startDelayMs,
       authToken,
@@ -1274,6 +1281,7 @@ async function handleOverlayRestart() {
       sessionId: recording.sessionId,
       recordingId: recording.recordingId,
       uploadUrl: recording.uploadUrl,
+      uploadMode: recording.uploadMode ?? "buffered",
       hasCamera:
         recording.captureSurface === "camera" || recording.includeCamera,
       startDelayMs: COUNTDOWN_SECONDS * 1000,

package/corpus/templates/clips/chrome-extension/src/offscreen.ts

@@ -17,7 +17,11 @@
 // app recorder via @shared/recording-core so the server contract can't drift.
 
 import { scheduleReadyChime } from "@shared/recording-audio";
-import { chunkUploadUrl, pickMimeType } from "@shared/recording-core";
+import {
+  chunkUploadUrl,
+  pickMimeType,
+  type UploadMode,
+} from "@shared/recording-core";
 import { MAX_UPLOAD_BYTES } from "@shared/upload-limits";
 
 import { waitForReadyRecordingAfterFinalizeError } from "./finalize-recovery";
@@ -63,6 +67,7 @@ type BeginMessage = {
   sessionId: string;
   recordingId: string;
   uploadUrl: string;
+  uploadMode?: UploadMode;
   hasCamera?: boolean;
   // Pre-roll countdown delay, owned here in the offscreen document (a reliable
   // context) rather than the service worker (which can suspend and drop timers).
@@ -114,6 +119,7 @@ type ActiveRecording = {
   sessionId: string;
   recordingId: string;
   uploadUrl: string;
+  uploadMode: UploadMode;
   authToken: string | null;
   mode: CaptureMode;
   startedAtMs: number;
@@ -134,6 +140,8 @@ type ActiveRecording = {
   // Set if the recording grew past the buffer ceiling and we stopped retaining
   // — at that point a local save can't be guaranteed, so we don't promise one.
   localBufferOverflow: boolean;
+  pendingStreamBlobs: Blob[];
+  pendingStreamBytes: number;
   cancelled: boolean;
   // Set when the recorder is being torn down to start over on the same source
   // streams, so the stop handler skips the usual track cleanup.
@@ -155,6 +163,8 @@ type ActiveRecording = {
   rejectStopped: (error: Error) => void;
 };
 
+const GCS_CHUNK_ALIGN_BYTES = 256 * 1024;
+const STREAM_CHUNK_BYTES = 15 * GCS_CHUNK_ALIGN_BYTES; // 3.75 MiB
 const UPLOAD_SLICE_BYTES = 3 * 1024 * 1024;
 
 // Don't retain more than the upload ceiling — past it the server rejects the
@@ -578,6 +588,32 @@ async function uploadBlobInSlices(
   }
 }
 
+async function uploadStreamingBlob(
+  recording: ActiveRecording,
+  blob: Blob,
+): Promise<void> {
+  if (blob.size === 0) return;
+  recording.pendingStreamBlobs.push(blob);
+  recording.pendingStreamBytes += blob.size;
+
+  while (recording.pendingStreamBytes >= STREAM_CHUNK_BYTES) {
+    if (recording.cancelled || recording.uploadFailure) return;
+    const combined = new Blob(recording.pendingStreamBlobs, {
+      type: recording.mimeType,
+    });
+    const head = combined.slice(0, STREAM_CHUNK_BYTES, recording.mimeType);
+    const tail = combined.slice(
+      STREAM_CHUNK_BYTES,
+      undefined,
+      recording.mimeType,
+    );
+    recording.pendingStreamBlobs = tail.size > 0 ? [tail] : [];
+    recording.pendingStreamBytes = tail.size;
+    const index = recording.chunkIndex++;
+    await uploadChunk(recording, head, index);
+  }
+}
+
 function stopStreams(streams: (MediaStream | null)[]): void {
   for (const stream of streams) {
     if (!stream) continue;
@@ -744,6 +780,7 @@ async function begin(message: BeginMessage): Promise<{
     sessionId: ready.sessionId,
     recordingId: message.recordingId,
     uploadUrl: message.uploadUrl,
+    uploadMode: message.uploadMode ?? "buffered",
     authToken: message.authToken ?? null,
     mode: ready.mode,
     startedAtMs: 0,
@@ -763,6 +800,8 @@ async function begin(message: BeginMessage): Promise<{
     recordedBlobs: [],
     recordedBytes: 0,
     localBufferOverflow: false,
+    pendingStreamBlobs: [],
+    pendingStreamBytes: 0,
     cancelled: false,
     restarting: false,
     startTimer: null,
@@ -798,7 +837,11 @@ async function begin(message: BeginMessage): Promise<{
     // rejected promise that surfaces as an "Uncaught (in promise)" error (bad
     // look in a Chrome Web Store review). finalizeStop reads recording.upload-
     // Failure and surfaces it through the normal error path instead.
-    const upload = uploadBlobInSlices(recording, event.data).catch((err) => {
+    const upload = (
+      recording.uploadMode === "streaming"
+        ? uploadStreamingBlob(recording, event.data)
+        : uploadBlobInSlices(recording, event.data)
+    ).catch((err) => {
       recording.uploadFailure =
         err instanceof Error ? err : new Error(String(err));
       captureExtensionError(recording.uploadFailure, {
@@ -1001,20 +1044,22 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
     }
     let result: UploadResult;
     try {
-      result = await uploadChunk(
-        recording,
-        new Blob([], { type: recording.mimeType }),
-        recording.chunkIndex,
-        {
-          isFinal: true,
-          total: recording.chunkIndex,
-          durationMs,
-          width: recording.dimensions.width,
-          height: recording.dimensions.height,
-          hasAudio: recording.hasAudio,
-          hasCamera: recording.hasCamera,
-        },
-      );
+      const finalBlob =
+        recording.uploadMode === "streaming"
+          ? new Blob(recording.pendingStreamBlobs, { type: recording.mimeType })
+          : new Blob([], { type: recording.mimeType });
+      recording.pendingStreamBlobs = [];
+      recording.pendingStreamBytes = 0;
+      const finalIndex = recording.chunkIndex;
+      result = await uploadChunk(recording, finalBlob, finalIndex, {
+        isFinal: true,
+        total: finalIndex + (finalBlob.size > 0 ? 1 : 0),
+        durationMs,
+        width: recording.dimensions.width,
+        height: recording.dimensions.height,
+        hasAudio: recording.hasAudio,
+        hasCamera: recording.hasCamera,
+      });
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
       (error as { finalUpload?: boolean }).finalUpload = true;