@agent-native/core 0.88.0 → 0.90.2

package/corpus/templates/clips/app/routes/record.tsx

@@ -6,7 +6,6 @@ import {
   useT,
 } from "@agent-native/core/client";
 import { useLiveTranscription } from "@agent-native/core/client/transcription/use-live-transcription";
-import { Skeleton } from "@agent-native/toolkit/ui/skeleton";
 import type { BrowserDiagnosticsData } from "@shared/browser-diagnostics";
 import { waitForReadyRecordingAfterFinalizeError } from "@shared/finalize-recovery";
 import {
@@ -30,6 +29,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { flushSync } from "react-dom";
 import { Link, useLocation, useNavigate } from "react-router";
 
+import { Skeleton } from "@/components/ui/skeleton";
 import { useDesktopPromo } from "@/hooks/use-desktop-promo";
 import {
   fetchVideoStorageStatus,
@@ -82,8 +82,6 @@ async function writeAppState(key: string, value: unknown): Promise<void> {
     },
   );
 }
-import { Button } from "@agent-native/toolkit/ui/button";
-import { Spinner } from "@agent-native/toolkit/ui/spinner";
 import {
   bugReportTitle,
   parseBugReportContext,
@@ -110,6 +108,8 @@ import {
 } from "@/components/recorder/recorder-engine";
 import { RecordingToolbar } from "@/components/recorder/recording-toolbar";
 import { StorageSetupCard } from "@/components/recorder/storage-setup-card";
+import { Button } from "@/components/ui/button";
+import { Spinner } from "@/components/ui/spinner";
 
 export function meta() {
   return [{ title: enMessages.recordRoute.pageTitle }];
@@ -959,6 +959,7 @@ export default function RecordRoute() {
     mode: RecordingMode;
     displaySurface: DisplaySurface;
     micDeviceId: string | null;
+    micDeviceLabel?: string | null;
     cameraDeviceId: string | null;
   } | null>(null);
   const tickRef = useRef<number | null>(null);
@@ -1042,6 +1043,7 @@ export default function RecordRoute() {
       mode: RecordingMode;
       displaySurface: DisplaySurface;
       micDeviceId: string | null;
+      micDeviceLabel?: string | null;
       cameraDeviceId: string | null;
     }) => {
       const blockedFeature = isEmbeddedWindow()
@@ -1086,6 +1088,7 @@ export default function RecordRoute() {
           mode: opts.mode,
           displaySurface: opts.displaySurface,
           micDeviceId: opts.micDeviceId,
+          micDeviceLabel: opts.micDeviceLabel,
           cameraDeviceId: opts.cameraDeviceId,
           cameraBubbleSize: cameraSize,
           uploadUrl: "",
@@ -1101,6 +1104,13 @@ export default function RecordRoute() {
           onWarning: (message) => {
             toast.warning(message);
           },
+          // Camera track ended mid-recording (unplugged, permission revoked,
+          // device asleep). The recorded composite already drops the bubble;
+          // clear the on-page preview stream too so it doesn't keep showing a
+          // frozen last frame that no longer matches the recorded output.
+          onCameraEnded: () => {
+            setCameraStream(null);
+          },
           // Track the surface the user actually chose (and any mid-recording
           // switch) so the live camera bubble is hidden only when the full
           // screen — including this tab's overlay — is being captured.
@@ -1188,12 +1198,10 @@ export default function RecordRoute() {
         // session for instant transcription; the recorded audio still uses
         // the exact selected device and can be transcribed after upload.
         //
-        // The one exception is when a stale saved mic forced the engine to
-        // fall back to the system default during acquire(): the recording is
-        // now on the default device, so live transcription would use the same
-        // mic and is safe to start.
-        const usingDefaultMic =
-          !opts.micDeviceId || engine.didMicFallBackToDefault();
+        // The engine reports whether the final recorded mic stream really is
+        // the system default; corrected explicit fallbacks must not start Web
+        // Speech because it would listen to a different device.
+        const usingDefaultMic = engine.didMicUseSystemDefault();
         if (wantsMic && usingDefaultMic && liveTranscription.supported) {
           liveTranscription.start();
         }
@@ -1349,6 +1357,7 @@ export default function RecordRoute() {
   // upload pipeline so finalize-recording handles it identically.
   // -------------------------------------------------------------------------
   const UPLOAD_CHUNK_BYTES = 3 * 1024 * 1024;
+  const UPLOAD_PARALLELISM = 4;
 
   const probeVideoMetadata = useCallback(
     (
@@ -1553,6 +1562,8 @@ export default function RecordRoute() {
               visibility: reportContext ? "org" : undefined,
               spaceIds: spaceIdFromUrl ? [spaceIdFromUrl] : undefined,
               folderId: folderIdFromUrl ?? undefined,
+              mimeType: uploadMimeType,
+              requestStreaming: false,
             }),
           },
         );
@@ -1592,92 +1603,180 @@ export default function RecordRoute() {
           1,
           Math.ceil(uploadBlob.size / UPLOAD_CHUNK_BYTES),
         );
-        let finalChunkResult: Record<string, unknown> | null = null;
-        for (let i = 0; i < totalChunks; i++) {
-          if (isStale()) throw makeAbortError("Upload cancelled");
+
+        const chunkDescs = Array.from({ length: totalChunks }, (_, i) => {
           const start = i * UPLOAD_CHUNK_BYTES;
           const end = Math.min(start + UPLOAD_CHUNK_BYTES, uploadBlob.size);
-          const slice = uploadBlob.slice(start, end, uploadMimeType);
           const isFinal = i === totalChunks - 1;
-          const chunkUrl = chunkUploadUrl(uploadBase, {
+          return {
             index: i,
-            total: totalChunks,
+            slice: uploadBlob.slice(start, end, uploadMimeType),
             isFinal,
-            mimeType: uploadMimeType,
-            durationMs: isFinal ? meta.durationMs : undefined,
-            width: isFinal ? meta.width : undefined,
-            height: isFinal ? meta.height : undefined,
-            hasAudio: isFinal ? true : undefined,
-            hasCamera: isFinal ? false : undefined,
+            url: chunkUploadUrl(uploadBase, {
+              index: i,
+              total: totalChunks,
+              isFinal,
+              mimeType: uploadMimeType,
+              durationMs: isFinal ? meta.durationMs : undefined,
+              width: isFinal ? meta.width : undefined,
+              height: isFinal ? meta.height : undefined,
+              hasAudio: isFinal ? true : undefined,
+              hasCamera: isFinal ? false : undefined,
+            }),
+          };
+        });
+        const finalChunkDesc = chunkDescs[chunkDescs.length - 1];
+        const parallelChunks = chunkDescs.slice(0, -1);
+
+        const chunkAbort = new AbortController();
+        if (abort.signal.aborted) {
+          chunkAbort.abort(abort.signal.reason);
+        } else {
+          abort.signal.addEventListener(
+            "abort",
+            () => chunkAbort.abort(abort.signal.reason),
+            { once: true },
+          );
+        }
+
+        const finalChunk = { result: null as Record<string, unknown> | null };
+        let uploadError: Error | null = null;
+        const queue = parallelChunks.slice();
+
+        const worker = async () => {
+          while (queue.length > 0) {
+            if (isStale() || chunkAbort.signal.aborted) break;
+            const item = queue.shift();
+            if (!item) break;
+            const { index, slice, url } = item;
+
+            let chunkRes: Response;
+            try {
+              chunkRes = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": uploadMimeType },
+                body: await slice.arrayBuffer(),
+                signal: chunkAbort.signal,
+              });
+            } catch (err) {
+              if (chunkAbort.signal.aborted) return;
+              if (!uploadError) {
+                uploadError =
+                  err instanceof Error ? err : new Error(String(err));
+                chunkAbort.abort(uploadError);
+              }
+              return;
+            }
+
+            if (!chunkRes.ok) {
+              const text = await chunkRes.text().catch(() => "");
+              const error = new Error(
+                t("recordRoute.uploadFailedAtChunk", {
+                  chunk: index + 1,
+                  total: totalChunks,
+                  message: text || chunkRes.statusText,
+                }),
+              );
+              (error as Error & { status?: number }).status = chunkRes.status;
+              if (!uploadError) {
+                uploadError = error;
+                chunkAbort.abort(uploadError);
+              }
+              return;
+            }
+            setUploadProgress((index + 1) / totalChunks);
+          }
+        };
+
+        await Promise.all(
+          Array.from(
+            { length: Math.min(UPLOAD_PARALLELISM, parallelChunks.length) },
+            worker,
+          ),
+        );
+
+        if (uploadError) throw uploadError;
+        if (abort.signal.aborted) {
+          const reason = abort.signal.reason;
+          throw reason instanceof Error
+            ? reason
+            : makeAbortError("Upload cancelled");
+        }
+        if (isStale()) throw makeAbortError("Upload cancelled");
+
+        const { index, slice, url } = finalChunkDesc;
+        let chunkRes: Response | null = null;
+        try {
+          chunkRes = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": uploadMimeType },
+            body: await slice.arrayBuffer(),
+            signal: abort.signal,
           });
-          let chunkRes: Response;
-          try {
-            chunkRes = await fetch(chunkUrl, {
-              method: "POST",
-              headers: { "Content-Type": uploadMimeType },
-              body: await slice.arrayBuffer(),
+        } catch (err) {
+          if (
+            createdId &&
+            (err as { name?: string } | null)?.name !== "AbortError"
+          ) {
+            const recovered = await waitForReadyRecordingAfterFinalizeError({
+              uploadUrl: uploadBase,
+              recordingId: createdId,
+              preferAuthenticated: true,
               signal: abort.signal,
             });
-          } catch (err) {
-            if (
-              isFinal &&
-              createdId &&
-              (err as { name?: string } | null)?.name !== "AbortError"
-            ) {
-              const recovered = await waitForReadyRecordingAfterFinalizeError({
-                uploadUrl: uploadBase,
-                recordingId: createdId,
-                preferAuthenticated: true,
-              });
-              if (recovered) {
-                finalChunkResult = recovered;
-                break;
-              }
+            if (recovered) {
+              finalChunk.result = recovered;
+            } else {
+              throw err;
             }
+          } else {
             throw err;
           }
-          if (!chunkRes.ok) {
-            const text = await chunkRes.text().catch(() => "");
-            const error = new Error(
-              t("recordRoute.uploadFailedAtChunk", {
-                chunk: i + 1,
-                total: totalChunks,
-                message: text || chunkRes.statusText,
-              }),
-            );
-            (error as Error & { status?: number }).status = chunkRes.status;
-            if (
-              isFinal &&
-              createdId &&
-              chunkRes.status !== 413 &&
-              !isUploadSizeError(error.message)
-            ) {
-              const recovered = await waitForReadyRecordingAfterFinalizeError({
-                uploadUrl: uploadBase,
-                recordingId: createdId,
-                preferAuthenticated: true,
-              });
-              if (recovered) {
-                finalChunkResult = recovered;
-                break;
-              }
+        }
+
+        if (chunkRes && !chunkRes.ok) {
+          const text = await chunkRes.text().catch(() => "");
+          const error = new Error(
+            t("recordRoute.uploadFailedAtChunk", {
+              chunk: index + 1,
+              total: totalChunks,
+              message: text || chunkRes.statusText,
+            }),
+          );
+          (error as Error & { status?: number }).status = chunkRes.status;
+          if (
+            createdId &&
+            chunkRes.status !== 413 &&
+            !isUploadSizeError(error.message)
+          ) {
+            const recovered = await waitForReadyRecordingAfterFinalizeError({
+              uploadUrl: uploadBase,
+              recordingId: createdId,
+              preferAuthenticated: true,
+              signal: abort.signal,
+            });
+            if (recovered) {
+              finalChunk.result = recovered;
+            } else {
+              throw error;
             }
+          } else {
             throw error;
           }
-          if (isFinal) {
-            finalChunkResult =
-              ((await chunkRes.json().catch(() => null)) as Record<
-                string,
-                unknown
-              > | null) ?? null;
-          }
-          setUploadProgress((i + 1) / totalChunks);
+        }
+
+        if (chunkRes?.ok) {
+          finalChunk.result =
+            ((await chunkRes.json().catch(() => null)) as Record<
+              string,
+              unknown
+            > | null) ?? null;
         }
 
         setUiState("complete");
         const waitingForStorage =
-          finalChunkResult?.waitingForStorage === true ||
-          finalChunkResult?.status === "waiting_storage";
+          finalChunk.result?.waitingForStorage === true ||
+          finalChunk.result?.status === "waiting_storage";
         if (waitingForStorage) {
           toast.info(t("recordRoute.videoReadyToUpload"), {
             description: t("recordRoute.connectStorageToFinish"),
@@ -2123,10 +2222,18 @@ export default function RecordRoute() {
       // ignore
     }
     if (pendingId) {
+      // The recording may have already finished uploading server-side (the
+      // final chunk can land, and the row can flip to "ready", while we're
+      // still awaiting saveBrowserDiagnostics/finishSavedRecording on the
+      // client). A separate GET-status-then-POST-trash sequence would still
+      // race finalize between the two calls, so ask the server to trash
+      // atomically instead: `skipIfReady` makes the trash a conditional
+      // no-op if the row is already "ready" by the time the UPDATE runs, so a
+      // fully saved video is never silently discarded.
       fetch(agentNativePath("/_agent-native/actions/trash-recording"), {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ id: pendingId }),
+        body: JSON.stringify({ id: pendingId, skipIfReady: true }),
       }).catch(() => {});
     }
     setCameraStream(null);

package/corpus/templates/clips/app/routes/share.$shareId.tsx

@@ -8,21 +8,6 @@ import {
   getBrowserTabId,
   useT,
 } from "@agent-native/core/client";
-import { Button } from "@agent-native/toolkit/ui/button";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuTrigger,
-} from "@agent-native/toolkit/ui/dropdown-menu";
-import { Skeleton } from "@agent-native/toolkit/ui/skeleton";
-import { Spinner } from "@agent-native/toolkit/ui/spinner";
-import {
-  Tabs,
-  TabsList,
-  TabsTrigger,
-  TabsContent,
-} from "@agent-native/toolkit/ui/tabs";
 import {
   IconAlertTriangle,
   IconArrowLeft,
@@ -63,6 +48,16 @@ import {
   type VideoPlayerHandle,
 } from "@/components/player/video-player";
 import { StorageSetupCard } from "@/components/recorder/storage-setup-card";
+import { Button } from "@/components/ui/button";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Spinner } from "@/components/ui/spinner";
+import { Tabs, TabsList, TabsTrigger, TabsContent } from "@/components/ui/tabs";
 import { isDefaultTitle } from "@/hooks/use-auto-title";
 import { usePlayerShortcuts } from "@/hooks/use-player-shortcuts";
 import { useViewTracking } from "@/hooks/use-view-tracking";
@@ -452,7 +447,28 @@ export default function ShareRoute() {
       return { ok: res.ok, status: res.status, data };
     },
     enabled: !!shareId,
-    refetchInterval: 2000,
+    refetchInterval: (q) => {
+      const payload = (q.state.data as { data?: any } | undefined)?.data;
+      const rec = payload?.recording;
+      if (!rec) return false;
+      // Poll while the recording is still being assembled / transcoded so the
+      // page auto-upgrades from "Processing" to the real player the moment
+      // the server flips status to 'ready' and writes videoUrl. Mirrors
+      // r.$recordingId.tsx's playerDataQ.refetchInterval.
+      if (rec.status !== "ready" || !rec.videoUrl) return 2000;
+      // Also keep polling while a transcript is pending so "Transcribing…"
+      // auto-flips to the ready transcript (or to the failure card). The
+      // public payload has no transcript.cleanup field (that's authenticated
+      // -only), so there is no equivalent of the cleanup.status poll here.
+      if (payload?.transcript?.status === "pending") return 3000;
+      // And keep polling while the title is still the server-seeded default
+      // — the agent will land a generated title via `update-recording` and
+      // we want the skeleton to swap in promptly.
+      if (shouldShowGeneratedTitleSkeleton(rec, payload?.transcript?.status)) {
+        return 3000;
+      }
+      return false;
+    },
     refetchIntervalInBackground: false,
   });
 
@@ -792,10 +808,10 @@ export default function ShareRoute() {
   );
 
   return (
-    <div className="flex min-h-screen flex-col bg-background text-foreground lg:h-screen lg:flex-row lg:overflow-hidden">
+    <div className="flex min-h-screen max-w-full flex-col overflow-x-hidden bg-background text-foreground lg:h-screen lg:flex-row lg:overflow-hidden">
       {agentDiscovery}
       <div className="flex w-full min-w-0 flex-col lg:flex-1">
-        <header className="flex shrink-0 flex-wrap items-center gap-3 border-b border-border px-4 py-3 lg:flex-nowrap">
+        <header className="flex min-w-0 shrink-0 flex-wrap items-center gap-2 border-b border-border px-3 py-2 sm:gap-3 sm:px-4 sm:py-3 lg:flex-nowrap">
           {session ? (
             <Button
               variant="ghost"
@@ -817,7 +833,7 @@ export default function ShareRoute() {
             )}
           </div>
 
-          <div className="flex w-full min-w-0 items-center justify-between gap-2 sm:w-auto sm:justify-end">
+          <div className="flex w-full min-w-0 flex-wrap items-center justify-between gap-2 sm:w-auto sm:justify-end">
             {viewerCanEdit ? (
               <Button variant="outline" size="sm" asChild>
                 <a
@@ -901,12 +917,13 @@ export default function ShareRoute() {
           </div>
         </header>
 
-        <div className="flex flex-col gap-4 overflow-visible p-4 lg:min-h-0 lg:flex-1 lg:overflow-hidden">
+        <div className="flex flex-col gap-4 overflow-hidden p-0 sm:p-4 lg:min-h-0 lg:flex-1">
           <div className="aspect-video w-full lg:min-h-0 lg:flex-1 lg:aspect-auto">
             <VideoPlayer
               ref={playerRef}
               recordingId={recording.id}
               videoUrl={recording.videoUrl}
+              videoFormat={recording.videoFormat}
               embedProvider={isLoomEmbedBacked ? "loom" : null}
               durationMs={recording.durationMs}
               editsJson={recording.editsJson}
@@ -920,11 +937,11 @@ export default function ShareRoute() {
               cta={firstCta}
               onCtaClick={() => tracking.reportCtaClick()}
               onTimeUpdate={(ms) => setCurrentMs(ms)}
-              className="h-full w-full"
+              className="h-full w-full rounded-none sm:rounded-xl"
             />
           </div>
 
-          <div className="flex shrink-0 flex-col gap-3 sm:flex-row sm:items-start">
+          <div className="flex shrink-0 flex-col gap-3 px-4 pb-4 sm:flex-row sm:items-start sm:px-0 sm:pb-0">
             <div className="min-w-0 flex-1">
               {showTitleSkeleton ? (
                 <Skeleton
@@ -999,14 +1016,11 @@ export default function ShareRoute() {
         </div>
       </div>
 
-      <aside className="flex min-h-[420px] w-full shrink-0 flex-col border-t border-border bg-background lg:min-h-0 lg:w-[380px] lg:border-s lg:border-t-0">
-        <Tabs defaultValue="agent" className="flex h-full flex-col">
+      <aside className="flex min-h-[420px] w-full min-w-0 shrink-0 flex-col border-t border-border bg-background lg:min-h-0 lg:w-[380px] lg:border-s lg:border-t-0">
+        <Tabs defaultValue="comments" className="flex h-full flex-col">
           <TabsList className="mx-3 mt-3 grid w-auto grid-cols-4">
-            <TabsTrigger value="agent" className="text-xs">
-              {t("sharePage.agent")}
-            </TabsTrigger>
             <TabsTrigger value="comments" className="text-xs gap-1">
-              {t("sharePage.comments")}
+              {t("recordingPage.activity")}
               {comments.length > 0 ? (
                 <span className="ms-0.5 rounded-full bg-accent px-1.5 text-[10px] tabular-nums">
                   {comments.length}
@@ -1016,6 +1030,9 @@ export default function ShareRoute() {
             <TabsTrigger value="transcript" className="text-xs">
               {t("sharePage.transcript")}
             </TabsTrigger>
+            <TabsTrigger value="agent" className="text-xs">
+              {t("sharePage.agent")}
+            </TabsTrigger>
             <TabsTrigger value="insights" className="text-xs">
               {t("sharePage.insights")}
             </TabsTrigger>
@@ -1070,7 +1087,12 @@ export default function ShareRoute() {
               enableComments={recording.enableComments}
               onSeek={(ms) => playerRef.current?.seek(ms)}
               onUnauthenticated={requireSignIn}
-              queryKey={["public-recording", shareId, password]}
+              queryKey={[
+                "public-recording",
+                shareId,
+                password,
+                agentAccessToken,
+              ]}
               selectComments={(d: any) => d?.data?.comments}
               applyComments={(d: any, next) =>
                 d ? { ...d, data: { ...(d.data ?? {}), comments: next } } : d

package/corpus/templates/clips/app/routes/share.meeting.$meetingId.tsx

@@ -1,8 +1,6 @@
 import { PoweredByBadge, appPath, useT } from "@agent-native/core/client";
 import { getRequestUserEmail } from "@agent-native/core/server";
 import { resolveAccess } from "@agent-native/core/sharing";
-import { Button } from "@agent-native/toolkit/ui/button";
-import { Spinner } from "@agent-native/toolkit/ui/spinner";
 import {
   IconCalendar,
   IconExternalLink,
@@ -11,13 +9,16 @@ import {
   IconWand,
 } from "@tabler/icons-react";
 import { and, eq, isNull } from "drizzle-orm";
+import { useEffect, useRef } from "react";
 import type { LoaderFunctionArgs, MetaFunction } from "react-router";
-import { useLoaderData } from "react-router";
+import { useLoaderData, useRevalidator } from "react-router";
 
 import {
   AttendeeStack,
   type AttendeeStackParticipant,
 } from "@/components/meetings/attendee-stack";
+import { Button } from "@/components/ui/button";
+import { Spinner } from "@/components/ui/spinner";
 import enMessages from "@/i18n/en-US";
 
 import { getDb, schema } from "../../server/db";
@@ -39,19 +40,20 @@ interface Bullet {
   text: string;
 }
 
-type LoaderData =
-  | {
-      meeting: {
-        id: string;
-        title: string;
-        scheduledStart: string | null;
-        summaryMd: string;
-        bullets: Bullet[];
-        participants: Participant[];
-        actionItems: ActionItem[];
-      };
-    }
-  | { meeting: null };
+interface ShareMeetingData {
+  id: string;
+  title: string;
+  scheduledStart: string | null;
+  summaryMd: string;
+  bullets: Bullet[];
+  participants: Participant[];
+  actionItems: ActionItem[];
+  actualStart: string | null;
+  actualEnd: string | null;
+  transcriptStatus: string | null;
+}
+
+type LoaderData = { meeting: ShareMeetingData } | { meeting: null };
 
 export async function loader({
   params,
@@ -67,6 +69,9 @@ export async function loader({
       visibility: schema.meetings.visibility,
       summaryMd: schema.meetings.summaryMd,
       bulletsJson: schema.meetings.bulletsJson,
+      actualStart: schema.meetings.actualStart,
+      actualEnd: schema.meetings.actualEnd,
+      transcriptStatus: schema.meetings.transcriptStatus,
     })
     .from(schema.meetings)
     .where(and(eq(schema.meetings.id, id), isNull(schema.meetings.trashedAt)))
@@ -115,6 +120,9 @@ export async function loader({
       bullets,
       participants,
       actionItems,
+      actualStart: row.actualStart,
+      actualEnd: row.actualEnd,
+      transcriptStatus: row.transcriptStatus,
     },
   };
 }
@@ -158,9 +166,56 @@ function formatDateTime(iso?: string | null): string {
   }
 }
 
+const REVALIDATE_INTERVAL_MS = 5_000;
+const REVALIDATE_MAX_DURATION_MS = 30 * 60 * 1000;
+
+/**
+ * Silent client-side revalidation while a meeting is still live or its notes
+ * haven't landed yet — the loader is SSR-only otherwise (M9), so a share link
+ * opened mid-meeting would never update without a manual reload. Polls the
+ * same access-checked loader (via useRevalidator, not a new endpoint) every
+ * 5s and stops once notes arrive or after 30 minutes.
+ */
+function useMeetingShareRevalidation(meeting: ShareMeetingData | null) {
+  const revalidator = useRevalidator();
+  const startedAtRef = useRef<number | null>(null);
+
+  const isLive = !!meeting && !!meeting.actualStart && !meeting.actualEnd;
+  const transcriptPending =
+    meeting?.transcriptStatus === "in_progress" ||
+    meeting?.transcriptStatus === "pending";
+  const notesAbsentWhileReady =
+    !!meeting &&
+    meeting.transcriptStatus === "ready" &&
+    !meeting.summaryMd &&
+    meeting.bullets.length === 0 &&
+    meeting.actionItems.length === 0;
+  const shouldPoll = isLive || transcriptPending || notesAbsentWhileReady;
+
+  useEffect(() => {
+    if (!shouldPoll) {
+      startedAtRef.current = null;
+      return;
+    }
+    if (startedAtRef.current == null) startedAtRef.current = Date.now();
+    const interval = window.setInterval(() => {
+      if (
+        Date.now() - (startedAtRef.current ?? Date.now()) >
+        REVALIDATE_MAX_DURATION_MS
+      ) {
+        window.clearInterval(interval);
+        return;
+      }
+      if (revalidator.state === "idle") revalidator.revalidate();
+    }, REVALIDATE_INTERVAL_MS);
+    return () => window.clearInterval(interval);
+  }, [shouldPoll, revalidator]);
+}
+
 export default function ShareMeetingRoute() {
   const t = useT();
   const data = useLoaderData<LoaderData>();
+  useMeetingShareRevalidation(data.meeting);
 
   if (!data.meeting) {
     return (

package/corpus/templates/clips/changelog/2026-07-05-mobile-clip-pages-use-a-tighter-viewer-layout-with-inline-ac.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-05
+---
+
+Mobile clip pages use a tighter viewer layout with inline activity and a reliable preparing overlay.