@agent-native/core 0.161.14 → 0.161.17

package/corpus/README.md

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

package/corpus/templates/chat/vitest.config.ts

@@ -1,9 +1,14 @@
-import baseConfig from "@agent-native/core/vitest-config";
-import { mergeConfig } from "vitest/config";
+import path from "node:path";
 
-import viteConfig from "./vite.config";
+import { defineConfig } from "vitest/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);
+// Keep tests independent from vite.config.ts: the production config starts
+// Nitro/Vite watchers and evaluates browser-targeted CommonJS SSR modules.
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./app"),
+      "@shared": path.resolve(__dirname, "./shared"),
+    },
+  },
+});

package/corpus/templates/clips/app/hooks/use-recording-leave-guard.ts

@@ -0,0 +1,70 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useBlocker } from "react-router";
+
+/**
+ * Blocks in-app route navigation while `hasRecordingAtRisk()` is true, using
+ * React Router's `useBlocker` — the same check the recorder's `beforeunload`
+ * handler already uses for tab close/reload. Without this, an in-app link
+ * (e.g. Library) unmounts the recorder route with no warning at all, since
+ * the browser never fires `beforeunload` for client-side navigation.
+ *
+ * Exposes a tiny state machine for a confirm dialog rather than a boolean,
+ * because confirming has to navigate away only after the dialog has actually
+ * finished closing — see the `onCloseAutoFocus` deferral below.
+ */
+export function useRecordingLeaveGuard(hasRecordingAtRisk: () => boolean) {
+  const blocker = useBlocker(
+    useCallback(
+      ({ currentLocation, nextLocation }) =>
+        currentLocation.pathname !== nextLocation.pathname &&
+        hasRecordingAtRisk(),
+      [hasRecordingAtRisk],
+    ),
+  );
+
+  const [leavePromptOpen, setLeavePromptOpen] = useState(false);
+  // See delete-recording-menu.tsx's `deletedWhileOpenRef`: navigating away
+  // while Radix is still tearing down the AlertDialog portal can leave its
+  // body pointer-events lock behind. Close the dialog first and defer
+  // `blocker.proceed()` to `onCloseAutoFocus`, once Radix has actually
+  // finished closing it, instead of calling it straight from the click
+  // handler.
+  const proceedBlockerRef = useRef<() => void>(() => {});
+  proceedBlockerRef.current =
+    blocker.state === "blocked" ? blocker.proceed : () => {};
+  const leaveConfirmedRef = useRef(false);
+
+  useEffect(() => {
+    if (blocker.state === "blocked") setLeavePromptOpen(true);
+  }, [blocker.state]);
+
+  const confirmLeave = useCallback(() => {
+    leaveConfirmedRef.current = true;
+    setLeavePromptOpen(false);
+  }, []);
+
+  const onDialogOpenChange = useCallback(
+    (open: boolean) => {
+      if (open) return;
+      setLeavePromptOpen(false);
+      if (!leaveConfirmedRef.current && blocker.state === "blocked") {
+        blocker.reset();
+      }
+    },
+    [blocker],
+  );
+
+  const onCloseAutoFocus = useCallback((event: { preventDefault(): void }) => {
+    if (!leaveConfirmedRef.current) return;
+    leaveConfirmedRef.current = false;
+    event.preventDefault();
+    setTimeout(() => proceedBlockerRef.current(), 0);
+  }, []);
+
+  return {
+    leavePromptOpen,
+    onDialogOpenChange,
+    onCloseAutoFocus,
+    confirmLeave,
+  };
+}

package/corpus/templates/clips/app/i18n/en-US.ts

@@ -1413,6 +1413,10 @@ All notable user-facing changes to Clips are documented here. Open it any time f
       "Connect storage on the next screen: Builder.io (free tier storage + AI) or S3-compatible storage. Clips will finish saving it.",
     connectStorageToRetryLoom:
       "Connect storage on the next screen: Builder.io (free tier storage + AI) or S3-compatible storage. Clips will retry the import.",
