@agent-native/core 0.129.2 → 0.130.0

package/corpus/templates/clips/app/components/player/video-player.tsx

@@ -82,6 +82,8 @@ const VOLATILE_VIDEO_QUERY_PARAMS = new Set([
   "Signature",
 ]);
 
+const PLAY_ATTEMPT_TIMEOUT_MS = 15_000;
+
 function videoSourceIdentity(url: string | undefined): string {
   if (!url) return "";
   try {
@@ -277,6 +279,9 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
     const suppressNextClickRef = useRef(false);
     const playAttemptPendingRef = useRef(false);
     const playAttemptIdRef = useRef(0);
+    const playAttemptTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(
+      null,
+    );
     // Position to restore after `v.load()` resets `currentTime` to 0 while
     // recovering from a media error (see `requestPlay`).
     const resumeAfterReloadMsRef = useRef<number | null>(null);
@@ -322,6 +327,47 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
     const [isPlayPending, setIsPlayPending] = useState(false);
     const [isBuffering, setIsBuffering] = useState(false);
     const [playError, setPlayError] = useState<string | null>(null);
+    const clearPlayAttemptWatchdog = useCallback(() => {
+      if (playAttemptTimeoutRef.current === null) return;
+      clearTimeout(playAttemptTimeoutRef.current);
+      playAttemptTimeoutRef.current = null;
+    }, []);
+    const armPlayAttemptWatchdog = useCallback(
+      (attemptId: number) => {
+        clearPlayAttemptWatchdog();
+        playAttemptTimeoutRef.current = setTimeout(() => {
+          playAttemptTimeoutRef.current = null;
+          if (
+            attemptId !== playAttemptIdRef.current ||
+            !playAttemptPendingRef.current
+          ) {
+            return;
+          }
+
+          playAttemptIdRef.current += 1;
+          playAttemptPendingRef.current = false;
+          videoRef.current?.pause();
+          setIsPlaying(false);
+          setIsPlayPending(false);
+          setIsBuffering(false);
+          setIsPreparing(false);
+          const timeoutError = new Error(
+            `Playback did not start within ${PLAY_ATTEMPT_TIMEOUT_MS}ms`,
+          );
+          reportPlaybackIssue(
+            "play-start-timeout",
+            timeoutError,
+            videoRef.current,
+            {
+              recordingId,
+              autoPlay: !!autoPlay,
+            },
+          );
+          setPlayError("Playback is taking too long to start. Try again.");
+        }, PLAY_ATTEMPT_TIMEOUT_MS);
+      },
+      [autoPlay, clearPlayAttemptWatchdog, recordingId],
+    );
     // MediaRecorder-created WebM files report `video.duration === Infinity`
     // until the browser has actually scrubbed to the end. When that happens
     // the scrubber's percentage math breaks (anything / Infinity = 0) and
@@ -447,13 +493,20 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
         playAttemptPendingRef.current = true;
         setIsPlayPending(true);
         setIsBuffering(true);
+        armPlayAttemptWatchdog(nextId);
       } else {
+        clearPlayAttemptWatchdog();
         setIsPlaying(false);
         setIsBuffering(false);
       }
       setIsPreparing(true);
       setCanPlay(false);
-    }, [mse.mode, activeVideoSrc]);
+    }, [
+      activeVideoSrc,
+      armPlayAttemptWatchdog,
+      clearPlayAttemptWatchdog,
+      mse.mode,
+    ]);
 
     useEffect(() => {
       if (!resolvedVideoSrc) {
@@ -494,12 +547,14 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
 
     useEffect(() => {
       if (!isLoomEmbed) return;
+      clearPlayAttemptWatchdog();
+      playAttemptPendingRef.current = false;
       setCanPlay(true);
       setIsPreparing(false);
       setIsBuffering(false);
       setIsPlayPending(false);
       setPlayError(null);
-    }, [activeVideoSourceIdentity, isLoomEmbed]);
+    }, [activeVideoSourceIdentity, clearPlayAttemptWatchdog, isLoomEmbed]);
 
     // Hide controls after 2s of idle movement.
     const bumpControls = useCallback(() => {
@@ -511,23 +566,28 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
       }, 2000);
     }, [alwaysShowControls]);
 
