@agent-native/core 0.108.0 → 0.109.1

package/corpus/templates/clips/desktop/src/lib/upload-verification.ts

@@ -2,6 +2,7 @@ export interface FinalizeReceipt {
   ok?: unknown;
   finalized?: unknown;
   status?: unknown;
+  verificationPending?: unknown;
   sourceSizeBytes?: unknown;
   durationMs?: unknown;
 }
@@ -11,16 +12,22 @@ export interface LocalRecordingProof {
   durationMs: number;
 }
 
+export type FinalizeReceiptStatus = "processing" | "ready";
+
 export function verifyFinalizeReceipt(
   receipt: FinalizeReceipt | null,
   local: LocalRecordingProof,
-): void {
-  if (
-    !receipt ||
-    receipt.ok !== true ||
-    receipt.finalized !== true ||
-    receipt.status !== "ready"
-  ) {
+): FinalizeReceiptStatus {
+  const ready =
+    receipt?.ok === true &&
+    receipt.finalized === true &&
+    receipt.status === "ready";
+  const processing =
+    receipt?.ok === true &&
+    receipt.finalized === false &&
+    receipt.status === "processing" &&
+    receipt.verificationPending === true;
+  if (!ready && !processing) {
     throw new Error(
       "Clip may be incomplete. Finalization was not confirmed; the local backup was kept.",
     );
@@ -48,4 +55,6 @@ export function verifyFinalizeReceipt(
       "Clip may be incomplete. The uploaded duration did not match the local recording; the local backup was kept.",
     );
   }
+
+  return ready ? "ready" : "processing";
 }

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

@@ -249,8 +249,7 @@ pub fn run() {
                 use tauri_plugin_deep_link::DeepLinkExt;
                 let dl_handle = app.handle().clone();
                 app.deep_link().on_open_url(move |event| {
-                    let urls: Vec<String> =
-                        event.urls().iter().map(|u| u.to_string()).collect();
+                    let urls: Vec<String> = event.urls().iter().map(|u| u.to_string()).collect();
                     dlog!("[clips-tray] deep link opened: {:?}", urls);
                     present_popover(&dl_handle);
                     let _ = dl_handle.emit("clips:deep-link", urls);
@@ -263,8 +262,7 @@ pub fn run() {
                 // arguments rather than an on_open_url event. Consume it here so
                 // the popover appears and the browser does not hit its fallback.
                 if let Ok(Some(urls)) = app.deep_link().get_current() {
-                    let url_strings: Vec<String> =
-                        urls.iter().map(|u| u.to_string()).collect();
+                    let url_strings: Vec<String> = urls.iter().map(|u| u.to_string()).collect();
                     dlog!("[clips-tray] deep link cold start: {:?}", url_strings);
                     present_popover(app.handle());
                     let _ = app.handle().emit("clips:deep-link", url_strings);

package/corpus/templates/clips/desktop/src-tauri/src/native_screen/live_upload.rs

@@ -36,8 +36,12 @@ pub(super) struct LiveUploadCtrl {
 
 pub(super) struct LiveUpload {
     pub(super) ctrl: Arc<LiveUploadCtrl>,
-    /// Resolves with the total bytes uploaded, or an error string.
-    pub(super) result_rx: tokio::sync::oneshot::Receiver<Result<u64, String>>,
+    pub(super) result_rx: tokio::sync::oneshot::Receiver<Result<LiveUploadResult, String>>,
+}
+
+pub(super) struct LiveUploadResult {
+    pub(super) bytes: u64,
+    pub(super) verification_pending: bool,
 }
 
 struct LiveUploadParams {
@@ -163,7 +167,7 @@ async fn send_live_upload_post_with_retry(
     duration_ms: Option<u128>,
     expected_source_bytes: Option<u64>,
     bytes: &[u8],
-) -> Result<(), String> {
+) -> Result<bool, String> {
     let rec = &params.recording_id;
     let mut attempt: u32 = 0;
     loop {
@@ -198,7 +202,7 @@ async fn send_live_upload_post_with_retry(
         )
         .await;
         let err = match result {
-            Ok(()) => return Ok(()),
+            Ok(verification_pending) => return Ok(verification_pending),
             Err(err) => err,
         };
         if attempt >= LIVE_UPLOAD_CHUNK_ATTEMPTS {
@@ -219,7 +223,7 @@ async fn live_upload_loop(
     app: AppHandle,
     ctrl: Arc<LiveUploadCtrl>,
     params: LiveUploadParams,
-) -> Result<u64, String> {
+) -> Result<LiveUploadResult, String> {
     let rec = params.recording_id.clone();
     eprintln!(
         "[live-upload] loop started for {rec}: file={} chunk={} bytes",
@@ -290,6 +294,7 @@ async fn live_upload_loop(
             // sentinel makes GCS silently commit only the aligned prefix, and
             // the session close then fails forever with 308 (incomplete).
             let mut final_sent = false;
+            let mut verification_pending = false;
             while final_len > offset {
                 let take = chunk.min(final_len - offset);
                 let is_last = offset + take >= final_len;
@@ -302,7 +307,7 @@ async fn live_upload_loop(
                 eprintln!(
                     "[live-upload] {rec}: sending tail chunk #{index} offset={offset} size={take} final={is_last}"
                 );
-                if let Err(e) = send_live_upload_post_with_retry(
+                let receipt = send_live_upload_post_with_retry(
                     &client,
                     &ctrl,
                     &params,
@@ -313,10 +318,16 @@ async fn live_upload_loop(
                     is_last.then_some(final_len),
                     &bytes,
                 )
-                .await
-                {
-                    eprintln!("[live-upload] {rec}: tail chunk #{index} failed: {e}");
-                    return Err(e);
+                .await;
+                let pending = match receipt {
+                    Ok(pending) => pending,
+                    Err(e) => {
+                        eprintln!("[live-upload] {rec}: tail chunk #{index} failed: {e}");
+                        return Err(e);
+                    }
+                };
+                if is_last {
+                    verification_pending = pending;
                 }
                 offset += take;
                 index += 1;
@@ -331,7 +342,7 @@ async fn live_upload_loop(
                     "[live-upload] {rec}: sending final post #{index} (total={}, duration_ms={duration_ms})",
                     index + 1
                 );
-                if let Err(e) = send_live_upload_post_with_retry(
+                verification_pending = match send_live_upload_post_with_retry(
                     &client,
                     &ctrl,
                     &params,
@@ -344,13 +355,19 @@ async fn live_upload_loop(
                 )
                 .await
                 {
-                    eprintln!("[live-upload] {rec}: final post failed: {e}");
-                    return Err(e);
-                }
+                    Ok(pending) => pending,
+                    Err(e) => {
+                        eprintln!("[live-upload] {rec}: final post failed: {e}");
+                        return Err(e);
+                    }
+                };
             }
             emit_native_upload_progress(&app, "opening", "Uploading clip", None, Some(1.0));
             eprintln!("[live-upload] {rec}: done — {index} post(s), {final_len} bytes total");
-            return Ok(final_len);
+            return Ok(LiveUploadResult {
+                bytes: final_len,
+                verification_pending,
+            });
         }
 
         if !wait_logged {

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

@@ -692,6 +692,7 @@ pub struct NativeFullscreenUploadResult {
     width: Option<u32>,
     height: Option<u32>,
     bytes: u64,
+    verification_pending: bool,
 }
 
 #[derive(Serialize, Clone)]
@@ -1388,20 +1389,23 @@ pub async fn native_fullscreen_recording_stop_and_upload(
         eprintln!(
             "[live-upload] stop: finalize result for {recording_id}: {}",
             match &result {
-                Ok(bytes) => format!("ok ({bytes} bytes)"),
+                Ok(upload) => format!("ok ({} bytes)", upload.bytes),
                 Err(e) => format!("error: {e}"),
             }
         );
         return match result {
-            Ok(bytes) => {
-                clear_saved_recording_after_success(&app, &saved);
+            Ok(upload) => {
+                if !upload.verification_pending {
+                    clear_saved_recording_after_success(&app, &saved);
+                }
                 emit_native_upload_finished(&app, &server_url, &recording_id, true, None, None);
                 Ok(NativeFullscreenUploadResult {
                     recording_id,
                     duration_ms: verified_duration_ms,
                     width: session.width,
                     height: session.height,
-                    bytes,
+                    bytes: upload.bytes,
+                    verification_pending: upload.verification_pending,
                 })
             }
             Err(err) => {
@@ -1481,7 +1485,9 @@ pub async fn native_fullscreen_recording_stop_and_upload(
 
     match result {
         Ok(result) => {
-            clear_saved_recording_after_success(&app, &saved);
+            if !result.verification_pending {
+                clear_saved_recording_after_success(&app, &saved);
+            }
             emit_native_upload_finished(&app, &server_url, &recording_id, true, None, None);
             Ok(result)
         }
@@ -2599,7 +2605,9 @@ pub async fn native_fullscreen_recording_retry_upload(
 
     match result {
         Ok(result) => {
-            clear_saved_recording_after_success(&app, &saved);
+            if !result.verification_pending {
+                clear_saved_recording_after_success(&app, &saved);
+            }
             Ok(result)
         }
         Err(err) => {
@@ -4003,6 +4011,7 @@ async fn upload_prepared_recording_file(
         .map_err(|e| format!("upload client failed: {e}"))?;
     let mut file =
         File::open(&prepared.path).map_err(|e| format!("native recording open failed: {e}"))?;
+    let verification_pending;
 
     if upload_mode == NativeUploadMode::Streaming {
         // Resumable providers require every non-final body to be aligned. The
@@ -4055,7 +4064,7 @@ async fn upload_prepared_recording_file(
             None,
             Some(streaming_full_chunks as f32 / total_posts as f32),
         );
-        send_upload_post(
+        verification_pending = send_upload_post(
             &client,
             &server_url,
             &recording_id,
@@ -4123,7 +4132,7 @@ async fn upload_prepared_recording_file(
             None,
             Some(total_chunks as f32 / total_posts as f32),
         );
-        send_upload_post(
+        verification_pending = send_upload_post(
             &client,
             &server_url,
             &recording_id,
@@ -4153,6 +4162,7 @@ async fn upload_prepared_recording_file(
         width,
         height,
         bytes: total_bytes,
+        verification_pending,
     })
 }
 
@@ -4270,7 +4280,7 @@ async fn send_upload_post(
     locally_transcoded: bool,
     expected_source_bytes: Option<u64>,
     body: Vec<u8>,
-) -> Result<(), String> {
+) -> Result<bool, String> {
     let body_len = body.len();
     let url = upload_url(
         server_url,
@@ -4319,7 +4329,7 @@ async fn send_upload_post(
             body.chars().take(400).collect::<String>()
         ));
     }
-    if is_final {
+    let verification_pending = if is_final {
         verify_native_finalize_receipt(
             &body,
             expected_source_bytes.ok_or_else(|| {
@@ -4328,13 +4338,15 @@ async fn send_upload_post(
             duration_ms.ok_or_else(|| {
                 "Clip may be incomplete: final upload had no local duration".to_string()
             })?,
-        )?;
-    }
+        )?
+    } else {
+        false
+    };
     eprintln!(
         "[clips-tray] native upload post ok recording={recording_id} mode={} index={index}/{total} final={is_final}",
         upload_mode.label()
     );
-    Ok(())
+    Ok(verification_pending)
 }
 
 #[derive(Deserialize)]
@@ -4343,6 +4355,7 @@ struct NativeFinalizeReceipt {
     ok: bool,
     finalized: bool,
     status: Option<String>,
+    verification_pending: Option<bool>,
     source_size_bytes: Option<u64>,
     duration_ms: Option<u128>,
 }
@@ -4351,12 +4364,17 @@ fn verify_native_finalize_receipt(
     body: &str,
     expected_source_bytes: u64,
     expected_duration_ms: u128,
-) -> Result<(), String> {
+) -> Result<bool, String> {
     let receipt: NativeFinalizeReceipt = serde_json::from_str(body).map_err(|_| {
         "Clip may be incomplete. The final upload receipt was unreadable; the local backup was kept."
             .to_string()
     })?;
-    if !receipt.ok || !receipt.finalized || receipt.status.as_deref() != Some("ready") {
+    let ready = receipt.ok && receipt.finalized && receipt.status.as_deref() == Some("ready");
+    let processing = receipt.ok
+        && !receipt.finalized
+        && receipt.status.as_deref() == Some("processing")
+        && receipt.verification_pending == Some(true);
+    if !ready && !processing {
         return Err(
             "Clip may be incomplete. Finalization was not confirmed; the local backup was kept."
                 .to_string(),
@@ -4374,7 +4392,7 @@ fn verify_native_finalize_receipt(
                 .to_string(),
         );
     }
-    Ok(())
+    Ok(processing)
 }
 
 fn media_durations_materially_match(expected_ms: u128, actual_ms: u128) -> bool {
@@ -4399,9 +4417,18 @@ mod native_finalize_receipt_tests {
     }
 
     #[test]
-    fn accepts_only_matching_ready_receipts() {
+    fn accepts_matching_ready_and_pending_verification_receipts() {
         let ready = r#"{"ok":true,"finalized":true,"status":"ready","sourceSizeBytes":581614005,"durationMs":1593259}"#;
-        assert!(verify_native_finalize_receipt(ready, 581_614_005, 1_592_773).is_ok());
+        assert_eq!(
+            verify_native_finalize_receipt(ready, 581_614_005, 1_592_773),
+            Ok(false)
+        );
+
+        let processing = r#"{"ok":true,"finalized":false,"status":"processing","verificationPending":true,"sourceSizeBytes":581614005,"durationMs":1593259}"#;
+        assert_eq!(
+            verify_native_finalize_receipt(processing, 581_614_005, 1_592_773),
+            Ok(true)
+        );
 
         let short = r#"{"ok":true,"finalized":true,"status":"ready","sourceSizeBytes":581614005,"durationMs":483000}"#;
         assert!(

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

@@ -0,0 +1,130 @@
+import { getDbExec } from "@agent-native/core/db";
+import { runWithRequestContext } from "@agent-native/core/server";
+import { and, eq, isNull } from "drizzle-orm";
+
+import finalizeRecording from "../../actions/finalize-recording.js";
+import { getDb, schema } from "../db/index.js";
+import {
+  MEDIA_VERIFICATION_STATE_PREFIX,
+  parseMediaVerificationMarker,
+} from "../lib/media-verification-state.js";
+import { ownerEmailMatches } from "../lib/recordings.js";
+
+const SWEEP_INTERVAL_MS = 60_000;
+const DISPATCH_FALLBACK_GRACE_MS = 30_000;
+const MAX_ATTEMPTS = 10;
+let skippingLogged = false;
+
+export async function runMediaVerificationSweepOnce(): Promise<void> {
+  const { rows } = await getDbExec().execute({
+    sql: `SELECT session_id, key, value FROM application_state WHERE key LIKE ?`,
+    args: [`${MEDIA_VERIFICATION_STATE_PREFIX}%`],
+  });
+  const now = Date.now();
+
+  for (const row of rows as Array<{
+    session_id?: unknown;
+    key?: unknown;
+    value?: unknown;
+  }>) {
+    const sessionId =
+      typeof row.session_id === "string" ? row.session_id.trim() : "";
+    const key = typeof row.key === "string" ? row.key : "";
+    const recordingId = key.startsWith(MEDIA_VERIFICATION_STATE_PREFIX)
+      ? key.slice(MEDIA_VERIFICATION_STATE_PREFIX.length)
+      : "";
+    const rawValue = typeof row.value === "string" ? row.value : "";
+    let rawState: unknown;
+    try {
+      rawState = JSON.parse(rawValue);
+    } catch {
+      continue;
+    }
+    const marker = parseMediaVerificationMarker(rawState);
+    if (
+      !sessionId ||
+      !recordingId ||
+      !marker ||
+      marker.recordingId !== recordingId
+    ) {
+      continue;
+    }
+
+    const nextAttemptAt = Date.parse(marker.nextAttemptAt);
+    const leaseUntil = marker.leaseUntil
+      ? Date.parse(marker.leaseUntil)
+      : Number.NEGATIVE_INFINITY;
+    const due =
+      marker.status === "pending"
+        ? now >= nextAttemptAt + DISPATCH_FALLBACK_GRACE_MS
+        : now >= leaseUntil;
+    if (marker.completedAttempts >= MAX_ATTEMPTS || !due) {
+      continue;
+    }
+
+    try {
+      const [recording] = await getDb()
+        .select({
+          ownerEmail: schema.recordings.ownerEmail,
+          orgId: schema.recordings.orgId,
+        })
+        .from(schema.recordings)
+        .where(
+          and(
+            eq(schema.recordings.id, recordingId),
+            ownerEmailMatches(schema.recordings.ownerEmail, sessionId),
+            eq(schema.recordings.status, "processing"),
+            isNull(schema.recordings.trashedAt),
+          ),
+        )
+        .limit(1);
+      if (!recording) continue;
+
+      await runWithRequestContext(
+        {
+          userEmail: recording.ownerEmail,
+          orgId: recording.orgId ?? undefined,
+        },
+        async () => {
+          await finalizeRecording.run({
+            id: recordingId,
+            mediaVerificationRetryAttempt: Math.min(
+              MAX_ATTEMPTS,
+              marker.completedAttempts + 1,
+            ),
+          });
+        },
+      );
+    } catch (err) {
+      console.warn("[media-verification] sweep item failed", {
+        key: String(row.key ?? ""),
+        recordingId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+}
+
+export default function registerMediaVerificationJob(): void {
+  const isProd = process.env.NODE_ENV === "production";
+  const flag = process.env.RUN_BACKGROUND_JOBS;
+  const enabled = flag === "1" || (isProd && flag !== "0");
+  if (!enabled) {
+    if (process.env.DEBUG && !skippingLogged) {
+      console.log(
+        "[media-verification] Skipping background sweep (set RUN_BACKGROUND_JOBS=1 to enable in dev).",
+      );
+      skippingLogged = true;
+    }
+    return;
+  }
+
+  setInterval(() => {
+    runMediaVerificationSweepOnce().catch((err) =>
+      console.error("[media-verification] interval failed:", err),
+    );
+  }, SWEEP_INTERVAL_MS);
+  console.log(
+    `[media-verification] Recurring recovery sweep every ${SWEEP_INTERVAL_MS / 1000}s.`,
+  );
+}

package/corpus/templates/clips/server/lib/builder-media-compression.ts

@@ -648,6 +648,21 @@ async function processCompressionState(
   try {
     const compressed = await triggerBuilderCompression(state);
     if (compressed) {
+      if (!compressed.durationMs) {
+        if (attempts >= MAX_TRIGGER_ATTEMPTS) {
+          return markCompressionFailed(
+            { ...state, attempts },
+            `Builder media compression did not provide a verified duration after ${attempts} attempts`,
+          );
+        }
+        return writeCompressionState(state, {
+          status: "triggered",
+          attempts,
+          lastTriggeredAt: new Date().toISOString(),
+          nextAttemptAt: isoAfter(TRIGGERED_POLL_DELAY_MS),
+          detail: "Compressed media is not ready with a verified duration yet",
+        });
+      }
       return swapRecordingToCompressed(
         state,
         compressed.url,

package/corpus/templates/clips/server/lib/media-verification-state.ts

@@ -0,0 +1,38 @@
+export const MEDIA_VERIFICATION_STATE_PREFIX = "recording-media-verification-";
+
+export type MediaVerificationMarker = {
+  recordingId: string;
+  status: "pending" | "leased";
+  completedAttempts: number;
+  nextAttemptAt: string;
+  leaseUntil: string | null;
+  updatedAt: string;
+};
+
+export function mediaVerificationStateKey(recordingId: string): string {
+  return `${MEDIA_VERIFICATION_STATE_PREFIX}${recordingId}`;
+}
+
+export function parseMediaVerificationMarker(
+  value: unknown,
+): MediaVerificationMarker | null {
+  if (!value || typeof value !== "object") return null;
+  const state = value as Record<string, unknown>;
+  if (
+    typeof state.recordingId !== "string" ||
+    !state.recordingId ||
+    (state.status !== "pending" && state.status !== "leased") ||
+    typeof state.completedAttempts !== "number" ||
+    !Number.isInteger(state.completedAttempts) ||
+    state.completedAttempts < 0 ||
+    typeof state.nextAttemptAt !== "string" ||
+    !Number.isFinite(Date.parse(state.nextAttemptAt)) ||
+    (state.leaseUntil !== null &&
+      (typeof state.leaseUntil !== "string" ||
+        !Number.isFinite(Date.parse(state.leaseUntil)))) ||
+    typeof state.updatedAt !== "string"
+  ) {
+    return null;
+  }
+  return state as MediaVerificationMarker;
+}

package/corpus/templates/clips/server/lib/player-thumbnail-url.ts

@@ -0,0 +1,31 @@
+export type PlayerThumbnailRecording = {
+  id: string;
+  thumbnailUrl?: string | null;
+  animatedThumbnailUrl?: string | null;
+};
+
+function appendQueryParam(url: string, key: string, value: string): string {
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+}
+
+export function localRecordingThumbnailRoute(recordingId: string): string {
+  return `/api/thumbnail/${encodeURIComponent(recordingId)}`;
+}
+
+export function resolvePlayerThumbnailUrl(
+  recording: PlayerThumbnailRecording,
+  options: {
+    accessToken?: string | null;
+    appPath?: (path: string) => string;
+  } = {},
+): string | null {
+  if (!recording.thumbnailUrl && !recording.animatedThumbnailUrl) return null;
+
+  let resolved = localRecordingThumbnailRoute(recording.id);
+  if (options.accessToken) {
+    resolved = appendQueryParam(resolved, "t", options.accessToken);
+  }
+  if (options.appPath) resolved = options.appPath(resolved);
+  return resolved;
+}

package/corpus/templates/clips/server/lib/post-finalize-dispatch.ts

@@ -7,7 +7,7 @@ import {
   signScopedAgentAccessToken,
 } from "@agent-native/core/server";
 
-export type PostFinalizeJobKind = "seekable" | "transcript";
+export type PostFinalizeJobKind = "media-ready" | "seekable" | "transcript";
 
 export const POST_FINALIZE_JOB_TOKEN_KIND = "clips-post-finalize-job";
 
@@ -47,10 +47,12 @@ export async function dispatchPostFinalizeJob(args: {
   delayMs?: number;
   retryAttempt?: number;
   regenerate?: boolean;
+  requireAccepted?: boolean;
 }): Promise<void> {
+  const { requireAccepted = false, ...job } = args;
   const token = signScopedAgentAccessToken({
     resourceKind: POST_FINALIZE_JOB_TOKEN_KIND,
-    resourceId: postFinalizeJobResourceId(args.recordingId, args.kind),
+    resourceId: postFinalizeJobResourceId(job.recordingId, job.kind),
     ttlSeconds: 10 * 60,
   });
   const basePath = normalizeBasePath(
@@ -62,7 +64,7 @@ export async function dispatchPostFinalizeJob(args: {
   const usesDurableBackground =
     dispatchPathTargetsNetlifyBackgroundFunction(dispatchPath);
   const body = JSON.stringify({
-    ...args,
+    ...job,
     token,
     ...(usesDurableBackground
       ? {
@@ -100,6 +102,11 @@ export async function dispatchPostFinalizeJob(args: {
     });
   });
 
+  if (requireAccepted) {
+    await dispatch;
+    return;
+  }
+
   await Promise.race([
     dispatch,
     new Promise<void>((resolve) => setTimeout(resolve, DISPATCH_SETTLE_MS)),

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

@@ -37,12 +37,12 @@ export default createAuthPlugin({
     "/api/media",
     "/api/clips-latest.json",
     "/api/clips-updater.json",
-    // Blob-serving for the dev-fallback (no provider) path.
-    // The route itself enforces resolveAccess + password/expiry checks;
-    // we add it to publicPaths so anonymous viewers on /share/:id can
-    // actually fetch the <video> bytes for public recordings. The chunk
-    // upload POSTs stay behind auth under /api/uploads/*.
+    // Public media-serving routes enforce resolveAccess + password/expiry
+    // checks themselves. They need to bypass the app auth shell so anonymous
+    // viewers and crawlers can fetch public share media. Chunk upload POSTs
+    // stay behind auth under /api/uploads/*.
     "/api/video",
+    "/api/thumbnail",
     "/api/auth/google-calendar",
     "/_agent-native/google/auth-url",
     "/_agent-native/google/callback",

package/corpus/templates/clips/server/plugins/calendar-jobs.ts

@@ -6,6 +6,7 @@
  */
 
 import registerBuilderMediaCompressionJob from "../jobs/builder-media-compression.js";
+import registerMediaVerificationJob from "../jobs/media-verification.js";
 import registerMeetingRemindersJob from "../jobs/meeting-reminders.js";
 import registerPollCalendarsJob from "../jobs/poll-calendars.js";
 import registerStaleMeetingSweeperJob from "../jobs/stale-meeting-sweeper.js";
@@ -16,6 +17,7 @@ export default () => {
   // background loop is off.
   registerMeetingRemindersJob();
   registerBuilderMediaCompressionJob();
+  registerMediaVerificationJob();
   registerPollCalendarsJob();
   registerStaleMeetingSweeperJob();
 };