+    leaveConfirmTitle: "Leave and discard this recording?",
+    leaveConfirmDescription:
+      "Your in-progress recording hasn't finished saving. Leaving this page now will discard it.",
+    leaveAndDiscard: "Leave and discard",
   },
   importRoute: {
     pageTitle: "Import Loom — Clips",

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

@@ -35,6 +35,7 @@ import { Link, useLocation, useNavigate } from "react-router";
 
 import { Skeleton } from "@/components/ui/skeleton";
 import { useDesktopPromo } from "@/hooks/use-desktop-promo";
+import { useRecordingLeaveGuard } from "@/hooks/use-recording-leave-guard";
 import {
   fetchVideoStorageStatus,
   useVideoStorageStatus,
@@ -2518,6 +2519,22 @@ export default function RecordRoute() {
     };
   }, [extensionCapture, stopLiveTranscription]);
 
+  // In-app navigation (e.g. a Library link) unmounts this route the same way
+  // a tab close does, but the browser never fires `beforeunload` for it — so
+  // without this, the cleanup effect above ran `releaseCapture()`
+  // unconditionally and silently killed an at-risk recording. Route every
+  // in-app navigation attempt through the same `hasRecordingAtRisk()` check
+  // `warnBeforeDiscard` uses, so both exits are gated by one check instead of
+  // two divergent ones.
+  const {
+    leavePromptOpen,
+    onDialogOpenChange,
+    onCloseAutoFocus,
+    confirmLeave,
+  } = useRecordingLeaveGuard(
+    useCallback(() => !!engineRef.current?.hasRecordingAtRisk(), []),
+  );
+
   // -------------------------------------------------------------------------
   // Render.
   // -------------------------------------------------------------------------
