@agent-native/core 0.129.1 → 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/desktop/src-tauri/src/native_screen.rs

@@ -3995,7 +3995,7 @@ const SCK_FINALIZE_TIMEOUT: Duration = Duration::from_secs(10);
 const CUSTOM_SCK_STOP_TIMEOUT: Duration = Duration::from_secs(3);
 
 #[cfg(target_os = "macos")]
-fn run_bounded_capture_stop<F>(stop: F, timeout: Duration) -> Result<(), String>
+pub(crate) fn run_bounded_capture_stop<F>(stop: F, timeout: Duration) -> Result<(), String>
 where
     F: FnOnce() -> Result<(), String> + Send + 'static,
 {

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

@@ -161,6 +161,7 @@ pub async fn audio_transcription_reset_timeline() -> Result<(), String> {
 pub(crate) mod macos {
     use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
     use std::sync::Arc;
+    use std::time::Duration;
 
     use objc2::rc::Retained;
     use objc2::AnyThread;
@@ -314,6 +315,15 @@ pub(crate) mod macos {
         }
     }
 
+    /// `SCStream::stop_capture()` occasionally never returns when the stream's
+    /// underlying connection was already interrupted (same ScreenCaptureKit
+    /// flakiness `native_screen::run_bounded_capture_stop` bounds for the video
+    /// stream). This capture has no delegate to observe that ahead of time, so
+    /// bound the stop call itself — otherwise a hung stop blocks the
+    /// `audio_transcription_stop` Tauri command, which blocks the recorder's
+    /// finalize await, forever.
+    const SYSTEM_AUDIO_SCK_STOP_TIMEOUT: Duration = Duration::from_secs(3);
+
     /// Handle for a running raw SCK audio capture. A meeting capture can carry
     /// both system and microphone output handlers on this one stream.
     pub(crate) struct RawSckAudioCapture {
@@ -328,7 +338,17 @@ pub(crate) mod macos {
     impl RawSckAudioCapture {
         pub(crate) fn stop(self) {
             self.cancelled.store(true, Ordering::SeqCst);
-            let _ = self.stream.stop_capture();
+            let stream = self.stream;
+            if let Err(err) = crate::native_screen::run_bounded_capture_stop(
+                move || {
+                    stream
+                        .stop_capture()
+                        .map_err(|e| format!("system audio SCStream stop failed: {e:?}"))
+                },
+                SYSTEM_AUDIO_SCK_STOP_TIMEOUT,
+            ) {
+                eprintln!("[system-audio] bounded stop_capture: {err}");
+            }
         }
     }