@agent-native/core 0.134.1 → 0.135.1

package/corpus/templates/clips/desktop/src-tauri/src/tray.rs

@@ -11,14 +11,59 @@ use crate::tray_meetings::{build_meetings_section, handle_meeting_menu_click, Me
 use crate::util::{is_meeting_active, is_recording_active};
 use crate::TRAY_PNG;
 
-pub fn refresh_tray_anchor(app: &tauri::AppHandle) -> bool {
-    let Some(rect) = app
-        .tray_by_id("main")
-        .and_then(|tray| tray.rect().ok().flatten())
-    else {
+fn physical_tray_rect(rect: tauri::Rect) -> (i32, i32, i32, i32) {
+    let (x, y) = match rect.position {
+        tauri::Position::Physical(position) => (position.x, position.y),
+        tauri::Position::Logical(position) => (position.x as i32, position.y as i32),
+    };
+    let (width, height) = match rect.size {
+        tauri::Size::Physical(size) => (size.width as i32, size.height as i32),
+        tauri::Size::Logical(size) => (size.width as i32, size.height as i32),
+    };
+    (x, y, width, height)
+}
+
+/// A status item that has not been laid out yet reports a frame at the screen
+/// origin, which macOS coordinate flipping turns into a bottom-left rect. Only
+/// a rect sitting in a monitor's menu-bar row can anchor the popover.
+fn tray_rect_is_laid_out(app: &tauri::AppHandle, rect: tauri::Rect) -> bool {
+    let (x, y, width, height) = physical_tray_rect(rect);
+    if width <= 0 || height <= 0 {
+        return false;
+    }
+
+    let center_x = x + width / 2;
+    let center_y = y + height / 2;
+    let Some(window) = app.get_webview_window("popover") else {
+        return false;
+    };
+    let Ok(monitors) = window.available_monitors() else {
         return false;
     };
 
+    monitors.into_iter().any(|monitor| {
+        let position = monitor.position();
+        let size = monitor.size();
+        if center_x < position.x || center_x >= position.x + size.width as i32 {
+            return false;
+        }
+        #[cfg(target_os = "macos")]
+        {
+            let menu_bar_band = (64.0 * monitor.scale_factor()).round() as i32;
+            center_y >= position.y && center_y < position.y + menu_bar_band
+        }
+        #[cfg(not(target_os = "macos"))]
+        {
+            center_y >= position.y && center_y < position.y + size.height as i32
+        }
+    })
+}
+
+fn store_tray_anchor(app: &tauri::AppHandle, rect: tauri::Rect) -> bool {
+    if !tray_rect_is_laid_out(app, rect) {
+        dlog!("[clips-tray] ignoring tray rect that is not laid out yet");
+        return false;
+    }
     let Some(anchor) = app.try_state::<TrayAnchor>() else {
         return false;
     };
@@ -29,6 +74,16 @@ pub fn refresh_tray_anchor(app: &tauri::AppHandle) -> bool {
     true
 }
 
+pub fn refresh_tray_anchor(app: &tauri::AppHandle) -> bool {
+    let Some(rect) = app
+        .tray_by_id("main")
+        .and_then(|tray| tray.rect().ok().flatten())
+    else {
+        return false;
+    };
+    store_tray_anchor(app, rect)
+}
+
 /// Build the full tray menu with the given upcoming-meetings list. Used both
 /// at startup (with `Vec::new()`) and at refresh time when the meetings
 /// watcher pushes a new snapshot — `TrayIcon::set_menu(Some(...))` swaps the
@@ -222,12 +277,7 @@ pub fn build_tray(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
                 _ => None,
             };
             if let Some(rect) = rect {
-                let app = tray.app_handle();
-                if let Some(anchor) = app.try_state::<TrayAnchor>() {
-                    if let Ok(mut g) = anchor.0.lock() {
-                        *g = Some(rect);
-                    }
-                }
+                store_tray_anchor(tray.app_handle(), rect);
             }
 
             if let TrayIconEvent::Click {

package/corpus/templates/clips/desktop/vitest.config.ts

@@ -0,0 +1,9 @@
+import baseConfig from "@agent-native/core/vitest-config";
+import { mergeConfig } from "vitest/config";
+
+import viteConfig from "./vite.config";
+
+// Kept separate from vite.config.ts so the production config never imports
+// vitest: `agent-native build` loads vite.config.ts in installs where vitest
+// is absent.
+export default mergeConfig(viteConfig, baseConfig);

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

@@ -146,6 +146,16 @@ export const recordings = table("recordings", {
   thumbnailUrl: text("thumbnail_url"),
   animatedThumbnailUrl: text("animated_thumbnail_url"),
 
+  // Editor timeline filmstrip: one sprite image plus the grid geometry needed
+  // to address a cell. Null means "not generated yet", which is why the editor
+  // still has a browser-side extraction fallback.
+  filmstripUrl: text("filmstrip_url"),
+  filmstripFrameCount: integer("filmstrip_frame_count").notNull().default(0),
+  filmstripColumns: integer("filmstrip_columns").notNull().default(0),
+  filmstripRows: integer("filmstrip_rows").notNull().default(0),
+  filmstripFrameWidth: integer("filmstrip_frame_width").notNull().default(0),
+  filmstripFrameHeight: integer("filmstrip_frame_height").notNull().default(0),
+
   durationMs: integer("duration_ms").notNull().default(0),
   videoUrl: text("video_url"),
   videoFormat: text("video_format", { enum: ["webm", "mp4"] })
@@ -168,6 +178,13 @@ export const recordings = table("recordings", {
   // Authoritative liveness for an in-flight upload: renewed by every chunk
   // POST, and the only thing the upload reaper is allowed to consult.
   uploadLeaseExpiresAt: text("upload_lease_expires_at"),
+  // Fences resumed writers: every recovery claim rotates this token so stale
+  // chunks and delayed interruption callbacks cannot mutate the new attempt.
+  uploadAttemptId: text("upload_attempt_id"),
+  // Every destructive restart receives a new generation. Unlike the attempt
+  // id (which is deliberately stable across a lost response), this fences the
+  // provider handle and buffered scratch that the restart replaces.
+  uploadGenerationId: text("upload_generation_id"),
   failureReason: text("failure_reason"),
   loomImportClaimId: text("loom_import_claim_id"),
   loomImportClaimedAt: text("loom_import_claimed_at"),

package/corpus/templates/clips/server/jobs/media-verification.ts

@@ -67,6 +67,7 @@ export async function runMediaVerificationSweepOnce(): Promise<void> {
         .select({
           ownerEmail: schema.recordings.ownerEmail,
           orgId: schema.recordings.orgId,
+          uploadGenerationId: schema.recordings.uploadGenerationId,
         })
         .from(schema.recordings)
         .where(
@@ -92,6 +93,9 @@ export async function runMediaVerificationSweepOnce(): Promise<void> {
               MAX_ATTEMPTS,
               marker.completedAttempts + 1,
             ),
+            ...(recording.uploadGenerationId
+              ? { uploadGenerationId: recording.uploadGenerationId }
+              : {}),
           });
         },
       );

package/corpus/templates/clips/server/lib/activity-notifications.ts

@@ -0,0 +1,185 @@
+/**
+ * Email notifications for Activity events (comments, replies, reactions).
+ *
+ * Recipient resolution and delivery reporting live in
+ * `@agent-native/core/server`; this module only knows which Clips rows are
+ * involved and which template to render. Share invites are deliberately NOT
+ * routed through the `emailNotifications` preference — they have their own
+ * delivery path.
+ */
+
+import {
+  notifyActivity,
+  runActivityNotification,
+  type ActivityNotificationResult,
+} from "@agent-native/core/server";
+import { filterRecipientsByResourceAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+
+import { CLIPS_USER_PREFS_KEY } from "../../shared/clips-ai-prefs.js";
+import { getDb, schema } from "../db/index.js";
+import { sendClipsTransactionalEmail } from "./transactional-email-templates.js";
+
+/**
+ * `recording-missing` is kept distinct from `no-recipients`: one means the row
+ * we were asked to notify about could not be read, the other means nobody
+ * wanted the email.
+ */
+export type ClipsActivityNotificationResult =
+  | ActivityNotificationResult
+  | { status: "recording-missing"; sent: []; failed: [] };
+
+const RECORDING_MISSING: ClipsActivityNotificationResult = {
+  status: "recording-missing",
+  sent: [],
+  failed: [],
+};
+
+const LOG_LABEL = "[clips] activity notification";
+
+async function getRecording(recordingId: string) {
+  const [row] = await getDb()
+    .select({
+      id: schema.recordings.id,
+      title: schema.recordings.title,
+      ownerEmail: schema.recordings.ownerEmail,
+      orgId: schema.recordings.orgId,
+    })
+    .from(schema.recordings)
+    .where(eq(schema.recordings.id, recordingId))
+    .limit(1);
+  return row ?? null;
+}
+
+async function threadParticipants(
+  recordingId: string,
+  threadId: string,
+): Promise<string[]> {
+  const rows = await getDb()
+    .select({ authorEmail: schema.recordingComments.authorEmail })
+    .from(schema.recordingComments)
+    .where(
+      and(
+        eq(schema.recordingComments.recordingId, recordingId),
+        eq(schema.recordingComments.threadId, threadId),
+      ),
+    );
+  return rows.map((row) => row.authorEmail);
+}
+
+export interface RecordingCommentNotificationInput {
+  recordingId: string;
+  threadId: string;
+  authorEmail: string;
+  authorName?: string | null;
+  content: string;
+  videoTimestampMs?: number | null;
+  isReply?: boolean;
+}
+
+export async function notifyRecordingComment(
+  input: RecordingCommentNotificationInput,
+): Promise<ClipsActivityNotificationResult> {
+  return runActivityNotification(LOG_LABEL, () =>
+    deliverRecordingCommentEmails(input),
+  );
+}
+
+async function deliverRecordingCommentEmails(
+  input: RecordingCommentNotificationInput,
+): Promise<ClipsActivityNotificationResult> {
+  const recording = await getRecording(input.recordingId);
+  if (!recording) {
+    console.error(`${LOG_LABEL}: recording ${input.recordingId} not found`);
+    return RECORDING_MISSING;
+  }
+
+  const candidates = [recording.ownerEmail];
+  if (input.isReply) {
+    candidates.push(
+      ...(await threadParticipants(input.recordingId, input.threadId)),
+    );
+  }
+
+  // Thread rows are history, not an access grant: a viewer whose share was
+  // revoked must stop receiving the recording's comment bodies.
+  const allowed = await filterRecipientsByResourceAccess({
+    resourceType: "recording",
+    resourceId: recording.id,
+    emails: candidates,
+    orgId: recording.orgId,
+  });
+
+  return notifyActivity({
+    candidates: allowed,
+    actorEmail: input.authorEmail,
+    preferenceKey: CLIPS_USER_PREFS_KEY,
+    logLabel: LOG_LABEL,
+    send: (to) =>
+      sendClipsTransactionalEmail({
+        kind: "activity-comment",
+        to,
+        recordingId: recording.id,
+        title: recording.title,
+        authorEmail: input.authorEmail,
+        authorName: input.authorName ?? null,
+        content: input.content,
+        videoTimestampMs: input.videoTimestampMs ?? null,
+        isReply: input.isReply ?? false,
+      }),
+  });
+}
+
+export interface RecordingReactionNotificationInput {
+  recordingId: string;
+  emoji: string;
+  viewerEmail: string;
+  viewerName?: string | null;
+  videoTimestampMs?: number | null;
+  extraRecipients?: (string | null | undefined)[];
+}
+
+export async function notifyRecordingReaction(
+  input: RecordingReactionNotificationInput,
+): Promise<ClipsActivityNotificationResult> {
+  return runActivityNotification(LOG_LABEL, () =>
+    deliverRecordingReactionEmails(input),
+  );
+}
+
+async function deliverRecordingReactionEmails(
+  input: RecordingReactionNotificationInput,
+): Promise<ClipsActivityNotificationResult> {
+  const recording = await getRecording(input.recordingId);
+  if (!recording) {
+    console.error(`${LOG_LABEL}: recording ${input.recordingId} not found`);
+    return RECORDING_MISSING;
+  }
+
+  const allowed = await filterRecipientsByResourceAccess({
+    resourceType: "recording",
+    resourceId: recording.id,
+    emails: [recording.ownerEmail, ...(input.extraRecipients ?? [])].filter(
+      (email): email is string => Boolean(email),
+    ),
+    orgId: recording.orgId,
+  });
+
+  return notifyActivity({
+    candidates: allowed,
+    actorEmail: input.viewerEmail,
+    preferenceKey: CLIPS_USER_PREFS_KEY,
+    logLabel: LOG_LABEL,
+    send: (to) =>
+      sendClipsTransactionalEmail({
+        kind: "activity-reaction",
+        to,
+        recordingId: recording.id,
+        title: recording.title,
+        emoji: input.emoji,
+        authorEmail: input.viewerEmail,
+        authorName: input.viewerName ?? null,
+        videoTimestampMs: input.videoTimestampMs ?? null,
+      }),
+  });
+}

package/corpus/templates/clips/server/lib/recording-media-cleanup.ts

@@ -7,6 +7,7 @@ interface RecordingMediaUrls {
   videoUrl?: string | null;
   thumbnailUrl?: string | null;
   animatedThumbnailUrl?: string | null;
+  filmstripUrl?: string | null;
 }
 
 export interface RecordingMediaCleanupResult {
@@ -25,6 +26,7 @@ export function recordingMediaUrls(recording: RecordingMediaUrls): string[] {
     recording.videoUrl,
     recording.thumbnailUrl,
     recording.animatedThumbnailUrl,
+    recording.filmstripUrl,
   ];
   return [...new Set(urls.filter((url): url is string => Boolean(url)))];
 }

package/corpus/templates/clips/server/lib/recording-upload-state.ts

@@ -4,14 +4,46 @@ function escapeLike(value: string): string {
   return value.replace(/[!%_]/g, (match) => `!${match}`);
 }
 
-function chunkPrefix(recordingId: string): string {
-  return `recording-chunks-${recordingId}-`;
+function chunkPrefix(
+  recordingId: string,
+  generationId?: string | null,
+): string {
+  return generationId
+    ? `recording-chunks-${recordingId}-${generationId}-`
+    : `recording-chunks-${recordingId}-`;
 }
 
 function likePrefix(prefix: string): string {
   return `${escapeLike(prefix)}%`;
 }
 
+function exactChunkKeyArgs(
+  ownerEmail: string,
+  recordingId: string,
+  generationId?: string | null,
+): [string, string, number, string, string] {
+  const prefix = chunkPrefix(recordingId, generationId);
+  return [
+    ownerEmail,
+    likePrefix(prefix),
+    prefix.length + 6,
+    `${prefix}000000`,
+    `${prefix}999999`,
+  ];
+}
+
+const exactChunkKeyWhere = `session_id = ? AND key LIKE ? ESCAPE '!' AND length(key) = ? AND key >= ? AND key <= ?`;
+
+function isChunkKeyForGeneration(
+  key: string,
+  recordingId: string,
+  generationId?: string | null,
+): boolean {
+  const prefix = chunkPrefix(recordingId, generationId);
+  if (!key.startsWith(prefix)) return false;
+  return /^\d+$/.test(key.slice(prefix.length));
+}
+
 function numberFromRowValue(value: unknown): number {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value === "bigint") return Number(value);
@@ -81,21 +113,25 @@ export function validateRecordingChunkKeys(
 export async function listRecordingChunkKeys(
   ownerEmail: string,
   recordingId: string,
+  generationId?: string | null,
 ): Promise<string[]> {
   const { rows } = await getDbExec().execute({
-    sql: `SELECT key FROM application_state WHERE session_id = ? AND key LIKE ? ESCAPE '!'`,
-    args: [ownerEmail, likePrefix(chunkPrefix(recordingId))],
+    sql: `SELECT key FROM application_state WHERE ${exactChunkKeyWhere}`,
+    args: exactChunkKeyArgs(ownerEmail, recordingId, generationId),
   });
-  return rows.map((row) => String(row.key));
+  return rows
+    .map((row) => String(row.key))
+    .filter((key) => isChunkKeyForGeneration(key, recordingId, generationId));
 }
 
 export async function deleteRecordingChunks(
   ownerEmail: string,
   recordingId: string,
+  generationId?: string | null,
 ): Promise<number> {
   const result = await getDbExec().execute({
-    sql: `DELETE FROM application_state WHERE session_id = ? AND key LIKE ? ESCAPE '!'`,
-    args: [ownerEmail, likePrefix(chunkPrefix(recordingId))],
+    sql: `DELETE FROM application_state WHERE ${exactChunkKeyWhere}`,
+    args: exactChunkKeyArgs(ownerEmail, recordingId, generationId),
   });
   return result.rowsAffected ?? 0;
 }
@@ -103,13 +139,14 @@ export async function deleteRecordingChunks(
 export async function sumRecordingChunkBytes(
   ownerEmail: string,
   recordingId: string,
+  generationId?: string | null,
 ): Promise<number> {
   const bytesExpression = isPostgres()
     ? `COALESCE(SUM((value::jsonb ->> 'bytes')::bigint), 0)`
     : `COALESCE(SUM(json_extract(value, '$.bytes')), 0)`;
   const { rows } = await getDbExec().execute({
-    sql: `SELECT ${bytesExpression} AS bytes FROM application_state WHERE session_id = ? AND key LIKE ? ESCAPE '!'`,
-    args: [ownerEmail, likePrefix(chunkPrefix(recordingId))],
+    sql: `SELECT ${bytesExpression} AS bytes FROM application_state WHERE ${exactChunkKeyWhere}`,
+    args: exactChunkKeyArgs(ownerEmail, recordingId, generationId),
   });
   return numberFromRowValue(rows[0]?.bytes);
 }

package/corpus/templates/clips/server/lib/recordings.ts

@@ -5,9 +5,14 @@ import {
   getRequestUserEmail,
   getRequestOrgId,
 } from "@agent-native/core/server/request-context";
+import { getUserSetting } from "@agent-native/core/settings";
 import { and, count, desc, eq, sql } from "drizzle-orm";
 import { HTTPError, type H3Event } from "h3";
 
+import {
+  CLIPS_USER_PREFS_KEY,
+  type ClipsUserPrefs,
+} from "../../shared/clips-ai-prefs.js";
 import { getDb, schema } from "../db/index.js";
 
 export function getCurrentOwnerEmail(): string {
@@ -99,6 +104,25 @@ export async function getOrganizationDefaultVisibility(
   }
 }
 
+/**
+ * Visibility for a new recording: the personal preference of the creator
+ * wins, then the organization default, then the built-in default.
+ */
+export async function getDefaultRecordingVisibility(
+  organizationId: string | null | undefined,
+): Promise<RecordingVisibility> {
+  const email = getRequestUserEmail();
+  if (email) {
+    const prefs = (await getUserSetting(
+      normalizeOwnerEmail(email),
+      CLIPS_USER_PREFS_KEY,
+    )) as ClipsUserPrefs | null;
+    const preferred = prefs?.defaultRecordingVisibility;
+    if (isRecordingVisibility(preferred)) return preferred;
+  }
+  return getOrganizationDefaultVisibility(organizationId);
+}
+
 const ORG_ROLE_RANK: Record<OrganizationAccessRole, number> = {
   member: 1,
   admin: 2,

package/corpus/templates/clips/server/lib/resumable-session.ts

@@ -12,12 +12,16 @@ export interface StoredResumableSession {
   lastCommittedIndex?: number;
 }
 
-const key = (recordingId: string) => `resumable-session-${recordingId}`;
+const key = (recordingId: string, generationId?: string | null) =>
+  generationId
+    ? `resumable-session-${recordingId}-${generationId}`
+    : `resumable-session-${recordingId}`;
 
 export async function getResumableSession(
   recordingId: string,
+  generationId?: string | null,
 ): Promise<StoredResumableSession | null> {
-  const raw = await readAppState(key(recordingId));
+  const raw = await readAppState(key(recordingId, generationId));
   if (!raw || typeof raw !== "object") return null;
   return raw as unknown as StoredResumableSession;
 }
@@ -25,15 +29,17 @@ export async function getResumableSession(
 export async function setResumableSession(
   recordingId: string,
   session: StoredResumableSession,
+  generationId?: string | null,
 ): Promise<void> {
   await writeAppState(
-    key(recordingId),
+    key(recordingId, generationId),
     session as unknown as Record<string, unknown>,
   );
 }
 
 export async function deleteResumableSession(
   recordingId: string,
+  generationId?: string | null,
 ): Promise<void> {
-  await deleteAppState(key(recordingId));
+  await deleteAppState(key(recordingId, generationId));
 }

package/corpus/templates/clips/server/lib/transactional-email-templates.ts

@@ -9,6 +9,8 @@ const CLIPS_BRAND_NAME = "Clips";
 const EMAIL_SEND_TIMEOUT_MS = 60_000;
 const FRIENDLY_REPLY_TO = "hello@agent-native.com";
 const UNTITLED_CLIP = "Untitled Clip";
+const ACTIVITY_EMAIL_FOOTER =
+  "You received this because email notifications are on in your Clips settings.";
 
 interface TransactionalEmailBase {
   to: string;
@@ -37,6 +39,25 @@ export type ClipsTransactionalEmailInput =
   | (TransactionalEmailBase & {
       kind: "two-clips";
       generatedSummary?: string | null;
+    })
+  | (TransactionalEmailBase & {
+      kind: "activity-comment";
+      recordingId: string;
+      title?: string | null;
+      authorEmail?: string | null;
+      authorName?: string | null;
+      content: string;
+      videoTimestampMs?: number | null;
+      isReply?: boolean;
+    })
+  | (TransactionalEmailBase & {
+      kind: "activity-reaction";
+      recordingId: string;
+      title?: string | null;
+      emoji: string;
+      authorEmail?: string | null;
+      authorName?: string | null;
+      videoTimestampMs?: number | null;
     });
 
 export interface ClipsTransactionalEmailRenderOptions {
@@ -103,6 +124,31 @@ function clipUrl(
   return appUrlForPath(`/r/${encodeURIComponent(recordingId)}`, options);
 }
 
+function clipCommentsUrl(
+  recordingId: string,
+  videoTimestampMs: number | null | undefined,
+  options: ClipsTransactionalEmailRenderOptions,
+): string {
+  const url = new URL(clipUrl(recordingId, options));
+  url.searchParams.set("panel", "comments");
+  if (typeof videoTimestampMs === "number" && videoTimestampMs > 0) {
+    url.searchParams.set("t", String(Math.floor(videoTimestampMs / 1000)));
+  }
+  return url.toString();
+}
+
+function formatTimestamp(ms: number): string {
+  const total = Math.floor(ms / 1000);
+  const minutes = Math.floor(total / 60);
+  const seconds = total % 60;
+  return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+
+function quotedExcerpt(value: string): string {
+  const text = singleLine(value);
+  return text.length > 280 ? `${text.slice(0, 277)}…` : text;
+}
+
 function recordUrl(options: ClipsTransactionalEmailRenderOptions): string {
   return appUrlForPath("/record", options);
 }
@@ -232,6 +278,69 @@ export function renderClipsTransactionalEmail(
       });
       return { subject, ...rendered };
     }
+
+    case "activity-comment": {
+      const author =
+        singleLine(input.authorName) ||
+        normalizeEmailDisplayName(input.authorEmail, "Someone");
+      const at =
+        typeof input.videoTimestampMs === "number" && input.videoTimestampMs > 0
+          ? ` at ${formatTimestamp(input.videoTimestampMs)}`
+          : "";
+      const subject = input.isReply
+        ? `${author} replied on “${title}”`
+        : `${author} commented on “${title}”`;
+      const rendered = renderEmail({
+        brandName: CLIPS_BRAND_NAME,
+        preheader: subject,
+        heading: input.isReply
+          ? `${author} replied on your Clip`
+          : `${author} commented on your Clip`,
+        paragraphs: [
+          `${emailStrong(author)} left a ${input.isReply ? "reply" : "comment"} on ${emailStrong(title!)}${at}.`,
+          `“${quotedExcerpt(input.content)}”`,
+        ],
+        cta: {
+          label: "Read and reply",
+          url: clipCommentsUrl(
+            input.recordingId,
+            input.videoTimestampMs,
+            options,
+          ),
+        },
+        footer: ACTIVITY_EMAIL_FOOTER,
+      });
+      return { subject, ...rendered };
+    }
+
+    case "activity-reaction": {
+      const author =
+        singleLine(input.authorName) ||
+        normalizeEmailDisplayName(input.authorEmail, "Someone");
+      const at =
+        typeof input.videoTimestampMs === "number" && input.videoTimestampMs > 0
+          ? ` at ${formatTimestamp(input.videoTimestampMs)}`
+          : "";
+      const subject = `${author} reacted ${input.emoji} on “${title}”`;
+      const rendered = renderEmail({
+        brandName: CLIPS_BRAND_NAME,
+        preheader: subject,
+        heading: "Someone reacted to your Clip",
+        paragraphs: [
+          `${emailStrong(author)} reacted ${emailStrong(input.emoji)} on ${emailStrong(title!)}${at}.`,
+        ],
+        cta: {
+          label: "See Clip activity",
+          url: clipCommentsUrl(
+            input.recordingId,
+            input.videoTimestampMs,
+            options,
+          ),
+        },
+        footer: ACTIVITY_EMAIL_FOOTER,
+      });
+      return { subject, ...rendered };
+    }
   }
 }
 

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

@@ -0,0 +1,8 @@
+export const RETRYABLE_UPLOAD_INTERRUPTION_REASON =
+  "Upload was interrupted. The local recording is safe; retry from the Clips desktop app.";
+
+export function isRetryableUploadInterruption(
+  failureReason: string | null | undefined,
+): boolean {
+  return failureReason === RETRYABLE_UPLOAD_INTERRUPTION_REASON;
+}