-    const resolvePlayAttempt = useCallback((attemptId: number) => {
-      if (attemptId !== playAttemptIdRef.current) return;
-      playAttemptPendingRef.current = false;
-      const v = videoRef.current;
-      if (v && !v.paused && !v.ended) {
-        setIsPlaying(true);
-        setHasPlaybackStarted(true);
-      }
-      setCanPlay(true);
-      setIsPlayPending(false);
-      setIsBuffering(false);
-      setIsPreparing(false);
-    }, []);
+    const resolvePlayAttempt = useCallback(
+      (attemptId: number) => {
+        if (attemptId !== playAttemptIdRef.current) return;
+        clearPlayAttemptWatchdog();
+        playAttemptPendingRef.current = false;
+        const v = videoRef.current;
+        if (v && !v.paused && !v.ended) {
+          setIsPlaying(true);
+          setHasPlaybackStarted(true);
+        }
+        setCanPlay(true);
+        setIsPlayPending(false);
+        setIsBuffering(false);
+        setIsPreparing(false);
+      },
+      [clearPlayAttemptWatchdog],
+    );
 
     const rejectPlayAttempt = useCallback(
       (attemptId: number, err: unknown) => {
         if (attemptId !== playAttemptIdRef.current) return;
+        clearPlayAttemptWatchdog();
         playAttemptPendingRef.current = false;
         setIsPlayPending(false);
         setIsBuffering(false);
@@ -547,7 +607,7 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
         });
         setPlayError("Could not start playback. Try again.");
       },
-      [autoPlay, recordingId],
+      [autoPlay, clearPlayAttemptWatchdog, recordingId],
     );
 
     const attachPlayPromise = useCallback(
@@ -592,8 +652,13 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
           v.currentTime > 1e7)
       ) {
         try {
-          v.currentTime = 0;
-          setCurrentMs(0);
+          const initialPlaybackMs = skipExcludedRange(
+            0,
+            excludedRanges,
+            resolvedDurationMs,
+          );
+          v.currentTime = initialPlaybackMs / 1000;
+          setCurrentMs(initialPlaybackMs);
         } catch {
           // If the browser refuses the rewind, continue with the normal play
           // attempt; playback is still better than blocking on a cosmetic seek.
@@ -622,6 +687,7 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
       const attemptId = playAttemptIdRef.current + 1;
       playAttemptIdRef.current = attemptId;
       playAttemptPendingRef.current = true;
+      armPlayAttemptWatchdog(attemptId);
 
       try {
         attachPlayPromise(v.play(), attemptId);
@@ -630,11 +696,14 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
       }
     }, [
       activeVideoSrc,
+      armPlayAttemptWatchdog,
       attachPlayPromise,
       bumpControls,
       currentMs,
+      excludedRanges,
       hasPlaybackStarted,
       rejectPlayAttempt,
+      resolvedDurationMs,
       startMs,
     ]);
 
@@ -653,10 +722,11 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
     const pauseVideo = useCallback(() => {
       playAttemptIdRef.current += 1;
       playAttemptPendingRef.current = false;
+      clearPlayAttemptWatchdog();
       setIsPlayPending(false);
       setIsBuffering(false);
       videoRef.current?.pause();
-    }, []);
+    }, [clearPlayAttemptWatchdog]);
 
     const togglePlayback = useCallback(() => {
       const v = videoRef.current;
@@ -995,11 +1065,12 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
       setLoomStartMs(null);
       playAttemptIdRef.current += 1;
       playAttemptPendingRef.current = false;
+      clearPlayAttemptWatchdog();
       setCanPlay(false);
       setIsPlayPending(false);
       setIsBuffering(false);
       setPlayError(null);
-    }, [activeVideoSourceIdentity, recordingId]);
+    }, [activeVideoSourceIdentity, clearPlayAttemptWatchdog, recordingId]);
 
     useEffect(() => {
       setThumbnailLoadFailed(false);
@@ -1132,6 +1203,13 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
       };
     }, [bumpControls]);
 
