@agent-native/core 0.175.2-nightly-20260826165737 → 0.175.3

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8618
+- template files: 8620

package/corpus/templates/clips/app/components/player/comments-panel.tsx

@@ -681,7 +681,7 @@ function CommentComposer({
           className={cn(
             "resize-none border-0 bg-background text-sm",
             isSharePresentation
-              ? "min-h-10 flex-1 border-0 p-0 shadow-none focus-visible:ring-0 focus-visible:ring-offset-0"
+              ? "min-h-10 flex-1 border-0 px-3 py-2 shadow-none focus-visible:ring-0 focus-visible:ring-offset-0"
               : "min-h-[60px]",
           )}
           onKeyDown={(e) => {

package/corpus/templates/clips/desktop/src/app.tsx

@@ -408,6 +408,7 @@ const CAM_ON_KEY = "clips:camera-on";
 const MIC_ON_KEY = "clips:mic-on";
 const SYSTEM_AUDIO_KEY = "clips:system-audio";
 const READINESS_REVIEWED_KEY = "clips:readiness-reviewed";
+const VIDEO_STORAGE_CONFIGURED_KEY = "clips:video-storage-configured";
 // The docs section for the tray's rolling buffer, published under the same
 // Rewind name the settings tab uses.
 const REWIND_DOCS_URL =
@@ -431,6 +432,10 @@ function stopRestartHandoff(handoff: RestartHandoff): void {
   [handoff.displayStream, handoff.audioStream].forEach((stream) =>
     stream?.getTracks().forEach((track) => track.stop()),
   );
+  // Every creation site attaches its own catch, so this teardown promise
+  // can't reject — this guard keeps a handoff abandoned mid-restart from
+  // ever surfacing an unhandled rejection if a future site forgets.
+  void handoff.transcriptionTornDown?.catch(() => {});
 }
 
 type FetchInput = Parameters<typeof fetch>[0];
@@ -490,64 +495,77 @@ async function fetchWithAbortTimeout(
 
 async function hasConfiguredVideoStorage(
   serverUrl: string,
+  account: string | null,
 ): Promise<VideoStorageProbe> {
   const base = serverUrl.replace(/\/+$/, "");
 
-  // Track whether any endpoint gave a definitive answer. If both checks throw
-  // or return non-OK/unparseable responses, we can't tell and return "unknown".
-  let sawDefinitiveAnswer = false;
-
-  try {
-    const uploadStatus = await fetchWithAbortTimeout(
-      `${base}/_agent-native/file-upload/status`,
-      {
-        credentials: "include",
-        cache: "no-store",
-      },
-      VIDEO_STORAGE_PROBE_TIMEOUT_MS,
-    );
-    if (uploadStatus.ok) {
-      const body = (await uploadStatus.json().catch(() => null)) as {
+  // One endpoint's answer: "configured", "missing" (a definitive
+  // not-configured), or "unknown" (threw, non-OK, or unparseable).
+  const probeEndpoint = async (path: string): Promise<VideoStorageProbe> => {
+    try {
+      const res = await fetchWithAbortTimeout(
+        `${base}${path}`,
+        {
+          credentials: "include",
+          cache: "no-store",
+        },
+        VIDEO_STORAGE_PROBE_TIMEOUT_MS,
+      );
+      if (!res.ok) return "unknown";
+      // coercion-ok: an unparseable body maps to the typed "unknown" probe
+      // result, which callers treat as distinct from configured/missing.
+      const body = (await res.json().catch(() => null)) as {
         configured?: boolean;
       } | null;
-      if (body) {
-        sawDefinitiveAnswer = true;
-        if (body.configured) return "configured";
-      }
+      if (!body) return "unknown";
+      return body.configured ? "configured" : "missing";
+    } catch {
+      return "unknown";
     }
-  } catch {
-    // Fall through to the Builder status endpoint.
-  }
+  };
 
-  try {
-    const builderStatus = await fetchWithAbortTimeout(
-      `${base}/_agent-native/builder/status`,
-      {
-        credentials: "include",
-        cache: "no-store",
-      },
-      VIDEO_STORAGE_PROBE_TIMEOUT_MS,
-    );
-    if (builderStatus.ok) {
-      const body = (await builderStatus.json().catch(() => null)) as {
-        configured?: boolean;
-      } | null;
-      if (body) {
-        sawDefinitiveAnswer = true;
-        if (body.configured) return "configured";
-      }
-    }
-  } catch {
-    // Network error or unreachable server — treat as indeterminate below.
+  const probes = [
+    probeEndpoint("/_agent-native/file-upload/status"),
+    probeEndpoint("/_agent-native/builder/status"),
+  ];
+  // The probes run concurrently. "configured" wins as soon as either endpoint
+  // reports it, but "missing" is only declared after both have settled — a
+  // Builder-credits-only user has file-upload configured:false and builder
+  // configured:true and must not be routed to storage setup.
+  let probe: VideoStorageProbe;
+  if ((await Promise.race(probes)) === "configured") {
+    probe = "configured";
+  } else {
+    const results = await Promise.all(probes);
+    probe = results.includes("configured")
+      ? "configured"
+      : results.includes("missing")
+        ? "missing"
+        : "unknown";
   }
-
-  return sawDefinitiveAnswer ? "missing" : "unknown";
+  // Last-known-good cache: seeds the next launch's Start button so it isn't
+  // held behind this round-trip. Only "configured" is ever cached —
+  // "missing"/"unknown" must always re-probe — and only when we know whose
+  // answer it is, so an unauthenticated probe never writes one.
+  if (probe === "configured" && account) {
+    saveBool(videoStorageConfiguredKey(serverUrl, account), true);
+  }
+  return probe;
 }
 
 function authTokenStorageKey(serverUrl: string): string {
   return `${AUTH_TOKEN_KEY}:${originForServer(serverUrl)}`;
 }
 
+// Whether video storage is configured is a fact about one account on one
+// server: both status endpoints answer as the authenticated user. A key any
+// coarser lets one answer enable Start for a server or an account it was never
+// about — including after a sign-out. `account` is null before the session
+// probe settles, which is not an identity, so nothing is cached or seeded then.
+function videoStorageConfiguredKey(serverUrl: string, account: string): string {
+  return `${VIDEO_STORAGE_CONFIGURED_KEY}:${originForServer(serverUrl)}:${account}`;
+}
+
 function loadDesktopAuthToken(serverUrl: string): string {
   return loadString(authTokenStorageKey(serverUrl), "");
 }
@@ -1234,6 +1252,10 @@ export function App({
   const serverHostForSignIn = serverUrl
     .replace(/^https?:\/\//, "")
     .replace(/\/+$/, "");
+  // Seeded from the last-known-good cache so a machine that ever probed
+  // Starts at "checking" and is seeded from the cache only once the signed-in
+  // account is known — the cached answer belongs to one account on one server,
+  // and the seed effect below is what applies it.
   const [videoStorageStatus, setVideoStorageStatus] =
     useState<VideoStorageStatus>("checking");
   const [signedInAs, setSignedInAs] = useState<string | null>(null);
@@ -1295,14 +1317,43 @@ export function App({
     setDesktopAuthContext(serverUrl, loadDesktopAuthToken(serverUrl));
   }, [serverUrl]);
 
+  // Who and where `videoStorageStatus` is an answer about. Every probe captures
+  // this and drops its result if it has since moved on, so an in-flight probe
+  // can never land one account-and-server's answer on another's.
+  const videoStorageIdentity = `${originForServer(serverUrl)}|${signedInAs ?? ""}`;
+  const videoStorageIdentityRef = useRef(videoStorageIdentity);
+  // A change of server or account makes the current answer meaningless, and the
+  // probe below deliberately never downgrades "configured" to "checking", so
+  // without this the previous answer would keep Start enabled against the new
+  // identity until its first probe lands. Re-seed from that identity's own
+  // cache — which is also what applies the cache at launch, once the session
+  // probe has said who is signed in.
+  useEffect(() => {
+    videoStorageIdentityRef.current = videoStorageIdentity;
+    setVideoStorageStatus(
+      signedInAs &&
+        loadBool(videoStorageConfiguredKey(serverUrl, signedInAs), false)
+        ? "configured"
+        : "checking",
+    );
+  }, [videoStorageIdentity, serverUrl, signedInAs]);
+
   const refreshVideoStorageStatus = useCallback(async () => {
     if (authStatus !== "authed" || localRecordingMode !== "off") {
       setVideoStorageStatus("configured");
       return true;
     }
 
-    setVideoStorageStatus((prev) => (prev === "missing" ? prev : "checking"));
-    const probe = await hasConfiguredVideoStorage(serverUrl);
+    // Deliberately no "checking" reset here: the status may already be seeded
+    // from the last-known-good cache or the mount-time warmup probe, and
+    // downgrading "configured" to "checking" would re-disable Start for the
+    // probe's whole round-trip. A definitive probe result below still wins.
+    const probedIdentity = videoStorageIdentity;
+    const probe = await hasConfiguredVideoStorage(serverUrl, signedInAs);
+    // The server or the account moved on while this was in flight: this answer
+    // is about an identity the UI is no longer using, and "configured over
+    // there" is not evidence about what Start would record to now.
+    if (videoStorageIdentityRef.current !== probedIdentity) return false;
     if (probe === "unknown") {
       // The check couldn't be completed (offline/unreachable). Never downgrade
       // an already-connected user to "missing" on an indeterminate result;
@@ -1316,12 +1367,25 @@ export function App({
     }
     setVideoStorageStatus(probe);
     return probe === "configured";
-  }, [authStatus, localRecordingMode, serverUrl]);
+  }, [
+    authStatus,
+    localRecordingMode,
+    serverUrl,
+    signedInAs,
+    videoStorageIdentity,
+  ]);
 
   useEffect(() => {
     void refreshVideoStorageStatus();
   }, [refreshVideoStorageStatus]);
 
+  // There is deliberately no mount-time warmup probe here any more. One used to
+  // run in parallel with checkAuth to overlap the round-trips, but a probe
+  // started before the session settles cannot say which account its answer
+  // belongs to, and applying it anyway is exactly how one account inherited
+  // another's "configured". A returning user is covered by the account-scoped
+  // cache seed above at no round-trip cost; a first launch pays one probe.
+
   useEffect(() => {
     if (
       authStatus !== "authed" ||
@@ -2604,6 +2668,13 @@ export function App({
     };
   }, []);
 
+  // Warm the multi-second SCShareableContent lookup while the popover is
+  // open so a recording start within the cache TTL skips it. Fire-and-forget.
+  useEffect(() => {
+    if (!popoverVisible) return;
+    invoke("native_fullscreen_prefetch_capture_content").catch(() => {});
+  }, [popoverVisible]);
+
   const speechPermissionChecked = useRef(false);
   useEffect(() => {
     if (!popoverVisible || !micOn || speechPermissionChecked.current) return;
@@ -2676,6 +2747,12 @@ export function App({
   // failed). Stop and cancel are terminal transitions on the recorder a
   // restart is already tearing down, so they must not run against it.
   const restartInFlightRef = useRef(false);
+  // The take the recorder last announced, tracked from the same
+  // `clips:recorder-session` event the pill uses for its identity. A stop that
+  // throws has no result to name, so this is the only way its failure event can
+  // say which take it belongs to instead of being applied to whichever card
+  // happens to be open.
+  const sessionRecordingIdRef = useRef<string | null>(null);
   const recordingInFlight = isRecording || recordingFlowActive;
   useLayoutEffect(() => {
     recordingFlowGateRef.current = recordingInFlight;
@@ -3497,6 +3574,8 @@ export function App({
         preAcquiredCameraStream,
         preAcquiredDisplayStream: options?.resumeCapture?.displayStream ?? null,
         preAcquiredAudioStream: options?.resumeCapture?.audioStream ?? null,
+        pendingTranscriptionTeardown:
+          options?.resumeCapture?.transcriptionTornDown ?? null,
         signal: startController.signal,
       });
       // macOS: give WebKit a short window to dispatch getDisplayMedia before
@@ -3771,6 +3850,14 @@ export function App({
         // ignore — best-effort
       });
     };
+    track(
+      listen<{ recordingId?: string | null }>(
+        "clips:recorder-session",
+        (event) => {
+          sessionRecordingIdRef.current = event.payload?.recordingId ?? null;
+        },
+      ),
+    );
     track(
       listen("clips:recorder-stop", async () => {
         if (restartInFlightRef.current) return;
@@ -3797,6 +3884,9 @@ export function App({
 
         let stopFailed = false;
         let stopResult: RecorderStopResult | null = null;
+        // Captured before the await: by the time a slow stop throws, a
+        // replacement take may already have announced itself.
+        const stoppingRecordingId = sessionRecordingIdRef.current;
         try {
           stopResult = await handle.stop();
           if (stopResult.localOnly) {
@@ -3804,6 +3894,15 @@ export function App({
               folderPath: stopResult.localFolder,
               files: stopResult.localFiles ?? [],
             });
+            // A local-only stop has no upload, so nothing else ever publishes
+            // its outcome. Without this the pill's completion card would hold
+            // "finishing up" until its stall timeout — and it must not claim
+            // the file was saved before the export actually returned.
+            emit("clips:native-upload-finished", {
+              recordingId: stopResult.recordingId,
+              ok: true,
+              localFilePath: stopResult.localFiles?.[0]?.path ?? null,
+            }).catch(() => {});
           } else {
             setLastRecordingId(stopResult.recordingId);
             // The browser opens `/r/<id>` (the author's dashboard); what lands
@@ -3814,6 +3913,18 @@ export function App({
         } catch (err) {
           stopFailed = true;
           setRecError(err instanceof Error ? err.message : String(err));
+          // Only when the stop itself threw. Past that point the upload
+          // pipeline owns the completion event and a copy-link failure is not
+          // an upload failure — but a stop that never produced a result is
+          // not a completion, and a local-only take has no other publisher to
+          // correct the card.
+          if (!stopResult) {
+            emit("clips:native-upload-finished", {
+              recordingId: stoppingRecordingId ?? undefined,
+              ok: false,
+              error: err instanceof Error ? err.message : String(err),
+            }).catch(() => {});
+          }
           await loadPendingUploads();
         } finally {
           recordingStopFinalizingRef.current = false;
@@ -3836,8 +3947,19 @@ export function App({
     track(
       listen("clips:recorder-cancel", async () => {
         if (restartInFlightRef.current) return;
+        const cancelDone = recorder.cancel();
+        // Optimistic feedback: bring the popover back and clear the tray's
+        // recording state the moment the cancel is dispatched — the recorder
+        // teardown can take seconds and neither call depends on it. The flow
+        // gate below must NOT be released here: it stays latched until
+        // cancel() resolves so a fast Start can't race the tearing-down
+        // session.
+        if (!cancelled) {
+          invoke("set_recording_state", { active: false }).catch(() => {});
+          invoke("show_popover").catch(() => {});
+        }
         try {
-          await recorder.cancel();
+          await cancelDone;
         } finally {
           if (!cancelled) {
             (
@@ -3849,8 +3971,6 @@ export function App({
             setRecorder(null);
             setRecordingFlowActive(false);
             setBubbleSessionEpoch((epoch) => epoch + 1);
-            invoke("set_recording_state", { active: false }).catch(() => {});
-            invoke("show_popover").catch(() => {});
           }
         }
       }),
@@ -8101,7 +8221,7 @@ function Setup({
       /* A fixed height, not content-driven: the tray window resizes itself to
          match rendered content, so a taller tab would otherwise grow the window
          out from under the user. Tabs scroll inside this frame instead. */
-      className="flex h-[560px] max-h-[calc(100vh-48px)] w-full flex-col overflow-hidden rounded-[14px] bg-background text-foreground"
+      className="flex h-[560px] max-h-screen w-full flex-col overflow-hidden rounded-[14px] bg-background text-foreground"
     >
       <div className="grid min-h-0 flex-1 grid-cols-[176px_minmax(0,1fr)]">
         <nav

package/corpus/templates/clips/desktop/src/lib/pill-completion.ts

@@ -0,0 +1,111 @@
+/**
+ * How the recording pill's completion card reads a `clips:native-upload-finished`
+ * payload.
+ *
+ * The card is fed from three places — the recorder's event, a localStorage
+ * hand-off for a pill that was still mounting, and a Rust-side replay of the
+ * last result — and the pill's window is reused across a restart, so a payload
+ * can arrive for a recording the window has already moved past.
+ */
+
+export type PillDoneStage = "finishing" | "uploading" | "uploaded" | "failed";
+
+export type NativeUploadFinished = {
+  recordingId?: string;
+  ok?: boolean;
+  viewUrl?: string;
+  error?: string | null;
+  localFilePath?: string | null;
+};
+
+export type PillCompletion = {
+  stage: "uploaded" | "failed";
+  savedLocally: boolean;
+  viewUrl: string | null;
+};
+
+/**
+ * The completion state the card should show, or `null` when the payload
+ * belongs to a different recording than the one on screen and must be ignored.
+ *
+ * Identity is checked through `isCompletionForSession`: a late completion from
+ * an earlier take would otherwise repaint the current card with the old clip's
+ * link and status.
+ */
+/**
+ * Whether an upload event belongs to the take the card is showing.
+ *
+ * Shared by the completion and progress paths so one rule governs both. When
+ * both sides name an id and they differ, the event is a leftover from an
+ * earlier take — this window is reused, so that happens. When either side has
+ * no id there is nothing to compare and the event is taken, which is the
+ * contract the pill has always had.
+ */
+export function isCompletionForSession(
+  sessionRecordingId: string | null | undefined,
+  payload: { recordingId?: string },
+): boolean {
+  if (!sessionRecordingId || !payload.recordingId) return true;
+  return payload.recordingId === sessionRecordingId;
+}
+
+export function resolveCompletion(
+  sessionRecordingId: string | null | undefined,
+  payload: NativeUploadFinished,
+): PillCompletion | null {
+  if (!isCompletionForSession(sessionRecordingId, payload)) {
+    return null;
+  }
+  return {
+    // A local-only stop succeeds with no view URL — the file on disk is the
+    // whole result — so success is `ok`, never the presence of a link.
+    stage: payload.ok ? "uploaded" : "failed",
+    savedLocally: Boolean(payload.localFilePath),
+    viewUrl: payload.viewUrl ?? null,
+  };
+}
+
+export type PillCardTone = "pending" | "ok" | "warn";
+
+export type PillCardState = {
+  title: string;
+  /** Sub-line detail, appended after the take's duration. Empty when the
+   * title already says everything there is to say. */
+  detail: string;
+  tone: PillCardTone;
+};
+
+/**
+ * The completion card's headline and tone.
+ *
+ * The card goes up the instant Stop is pressed, before the export or upload
+ * has returned anything, so the headline tracks `stage` rather than asserting
+ * success. A stop that fails must not leave a green check and "Recording
+ * saved" on screen with only a small caption disagreeing — the headline is
+ * what a glance and a screen reader both take away.
+ */
+export function completionCardState(
+  stage: PillDoneStage,
+  session: { hasLink: boolean; savedLocally: boolean },
+): PillCardState {
+  switch (stage) {
+    case "uploaded":
+      return {
+        title: "Recording saved",
+        // With a link the row below already shows it; without one the file on
+        // disk is the only place the take exists, so say where it went.
+        detail: session.hasLink ? "" : "saved on this device",
+        tone: "ok",
+      };
+    case "failed":
+      return {
+        title: "Upload paused",
+        detail: session.savedLocally ? "saved on this device" : "",
+        tone: "warn",
+      };
+    case "uploading":
+      return { title: "Uploading", detail: "", tone: "pending" };
+    case "finishing":
+      return { title: "Finishing up", detail: "", tone: "pending" };
+  }
+}

package/corpus/templates/clips/desktop/src/lib/pill-session.ts

@@ -0,0 +1,34 @@
+/**
+ * What the recording pill does when the recorder flips `clips:toolbar-enabled`.
+ *
+ * The pill's window outlives a single take: a restart reuses it for the
+ * replacement session, and the completion card keeps it open after a stop. So
+ * "enabled" is not simply "show the controls" — it also decides whether the
+ * previous session's card is retired.
+ */
+
+export type PillMode = "recording" | "confirm" | "done";
+
+export type ToolbarEnabledEffect =
+  /** A live session is taking a window still showing the last take's card. */
+  | "adopt-new-session"
+  /** No session owns the pill: snap the segments back to their rest state. */
+  | "reset-to-rest"
+  /** Leave the pill exactly as it is. */
+  | "keep";
+
+export function toolbarEnabledEffect(
+  enabled: boolean,
+  mode: PillMode,
+): ToolbarEnabledEffect {
+  if (enabled) {
+    // A confirm strip is deliberately NOT rescued here. The recorder re-emits
+    // `toolbar-enabled(true)` on every `toolbar-ready` handshake, so resetting
+    // on enable would close a question the user is still reading. Answering a
+    // confirm therefore has to leave confirm mode at the point of the answer.
+    return mode === "done" ? "adopt-new-session" : "keep";
+  }
+  // The completion card owns the window after a stop; disabling the controls
+  // must not wipe it out from under the user.
+  return mode === "done" ? "keep" : "reset-to-rest";
+}