@@ -2740,6 +2757,31 @@ export default function RecordRoute() {
         </AlertDialogContent>
       </AlertDialog>
 
+      <AlertDialog open={leavePromptOpen} onOpenChange={onDialogOpenChange}>
+        <AlertDialogContent onCloseAutoFocus={onCloseAutoFocus}>
+          <AlertDialogHeader>
+            <AlertDialogTitle>
+              {t("recordRoute.leaveConfirmTitle")}
+            </AlertDialogTitle>
+            <AlertDialogDescription>
+              {t("recordRoute.leaveConfirmDescription")}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>{t("common.cancel")}</AlertDialogCancel>
+            <AlertDialogAction
+              onClick={(event) => {
+                event.preventDefault();
+                confirmLeave();
+              }}
+              className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+            >
+              {t("recordRoute.leaveAndDiscard")}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+
       {/* Uploading overlay (also covers the compressing pass which can run
           for several minutes on long recordings — without a distinct copy
           users wonder if the app froze). */}

package/corpus/templates/clips/changelog/2026-08-18-clips-now-recovers-interrupted-uploads-and-reliably-restarts.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-18
+---
+
+Clips now recovers interrupted uploads and reliably restarts after installing desktop updates.

package/corpus/templates/clips/changelog/2026-08-18-meeting-notifications-no-longer-show-decorative-left-side-lines.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-18
+---
+
+Meeting notifications no longer show decorative left-side lines.

package/corpus/templates/clips/desktop/src/lib/updater.ts

@@ -1,7 +1,10 @@
-import { relaunch } from "@tauri-apps/plugin-process";
+import { invoke } from "@tauri-apps/api/core";
+import { exit, relaunch } from "@tauri-apps/plugin-process";
 import { check, Update } from "@tauri-apps/plugin-updater";
 import { useEffect, useState } from "react";
 
+import { isMacPlatform } from "./platform";
+
 declare const __CLIPS_DESKTOP_LOCAL_BUILD__: boolean;
 
 export type UpdateStatus =
@@ -166,9 +169,26 @@ export async function installAndRestart(): Promise<void> {
   // bundle no longer matches the running process as short as possible — the
   // process is torn down by `relaunch()` right after, so capture never runs
   // against a swapped-out bundle.
+  const restartBundlePath = await invoke<string>("restart_bundle_path").catch(
+    (err) => {
+      console.error("[clips-updater] restart target lookup failed:", err);
+      return null;
+    },
+  );
   if (pendingUpdate) {
     await pendingUpdate.install();
   }
+  if (isMacPlatform() && restartBundlePath) {
+    try {
+      await invoke("schedule_restart_after_exit", {
+        bundlePath: restartBundlePath,
+      });
+      await exit(0);
+      return;
+    } catch (err) {
+      console.error("[clips-updater] macOS restart handoff failed:", err);
+    }
+  }
   await relaunch();
 }
 

package/corpus/templates/clips/desktop/src/overlays/meeting-notification.tsx

@@ -386,7 +386,6 @@ export function MeetingNotification() {
     return <div className="meeting-notification-root" />;
   }
 
-  const isCalendar = data.type === "calendar";
   const hasJoin = Boolean(data.joinUrl);
   const provider = detectMeetingJoinProvider(data.joinUrl, data.platform);
   const providerName = joinProviderLabel(provider);
@@ -404,9 +403,6 @@ export function MeetingNotification() {
         onMouseEnter={() => setDomHovered(true)}
         onMouseLeave={() => setDomHovered(false)}
       >
-        <div
-          className={`meeting-notification-bar ${isCalendar ? "meeting-notification-bar-calendar" : "meeting-notification-bar-adhoc"}`}
-        />
         <div className="meeting-notification-content">
           <div className="meeting-notification-title">{data.title}</div>
           <div className="meeting-notification-subtitle">{data.subtitle}</div>

package/corpus/templates/clips/desktop/src/styles.css

@@ -5414,24 +5414,6 @@ body[data-clips-route="recording-pill"] #root {
   max-width: 440px;
 }
 
-.meeting-notification-bar {
-  width: 3px;
-  height: 36px;
-  border-radius: 999px;
-  flex-shrink: 0;
-}
-
-.meeting-notification-bar-calendar {
-  background: #7dd3fc;
-}
-
-.meeting-notification-bar-adhoc {
-  background: transparent;
-  border-left: 3px dashed #a3a3a3;
-  width: 3px;
-  border-radius: 0;
-}
-
 .meeting-notification-content {
   flex: 1;
   min-width: 0;

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

@@ -52,7 +52,7 @@ use state::{
 };
 use util::{
     configure_overlay_behavior, is_recording_active, present_interactive_window,
-    set_capture_excluded,
+    restart_bundle_path, schedule_restart_after_exit, set_capture_excluded,
 };
 
 // Embedded fallback icon — a tiny 16x16 solid purple PNG so the binary always
@@ -248,6 +248,8 @@ pub fn run() {
             // persistent log file (production debugging)
             logfile::frontend_log,
             logfile::open_logs,
+            restart_bundle_path,
+            schedule_restart_after_exit,
         ])
         .plugin(tauri_plugin_shell::init())
         .plugin(tauri_plugin_deep_link::init())

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

@@ -4055,7 +4055,11 @@ fn recording_file_has_bytes(path: &Path) -> bool {
 }
 
 fn remove_empty_recording_artifacts(session: &NativeFullscreenSession) {
-    for path in session.segments.iter().chain(std::iter::once(&session.path)) {
+    for path in session
+        .segments
+        .iter()
+        .chain(std::iter::once(&session.path))
+    {
         if !path.exists() {
             continue;
         }
@@ -4495,8 +4499,7 @@ fn write_bytes_atomically(path: &Path, data: &[u8], label: &str) -> Result<(), S
         .and_then(|value| value.to_str())
         .unwrap_or("recording");
     let temporary = path.with_file_name(format!(".{file_name}.tmp"));
-    std::fs::write(&temporary, data)
-        .map_err(|error| format!("{label} write failed: {error}"))?;
+    std::fs::write(&temporary, data).map_err(|error| format!("{label} write failed: {error}"))?;
     if let Err(error) = std::fs::rename(&temporary, path) {
         let _ = std::fs::remove_file(&temporary);
         return Err(format!("{label} finalize failed: {error}"));

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

@@ -1,3 +1,9 @@
+use std::{
+    ffi::OsString,
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+};
+
 use tauri::{AppHandle, Emitter, Manager, WebviewUrl, WebviewWindow, WebviewWindowBuilder};
 
 use crate::dlog;
@@ -505,6 +511,78 @@ pub fn frontmost_bundle_id() -> Option<String> {
     None
 }
 
+fn bundle_path_from_executable_path(executable_path: &Path) -> Option<PathBuf> {
+    let macos_dir = executable_path.parent()?;
+    if macos_dir.file_name()?.to_str()? != "MacOS" {
+        return None;
+    }
+    let contents_dir = macos_dir.parent()?;
+    let bundle_path = contents_dir.parent()?;
+    Some(bundle_path.to_path_buf())
+}
+
+#[tauri::command]
+pub fn restart_bundle_path() -> Result<String, String> {
+    let executable_path = std::env::current_exe().map_err(|err| format!("current_exe: {err}"))?;
+    #[cfg(target_os = "macos")]
+    let bundle_path = bundle_path_from_executable_path(&executable_path).ok_or_else(|| {
+        format!(
+            "could not derive macOS bundle path from {}",
+            executable_path.display()
+        )
+    })?;
+    #[cfg(not(target_os = "macos"))]
+    let bundle_path = executable_path;
+    Ok(bundle_path.to_string_lossy().into_owned())
+}
+
+#[cfg(target_os = "macos")]
+fn spawn_macos_restart_helper(bundle_path: &Path, args: &[OsString]) -> Result<(), String> {
+    let parent_pid = std::process::id().to_string();
+    let mut command = Command::new("/bin/sh");
+    command
+        .arg("-c")
+        .arg(
+            r#"
+parent_pid="$1"
+bundle_path="$2"
+shift 2
+while kill -0 "$parent_pid" >/dev/null 2>&1; do
+  sleep 0.1
+done
+if [ "$#" -gt 0 ]; then
+  exec /usr/bin/open -n "$bundle_path" --args "$@"
+else
+  exec /usr/bin/open -n "$bundle_path"
+fi
+"#,
+        )
+        .arg("clips-restart-helper")
+        .arg(parent_pid)
+        .arg(bundle_path)
+        .args(args.iter().skip(1))
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null());
+
+    command
+        .spawn()
+        .map_err(|err| format!("spawn restart helper: {err}"))?;
+    Ok(())
+}
+
+#[cfg(not(target_os = "macos"))]
+fn spawn_macos_restart_helper(_bundle_path: &Path, _args: &[OsString]) -> Result<(), String> {
+    Err("macOS restart helper is unavailable on this platform".to_string())
+}
+
+#[tauri::command]
+pub fn schedule_restart_after_exit(bundle_path: String) -> Result<(), String> {
+    let bundle_path = PathBuf::from(bundle_path);
+    let args: Vec<OsString> = std::env::args_os().collect();
+    spawn_macos_restart_helper(&bundle_path, &args)
+}
+
 pub fn set_dictation_active(app: &AppHandle, active: bool) {
     if let Some(state) = app.try_state::<DictationActive>() {
         if let Ok(mut g) = state.0.lock() {
@@ -537,3 +615,23 @@ pub fn hide_voice_wake_popover(app: &AppHandle) {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::bundle_path_from_executable_path;
+    use std::path::Path;
+
+    #[test]
+    fn derives_macos_bundle_path_from_app_executable() {
+        let executable = Path::new("/Applications/Clips.app/Contents/MacOS/Clips");
+        let bundle =
+            bundle_path_from_executable_path(executable).expect("expected macOS bundle path");
+        assert_eq!(bundle, Path::new("/Applications/Clips.app"));
+    }
+
+    #[test]
+    fn rejects_non_bundle_executable_paths() {
+        let executable = Path::new("/Users/steve/dev/Clips");
+        assert!(bundle_path_from_executable_path(executable).is_none());
+    }
+}

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/reset-chunks.post.ts

@@ -174,6 +174,14 @@ export default defineEventHandler(async (event: H3Event) => {
     uploadGenerationId?: string;
     useGenerationFence?: boolean;
   } | null;
+  const requestedStreamingMimeType =
+    body?.requestStreaming === true
+      ? normalizeVideoMimeType(body.mimeType)
+      : null;
+  if (body?.requestStreaming === true && !requestedStreamingMimeType) {
+    setResponseStatus(event, 400);
+    return { error: "A supported video mimeType is required for retry" };
+  }
   const recoveryEnabled = await isFeatureFlagEnabled(UPLOAD_RETRY_RESUME_FLAG, {
     userEmail: ownerEmail,
     userKey: ownerEmail,
@@ -353,6 +361,7 @@ export default defineEventHandler(async (event: H3Event) => {
       if (claimed) cleanupClaim = candidate;
     }
 
+    let resumableCleanupFailed = false;
     if (discardedResumableSession) {
       if (cleanupClaim) {
         const cleaned = await abortResumableUploadSession(
@@ -360,21 +369,34 @@ export default defineEventHandler(async (event: H3Event) => {
           { label: `reset-${recordingId}` },
         );
         if (!cleaned) {
-          setResponseStatus(event, 502);
-          return {
-            error:
-              "The previous recording upload could not be cleaned up. Retry the upload restart.",
-          };
-        }
-        const released = await compareAndSetAppState(
-          cleanupStateKey,
-          cleanupClaim as unknown as Record<string, unknown>,
-          null,
-        );
-        if (!released) {
+          if (!allowsSqlRecordingChunkScratch()) {
+            setResponseStatus(event, 502);
+            return {
+              error:
+                "The previous recording upload could not be cleaned up. Retry the upload restart.",
+            };
+          }
+          // The provider-side session may remain orphaned when abort fails,
+          // but local buffered scratch is a complete recovery path for the
+          // saved file. Keep the cleanup claim for a later retry, remove the
+          // stale local session handle, and force the new chunks through the
+          // buffered handler instead of returning the same 502 repeatedly.
           console.warn(
-            `[reset-chunks-${recordingId}] cleanup claim changed while releasing it`,
+            `[reset-chunks-${recordingId}] provider cleanup failed; using buffered retry and retaining cleanup claim`,
           );
+          resumableCleanupFailed = true;
+        }
+        if (!resumableCleanupFailed) {
+          const released = await compareAndSetAppState(
+            cleanupStateKey,
+            cleanupClaim as unknown as Record<string, unknown>,
+            null,
+          );
+          if (!released) {
+            console.warn(
+              `[reset-chunks-${recordingId}] cleanup claim changed while releasing it`,
+            );
+          }
         }
       }
     }
@@ -385,22 +407,34 @@ export default defineEventHandler(async (event: H3Event) => {
     );
     // Clear any stale resumable session so a buffered retry does not
     // accidentally route through handleResumableChunk with stale offsets.
-    if (!discardedResumableSession || cleanupClaim) {
-      await deleteResumableSession(recordingId, discardedGenerationId).catch(
-        () => {},
-      );
+    if (!discardedResumableSession || cleanupClaim || resumableCleanupFailed) {
+      try {
+        await deleteResumableSession(recordingId, discardedGenerationId);
+      } catch (error) {
+        console.warn(
+          `[reset-chunks-${recordingId}] local resumable session cleanup failed`,
+          error,
+        );
+        setResponseStatus(event, 502);
+        return {
+          error:
+            "The previous recording upload could not be reset locally. Retry the upload restart.",
+        };
+      }
     }
 
     let uploadMode: UploadMode = "buffered";
     let compensateStartedSession: (() => Promise<void>) | null = null;
-    if (body?.requestStreaming === true) {
-      const mimeType = normalizeVideoMimeType(body.mimeType);
+    const bufferedFallbackAvailable = allowsSqlRecordingChunkScratch();
+    const shouldRetryStreaming =
+      body?.requestStreaming === true && !resumableCleanupFailed;
+    if (shouldRetryStreaming) {
+      const mimeType = requestedStreamingMimeType;
       if (!mimeType) {
         setResponseStatus(event, 400);
         return { error: "A supported video mimeType is required for retry" };
       }
 
-      const bufferedFallbackAvailable = allowsSqlRecordingChunkScratch();
       const uploadProvider = await getActiveFileUploadProviderForRequest();
       if (
         shouldEnableStreamingUpload({

package/corpus/templates/design/app/global.css

@@ -7,6 +7,12 @@
 
 @source "./**/*.{ts,tsx}";
 
+/* Keep agent context available to the Design agent without making the
+ * composer carry implementation details as visible chips. */
+[data-design-app] .agent-composer-context-row {
+  display: none;
+}
+
 :root {
   --background: 0 0% 100%;
   --foreground: 0 0% 10%;

package/corpus/templates/design/app/root.tsx

@@ -70,7 +70,7 @@ const LOCALE_INIT_SCRIPT = getLocaleInitScript();
 
 export function Layout({ children }: { children: React.ReactNode }) {
   return (
-    <html lang="en" suppressHydrationWarning>
+    <html lang="en" data-design-app suppressHydrationWarning>
       <head>
         <meta charSet="utf-8" />
         <meta

package/corpus/templates/design/changelog/2026-08-18-design-chat-context-stays-out-of-the-composer.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-18
+---
+
+Design chat keeps context out of the composer and uses shorter completion summaries.

package/corpus/templates/design/server/plugins/agent-chat.ts

@@ -65,6 +65,8 @@ export default createAgentChatPlugin({
   resolveOrgId: async (event) => (await getOrgContext(event)).orgId,
   systemPrompt: `You are an AI prototyping assistant. You create and edit designs, files, design systems, variants, exports, sharing, and connected repository context through actions and shared application state.
 
+Final responses should be concise and operational. Lead with what changed or what is needed. For ordinary design actions, use 1-3 short sentences or at most 3 flat bullets. Do not narrate your process, repeat the user's request, paste HTML or tool results, or write an essay. Mention screenshots and audits only as brief completion evidence. Expand only when the user explicitly asks for an explanation or detailed critique.
+
 When a user message begins with [Reprompt selection], the design must remain unchanged until the user accepts a preview. Call propose-node-rewrite with the exact repromptId, target, and baseVersionHash from the message. Never call edit-design, update-design, update-file, generate-design, apply-visual-edit, or any other content-writing action for that turn. The proposal action stores preview state only; the frontend-only resolve-node-rewrite action persists a chosen variant after the user presses Accept.
 
 When a user message begins with [Selection question], answer about the captured element and selected subtree without changing the design. You may use read-only actions when more context is needed, but do not call any content-writing action. If the user actually intended an edit, explain that they can choose Preview change from the composer mode menu and resend.

package/corpus/templates/slides/app/root.tsx

@@ -66,6 +66,26 @@ const BARE_ROUTES = new Set(["/slide"]);
 /** Route prefixes that render without the app shell */
 const BARE_PREFIXES = ["/share/", "/p/"];
 
+/**
+ * Routes that serve deck content to any visitor — owner, teammate, or an
+ * anonymous recipient of a shared link — rather than an app-management
+ * surface. `/deck/:id` renders the full editor shell (so it's not "bare"
+ * above: viewers still get chrome, just read-only), but it must never force
+ * sign-in or gate on first-run onboarding, or a shared link flashes the deck
+ * and then buries it under "create your first deck" (the onboarding gate has
+ * no route awareness of its own — see `sessionBypass` below). `/present` is
+ * the full-screen presentation view and `/slide` is the agent-embed preview;
+ * both are shown to viewers the same way.
+ */
+export function isShareableContentPath(pathname: string): boolean {
+  return (
+    BARE_ROUTES.has(pathname) ||
+    BARE_PREFIXES.some((p) => pathname.startsWith(p)) ||
+    pathname.startsWith("/deck/") ||
+    pathname.endsWith("/present")
+  );
+}
+
 export const links: LinksFunction = () => [
   { rel: "stylesheet", href: stylesheet },
 ];
@@ -311,6 +331,7 @@ export default function Root() {
         queryClient={queryClient}
         defaultTheme="dark"
         i18n={{ catalog: i18nCatalog }}
+        sessionBypass={isShareableContentPath(location.pathname)}
       >
         <AppContent />
       </AppProviders>

package/corpus/templates/slides/server/handlers/decks.ts

@@ -1,7 +1,7 @@
 import { recordChange } from "@agent-native/core/server/poll";
 import { defineEventHandler, setResponseStatus, createEventStream } from "h3";
 
-import { resolveSlidesRequestAuthContext } from "./request-auth-context.js";
+import { resolveSlidesRequestAuth } from "./request-auth-context.js";
 
 // --- SSE for change notifications ---
 type SSEPush = (data: string) => void;
@@ -91,8 +91,12 @@ export function notifyClients(
 // callers can't tail the stream. (The agent path runs server-side and is
 // not affected.)
 export const deckEvents = defineEventHandler(async (event) => {
-  const session = await resolveSlidesRequestAuthContext(event);
-  if (!session.email) {
+  const auth = await resolveSlidesRequestAuth(event);
+  if (!auth.ok) {
+    setResponseStatus(event, auth.statusCode);
+    return { error: auth.error };
+  }
+  if (!auth.context.email) {
     setResponseStatus(event, 401);
     return { error: "Unauthorized" };
   }