+    useEffect(
+      () => () => {
+        clearPlayAttemptWatchdog();
+      },
+      [clearPlayAttemptWatchdog],
+    );
+
     // Keep isPip in sync with the browser's PiP state (React doesn't support
     // PiP events as JSX handlers; wire them via addEventListener instead).
     useEffect(() => {
@@ -1280,13 +1358,6 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
             ref={setVideoNode}
             src={domVideoSrc}
             poster={resolveLocalUrl(thumbnailUrl)}
-            // `crossOrigin` is only needed so the owner's canvas thumbnail
-            // capture isn't tainted. For everyone else (viewers, and the Slack
-            // unfurl embed) it adds nothing — but if the player is ever framed
-            // into a sandboxed/opaque-origin context (Slack double-iframes the
-            // embed), the resulting CORS check on the media bytes fails and the
-            // video won't load. Scope it to owners so embeds load cleanly.
-            crossOrigin={role === "owner" ? "anonymous" : undefined}
             className={cn(
               "w-full h-full",
               cover ? "object-cover" : "object-contain",
@@ -1425,6 +1496,8 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
               onTimeUpdate?.(ms, resolvedDurationMs);
             }}
             onEnded={() => {
+              clearPlayAttemptWatchdog();
+              playAttemptPendingRef.current = false;
               const endedMs =
                 resolvedDurationMs > 0
                   ? resolvedDurationMs
@@ -1442,6 +1515,7 @@ export const VideoPlayer = forwardRef<VideoPlayerHandle, VideoPlayerProps>(
               onEnded?.();
             }}
             onError={(e) => {
+              clearPlayAttemptWatchdog();
               playAttemptPendingRef.current = false;
               setIsPlayPending(false);
 

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

@@ -926,6 +926,7 @@ All notable user-facing changes to Clips are documented here. Open it any time f
     replyingTo: "Replying to",
     commentAt: "Comment at",
     writeReply: "Write a reply...",
+    editComment: "Edit comment",
     commentButton: "Comment",
     composerPlaceholder: "Add a comment…",
     mentionSomeone: "Mention someone",
@@ -1322,7 +1323,7 @@ All notable user-facing changes to Clips are documented here. Open it any time f
     downloadDesktopApp: "Download desktop app",
     technicalDetails: "Technical details",
     whatToCheck: "What to check",
-    downloadRecording: "Download recording",
+    downloadRecording: "Download",
     openRecorderInTab: "Open recorder in tab",
     connectStorageToFinish:
       "Connect storage on the next screen: Builder.io (free tier storage + AI) or S3-compatible storage. Clips will finish saving it.",

package/corpus/templates/clips/app/routes/bug-report.done.tsx

@@ -1,5 +1,13 @@
 import { appBasePath } from "@agent-native/core/client/api-path";
+import { callAction } from "@agent-native/core/client/hooks";
 import { useT } from "@agent-native/core/client/i18n";
+import {
+  BUG_REPORT_AGENT_ACCESS_TTL_SECONDS,
+  BUG_REPORT_POPUP_RESPONSE_HEADERS,
+  bugReportSubmissionTargetOrigins,
+  createBugReportSubmissionMessage,
+  type BugReportAgentLink,
+} from "@shared/bug-report";
 import {
   IconArrowLeft,
   IconCheck,
@@ -16,20 +24,15 @@ export function meta() {
   return [{ title: enMessages.bugReportRoute.donePageTitle }];
 }
 
+export function headers() {
+  return BUG_REPORT_POPUP_RESPONSE_HEADERS;
+}
+
 function absoluteAppUrl(path: string) {
   if (typeof window === "undefined") return path;
   return new URL(`${appBasePath()}${path}`, window.location.origin).toString();
 }
 
-function targetOrigin(returnUrl: string | null) {
-  if (!returnUrl) return "*";
-  try {
-    return new URL(returnUrl).origin;
-  } catch {
-    return "*";
-  }
-}
-
 export default function BugReportDoneRoute() {
   const t = useT();
   const location = useLocation();
@@ -47,27 +50,45 @@ export default function BugReportDoneRoute() {
   const embedUrl = recordingId
     ? absoluteAppUrl(`/embed/${encodeURIComponent(recordingId)}`)
     : null;
-  const agentContextUrl = recordingId
-    ? absoluteAppUrl(
-        `/api/agent-context.json?id=${encodeURIComponent(recordingId)}`,
-      )
-    : null;
-
   useEffect(() => {
     if (!recordingId || !recordingUrl) return;
-    const message = {
-      type: "agent-native.clips.bug-report.submitted",
-      recordingId,
-      recordingUrl,
-      embedUrl,
-      agentContextUrl,
+    let cancelled = false;
+    void (async () => {
+      let agentLink: BugReportAgentLink | null = null;
+      try {
+        agentLink = (await callAction(
+          "create-recording-agent-link" as any,
+          {
+            recordingId,
+            ttlSeconds: BUG_REPORT_AGENT_ACCESS_TTL_SECONDS,
+          } as any,
+        )) as BugReportAgentLink;
+      } catch {
+        agentLink = null;
+      }
+      if (cancelled) return;
+
+      const message = createBugReportSubmissionMessage({
+        recordingId,
+        recordingUrl,
+        embedUrl: embedUrl ?? recordingUrl,
+        agentLink,
+      });
+
+      for (const origin of bugReportSubmissionTargetOrigins(
+        window.location.origin,
+        returnUrl,
+      )) {
+        window.opener?.postMessage(message, origin);
+        if (window.parent && window.parent !== window) {
+          window.parent.postMessage(message, origin);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
     };
-    const origin = targetOrigin(returnUrl);
-    window.opener?.postMessage(message, origin);
-    if (window.parent && window.parent !== window) {
-      window.parent.postMessage(message, origin);
-    }
-  }, [agentContextUrl, embedUrl, recordingId, recordingUrl, returnUrl]);
+  }, [embedUrl, recordingId, recordingUrl, returnUrl]);
 
   const copyRecordingUrl = async () => {
     if (!recordingUrl) return;

package/corpus/templates/clips/app/routes/bug-report.tsx

@@ -1,7 +1,9 @@
 import { appBasePath } from "@agent-native/core/client/api-path";
 import { useT } from "@agent-native/core/client/i18n";
 import {
+  BUG_REPORT_POPUP_RESPONSE_HEADERS,
   bugReportContextToSearchParams,
+  isBugReportSubmissionMessage,
   parseBugReportContext,
   type BugReportContext,
   type BugReportSeverity,
@@ -12,7 +14,7 @@ import {
   IconExternalLink,
   IconShieldCheck,
 } from "@tabler/icons-react";
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { useLocation, useOutlet } from "react-router";
 
 import { Button } from "@/components/ui/button";
@@ -33,7 +35,11 @@ export function meta() {
   return [{ title: enMessages.bugReportRoute.pageTitle }];
 }
 
-function openRecorder(url: string) {
+export function headers() {
+  return BUG_REPORT_POPUP_RESPONSE_HEADERS;
+}
+
+function openRecorder(url: string): Window | null {
   const opened = window.open(
     url,
     "agent-native-clips-bug-report",
@@ -41,9 +47,19 @@ function openRecorder(url: string) {
   );
   if (!opened) {
     window.location.href = url;
-    return;
+    return null;
   }
   opened.focus();
+  return opened;
+}
+
+function originFor(value: string | null): string | null {
+  if (!value) return null;
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
 }
 
 export default function BugReportRoute() {
@@ -66,6 +82,7 @@ export default function BugReportRoute() {
     initialContext?.severity ?? "normal",
   );
   const [referrer, setReferrer] = useState<string | null>(null);
+  const recorderWindowRef = useRef<Window | null>(null);
 
   useEffect(() => {
     setReferrer(document.referrer || null);
@@ -75,6 +92,26 @@ export default function BugReportRoute() {
   const pageTitle = initialContext?.pageTitle ?? null;
   const sourceLabel =
     pageTitle || sourceUrl || t("bugReportRoute.sourceUnknown");
+  const hostOrigin = originFor(initialContext?.returnUrl ?? sourceUrl);
+
+  useEffect(() => {
+    if (!hostOrigin) return;
+    const relaySubmission = (event: MessageEvent) => {
+      if (event.origin !== window.location.origin) return;
+      if (
+        recorderWindowRef.current &&
+        event.source !== recorderWindowRef.current
+      ) {
+        return;
+      }
+      if (!isBugReportSubmissionMessage(event.data)) return;
+      if (window.parent && window.parent !== window) {
+        window.parent.postMessage(event.data, hostOrigin);
+      }
+    };
+    window.addEventListener("message", relaySubmission);
+    return () => window.removeEventListener("message", relaySubmission);
+  }, [hostOrigin]);
 
   if (outlet) return outlet;
 
@@ -99,7 +136,9 @@ export default function BugReportRoute() {
     params.set("intent", "bug-report");
     params.set("mode", "screen");
     params.set("surface", "browser");
-    openRecorder(`${appBasePath()}/record?${params.toString()}`);
+    recorderWindowRef.current = openRecorder(
+      `${appBasePath()}/record?${params.toString()}`,
+    );
   };
 
   return (

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

@@ -93,6 +93,7 @@ async function writeAppState(key: string, value: unknown): Promise<void> {
 }
 
 import {
+  BUG_REPORT_POPUP_RESPONSE_HEADERS,
   bugReportTitle,
   parseBugReportContext,
   type BugReportContext,
@@ -129,6 +130,7 @@ export function headers() {
   return {
     "Permissions-Policy":
       "camera=(self), microphone=(self), display-capture=(self), geolocation=(), screen-wake-lock=()",
+    ...BUG_REPORT_POPUP_RESPONSE_HEADERS,
   };
 }
 

package/corpus/templates/clips/changelog/2026-07-29-clip-playback-now-recovers-instead-of-getting-stuck-when-a-b.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-29
+---
+
+Edited clips now start after trimmed intros and recover instead of getting stuck when a browser cannot start the video.

package/corpus/templates/clips/changelog/2026-07-29-comments-can-now-be-edited-after-posting.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-29
+---
+
+Comments can now be edited after posting.

package/corpus/templates/clips/changelog/2026-07-29-download-actions-now-use-a-shorter-clearer-label.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-29
+---
+
+Download actions now use a shorter, clearer label.

package/corpus/templates/clips/changelog/2026-07-29-embedded-bug-reports-now-return-a-temporary-agent-readable.md

@@ -0,0 +1,6 @@
+---
+date: "2026-07-29"
+type: improved
+---
+
+Embedded bug reports now return a temporary agent-readable link with transcript, timestamped frames, and diagnostics.

package/corpus/templates/clips/shared/bug-report.ts

@@ -1,4 +1,7 @@
 export const BUG_REPORT_QUERY_FLAG = "bugReport";
+export const BUG_REPORT_SUBMITTED_MESSAGE_TYPE =
+  "agent-native.clips.bug-report.submitted";
+export const BUG_REPORT_AGENT_ACCESS_TTL_SECONDS = 7 * 24 * 60 * 60;
 
 export const BUG_REPORT_SEVERITIES = [
   "low",
@@ -25,6 +28,27 @@ export interface BugReportContext {
   returnUrl: string | null;
 }
 
+export interface BugReportSubmissionMessage {
+  type: typeof BUG_REPORT_SUBMITTED_MESSAGE_TYPE;
+  recordingId: string;
+  recordingUrl: string;
+  embedUrl: string;
+  agentShareUrl: string | null;
+  agentContextUrl: string | null;
+  agentAccessExpiresAt: string | null;
+  agentAccessStatus: "ready" | "unavailable";
+}
+
+export interface BugReportAgentLink {
+  url?: string | null;
+  contextUrl?: string | null;
+  expiresAt?: string | null;
+}
+
+export const BUG_REPORT_POPUP_RESPONSE_HEADERS = {
+  "Cross-Origin-Opener-Policy": "unsafe-none",
+} as const;
+
 const PARAMS = {
   projectId: "projectId",
   title: "title",
@@ -159,3 +183,78 @@ export function bugReportTitle(context: BugReportContext | null): string {
     context?.title || context?.pageTitle || context?.sourceUrl || "Bug report"
   );
 }
+
+function nonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+export function createBugReportSubmissionMessage(input: {
+  recordingId: string;
+  recordingUrl: string;
+  embedUrl: string;
+  agentLink: BugReportAgentLink | null;
+}): BugReportSubmissionMessage {
+  const agentShareUrl = nonEmptyString(input.agentLink?.url)
+    ? input.agentLink.url
+    : null;
+  const agentContextUrl = nonEmptyString(input.agentLink?.contextUrl)
+    ? input.agentLink.contextUrl
+    : null;
+  const agentAccessExpiresAt = nonEmptyString(input.agentLink?.expiresAt)
+    ? input.agentLink.expiresAt
+    : null;
+  const agentAccessReady =
+    agentShareUrl !== null &&
+    agentContextUrl !== null &&
+    agentAccessExpiresAt !== null;
+
+  return {
+    type: BUG_REPORT_SUBMITTED_MESSAGE_TYPE,
+    recordingId: input.recordingId,
+    recordingUrl: input.recordingUrl,
+    embedUrl: input.embedUrl,
+    agentShareUrl: agentAccessReady ? agentShareUrl : null,
+    agentContextUrl: agentAccessReady ? agentContextUrl : null,
+    agentAccessExpiresAt: agentAccessReady ? agentAccessExpiresAt : null,
+    agentAccessStatus: agentAccessReady ? "ready" : "unavailable",
+  };
+}
+
+export function bugReportSubmissionTargetOrigins(
+  clipsOrigin: string,
+  returnUrl: string | null,
+): string[] {
+  let returnOrigin: string | null = null;
+  if (returnUrl) {
+    try {
+      const parsed = new URL(returnUrl);
+      returnOrigin = parsed.origin === "null" ? null : parsed.origin;
+    } catch {
+      returnOrigin = null;
+    }
+  }
+  return [...new Set([clipsOrigin, returnOrigin].filter(nonEmptyString))];
+}
+
+export function isBugReportSubmissionMessage(
+  value: unknown,
+): value is BugReportSubmissionMessage {
+  if (!value || typeof value !== "object") return false;
+  const message = value as Record<string, unknown>;
+  const validAgentAccess =
+    (message.agentAccessStatus === "ready" &&
+      nonEmptyString(message.agentShareUrl) &&
+      nonEmptyString(message.agentContextUrl) &&
+      nonEmptyString(message.agentAccessExpiresAt)) ||
+    (message.agentAccessStatus === "unavailable" &&
+      message.agentShareUrl === null &&
+      message.agentContextUrl === null &&
+      message.agentAccessExpiresAt === null);
+  return (
+    message.type === BUG_REPORT_SUBMITTED_MESSAGE_TYPE &&
+    nonEmptyString(message.recordingId) &&
+    nonEmptyString(message.recordingUrl) &&
+    nonEmptyString(message.embedUrl) &&
+    validAgentAccess
+  );
+}

package/corpus/templates/content/actions/_content-database-personal-view.ts

@@ -99,7 +99,13 @@ export async function assertContentDatabaseViewerAccess(databaseId: string) {
         isNull(schema.contentDatabases.deletedAt),
       ),
     );
-  if (!database) throw new Error(`Database "${databaseId}" not found`);
+  if (!database) {
+    const error = new Error(`Database "${databaseId}" not found`) as Error & {
+      statusCode: number;
+    };
+    error.statusCode = 404;
+    throw error;
+  }
 
   try {
     await assertAccess("document", database.documentId, "viewer");

package/corpus/templates/content/app/components/editor/database/DatabaseView.tsx

@@ -812,11 +812,14 @@ function DatabaseTable({
   const isLoadingMoreItems =
     database.isFetching && data?.pagination?.limit !== databaseRequestItemLimit;
   const databaseId = data?.database.id ?? expectedDatabaseId;
+  const personalViewDatabaseId = data?.database.id ?? null;
   const newDatabaseRowLabel = isWorkspaceCatalog
     ? t("sidebar.addWorkspace")
     : dbText("newPage");
-  const personalView = useContentDatabasePersonalView(databaseId);
-  const updatePersonalView = useUpdateContentDatabasePersonalView(databaseId);
+  const personalView = useContentDatabasePersonalView(personalViewDatabaseId);
+  const updatePersonalView = useUpdateContentDatabasePersonalView(
+    personalViewDatabaseId,
+  );
   const source = data?.source ?? null;
   const sources = useMemo(
     () => databaseAttachedSources(data?.sources, source),