@agent-native/core 0.69.0 → 0.70.0

package/corpus/templates/clips/app/routes/_app.settings._index.tsx

@@ -16,10 +16,18 @@ import {
   appApiPath,
   openBuilderConnectPopup,
   useActionQuery,
+  ChangelogSettingsCard,
 } from "@agent-native/core/client";
+import changelog from "../../CHANGELOG.md?raw";
 import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from "@/components/ui/card";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { PageHeader } from "@/components/library/page-header";
@@ -389,6 +397,8 @@ export default function SettingsIndexRoute() {
           Preferences and connected services for this Clips workspace.
         </p>
 
+        <ChangelogSettingsCard markdown={changelog} />
+
         <Card id="video-storage" className="scroll-mt-16">
           <CardHeader>
             <CardTitle className="text-base flex items-center gap-2">
@@ -462,6 +472,10 @@ export default function SettingsIndexRoute() {
               <IconBrandSlack className="size-4 text-primary" />
               Agent-Native Clips for Slack
             </CardTitle>
+            <CardDescription>
+              Share a public clip, paste the link in Slack, and it plays inline
+              — no extra steps for viewers. Connect each workspace once.
+            </CardDescription>
           </CardHeader>
           <CardContent className="space-y-4">
             <div className="flex flex-col gap-3 rounded-md border border-border bg-accent/30 px-3 py-3 sm:flex-row sm:items-center sm:justify-between">

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

@@ -486,6 +486,65 @@ function captureThumbnailFromPreview(
     });
 }
 
+/** Resolve once the off-screen video has a decoded frame, or after a timeout. */
+function waitForVideoFrame(
+  video: HTMLVideoElement,
+  timeoutMs: number,
+): Promise<void> {
+  if (video.videoWidth > 0 && video.readyState >= 2) return Promise.resolve();
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      video.removeEventListener("loadeddata", onReady);
+      video.removeEventListener("canplay", onReady);
+      clearTimeout(timer);
+      resolve();
+    };
+    const onReady = () => {
+      if (video.videoWidth > 0 && video.readyState >= 2) finish();
+    };
+    video.addEventListener("loadeddata", onReady);
+    video.addEventListener("canplay", onReady);
+    const timer = setTimeout(finish, timeoutMs);
+    onReady();
+  });
+}
+
+/**
+ * Capture a thumbnail from a MediaStream that isn't bound to a visible element
+ * — used for the screen+camera composite so the thumbnail includes the camera
+ * bubble. Best effort: if it misses, the player's backfill path (which reads
+ * the recorded file, also composited) still produces a face thumbnail.
+ */
+function captureThumbnailFromStream(
+  stream: MediaStream,
+  recordingId: string,
+): void {
+  const video = document.createElement("video");
+  video.srcObject = stream;
+  video.muted = true;
+  video.playsInline = true;
+  void (async () => {
+    try {
+      await video.play().catch(() => {});
+      await waitForVideoFrame(video, 1500);
+      const blob = await captureVideoThumbnailBlob(video);
+      if (blob) await uploadRecordingThumbnail(recordingId, blob);
+    } catch {
+      // best effort — the player has a backfill path if this misses.
+    } finally {
+      try {
+        video.pause();
+      } catch {
+        // ignore
+      }
+      video.srcObject = null;
+    }
+  })();
+}
+
 interface PendingRecording {
   id: string;
   uploadChunkUrl: string;
@@ -1024,7 +1083,14 @@ export default function RecordRoute() {
         // chose a specific mic, do not start a parallel system-default mic
         // session for instant transcription; the recorded audio still uses
         // the exact selected device and can be transcribed after upload.
-        if (wantsMic && !opts.micDeviceId && liveTranscription.supported) {
+        //
+        // The one exception is when a stale saved mic forced the engine to
+        // fall back to the system default during acquire(): the recording is
+        // now on the default device, so live transcription would use the same
+        // mic and is safe to start.
+        const usingDefaultMic =
+          !opts.micDeviceId || engine.didMicFallBackToDefault();
+        if (wantsMic && usingDefaultMic && liveTranscription.supported) {
           liveTranscription.start();
         }
 
@@ -1673,10 +1739,17 @@ export default function RecordRoute() {
     }
     setUiState("uploading");
     try {
-      // Capture a still-frame thumbnail from the preview while the stream is
-      // still live — otherwise the library would show a blank card until the
-      // owner opens the recording and triggers the player's backfill path.
-      captureThumbnailFromPreview(previewVideoRef.current, pending.id);
+      // Capture a still-frame thumbnail while the stream is still live —
+      // otherwise the library would show a blank card until the owner opens the
+      // recording and triggers the player's backfill path. In screen+camera
+      // mode the visible preview is screen-only, so grab the composited stream
+      // (screen + camera bubble) to keep the presenter's face in the thumbnail.
+      const compositeStream = engine.getCompositeStream();
+      if (compositeStream) {
+        captureThumbnailFromStream(compositeStream, pending.id);
+      } else {
+        captureThumbnailFromPreview(previewVideoRef.current, pending.id);
+      }
 
       // Stop live transcription and save the native web transcript before the
       // engine finalizes. This gives the recording an instant transcript

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

@@ -1,6 +1,7 @@
 import {
   useCallback,
   useEffect,
+  useMemo,
   useRef,
   useState,
   type ReactNode,
@@ -22,6 +23,7 @@ import {
   agentNativePath,
   appBasePath,
   appPath,
+  track,
   useSession,
   AgentPanel,
   getBrowserTabId,
@@ -70,6 +72,10 @@ import {
   clipsSharePageTitle,
   displayRecordingTitle,
 } from "../../shared/share-meta";
+import {
+  buildSignupAttributionQuery,
+  readShareAttribution,
+} from "../../shared/share-attribution";
 
 type SharePageMetaRecording = {
   id: string;
@@ -274,6 +280,61 @@ export default function ShareRoute() {
   const loaderData = useLoaderData<typeof loader>() as SharePageLoaderData;
   const { shareId } = useParams<{ shareId: string }>();
   const navigate = useNavigate();
+
+  // Viral attribution: read the `ref`/`via` the visitor arrived on (the tagged
+  // share link) so we can fire funnel events and forward attribution into the
+  // signup URL even when cookies are blocked or `document.referrer` is empty.
+  const attribution = useMemo(
+    () =>
+      readShareAttribution(
+        typeof window === "undefined" ? "" : window.location.search,
+      ),
+    [],
+  );
+  const recordingId = shareId ?? "";
+
+  // share_cta_click — fired alongside (never instead of) the real navigation.
+  // `track` is non-throwing, but guard anyway so tracking can never break a CTA.
+  const fireShareCtaClick = useCallback(
+    (cta: "signup" | "download" | "try_clips" | "signin") => {
+      try {
+        void track("share_cta_click", {
+          surface: "clip",
+          recording_id: recordingId,
+          cta,
+          ref: attribution.ref,
+          via: attribution.via,
+        });
+      } catch {
+        // Never let analytics break a CTA.
+      }
+    },
+    [recordingId, attribution.ref, attribution.via],
+  );
+
+  // Forward attribution into the signup URL so it survives blocked cookies.
+  const signupHref = appPath(
+    `/signup?${buildSignupAttributionQuery(attribution.via)}`,
+  );
+
+  // share_view — fire once when the public share page mounts. The ref guard
+  // prevents double-fire across re-renders / StrictMode double-invocation.
+  const shareViewFiredRef = useRef(false);
+  useEffect(() => {
+    if (shareViewFiredRef.current) return;
+    shareViewFiredRef.current = true;
+    try {
+      void track("share_view", {
+        surface: "clip",
+        recording_id: recordingId,
+        ref: attribution.ref,
+        via: attribution.via,
+      });
+    } catch {
+      // Never let analytics break the page render.
+    }
+  }, [recordingId, attribution.ref, attribution.via]);
+
   const playerRef = useRef<VideoPlayerHandle | null>(null);
   const [password, setPassword] = useState<string | null>(() => {
     if (typeof window === "undefined" || !shareId) return null;
@@ -690,7 +751,11 @@ export default function ShareRoute() {
               </Button>
             ) : session ? null : (
               <Button variant="ghost" size="sm" asChild>
-                <a href={appPath("/")} className="gap-1.5">
+                <a
+                  href={appPath("/")}
+                  className="gap-1.5"
+                  onClick={() => fireShareCtaClick("try_clips")}
+                >
                   Try Clips
                   <IconExternalLink className="h-3.5 w-3.5" />
                 </a>
@@ -879,7 +944,10 @@ export default function ShareRoute() {
                 browserTabId={getBrowserTabId()}
               />
             ) : (
-              <PublicAgentEmptyState />
+              <PublicAgentEmptyState
+                signupHref={signupHref}
+                onCtaClick={fireShareCtaClick}
+              />
             )}
           </TabsContent>
           <TabsContent
@@ -932,6 +1000,7 @@ export default function ShareRoute() {
           if (!open) setSignInIntent(null);
         }}
         intent={signInIntent ?? "comment"}
+        onSignIn={() => fireShareCtaClick("signin")}
       />
     </div>
   );
@@ -947,7 +1016,13 @@ function sanitizeFilename(name: string): string {
   );
 }
 
-function PublicAgentEmptyState() {
+function PublicAgentEmptyState({
+  signupHref,
+  onCtaClick,
+}: {
+  signupHref: string;
+  onCtaClick: (cta: "signup" | "download" | "try_clips" | "signin") => void;
+}) {
   const [platform, setPlatform] = useState<ViewerPlatform | null>(null);
 
   useEffect(() => {
@@ -1005,12 +1080,18 @@ function PublicAgentEmptyState() {
         Loom alternative
       </p>
       <div className="mt-7 flex w-full max-w-[220px] flex-col gap-2">
-        <CaptureInstallButton className="w-full gap-2" align="center">
+        <CaptureInstallButton
+          className="w-full gap-2"
+          align="center"
+          onClick={() => onCtaClick("download")}
+        >
           <IconDownload className="h-4 w-4" />
           {downloadLabel}
         </CaptureInstallButton>
         <Button asChild variant="outline" className="w-full">
-          <a href={appPath("/signup")}>Sign up</a>
+          <a href={signupHref} onClick={() => onCtaClick("signup")}>
+            Sign up
+          </a>
         </Button>
       </div>
     </div>

package/corpus/templates/clips/changelog/2026-06-23-clips-shared-in-slack-no-longer-show-a-could-not-start-playb.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-23
+---
+
+Clips shared in Slack no longer show a 'Could not start playback' error in the inline preview — they autoplay muted where allowed and play on click otherwise

package/corpus/templates/clips/changelog/2026-06-23-made-the-play-button-on-shared-and-embedded-clips-scale-with.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-06-23
+---
+
+Made the play button on shared and embedded clips scale with the player size so it's no longer oversized in small previews like Slack unfurls

package/corpus/templates/clips/changelog/2026-06-23-public-clip-share-links-now-show-whether-they-ll-play-inline.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-06-23
+---
+
+Public clip share links now show whether they'll play inline in Slack, with a one-click link to connect a workspace

package/corpus/templates/clips/changelog/2026-06-23-screen-camera-recordings-now-keep-the-presenter-s-face-in-th.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-23
+---
+
+Screen + camera recordings now keep the presenter's face in the thumbnail shown on the library card, video poster, and Slack unfurl

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

@@ -1473,6 +1473,22 @@ async function showRegionGuidesForRecording(wantsScreen: boolean) {
   });
 }
 
+// Frame the chosen screen region with a live border so the user can see exactly
+// what's being captured throughout the countdown and recording. The overlay is
+// capture-excluded and draws its stroke outside the captured pixels, so it never
+// lands in the video. Torn down with the rest of the recording chrome on stop.
+async function showRegionRecordBorder(region: RegionCaptureRect | null) {
+  if (!region) return;
+  await invoke("show_region_record_border", {
+    x: region.x,
+    y: region.y,
+    width: region.width,
+    height: region.height,
+  }).catch((err) => {
+    console.warn("[clips-recorder] show_region_record_border failed:", err);
+  });
+}
+
 async function runRecordingCountdown(wantsScreen: boolean, audioCue: AudioCue) {
   const countdownEvent = waitForCountdownEvent(
     COUNTDOWN_EVENT_TIMEOUT_MS,
@@ -1566,6 +1582,10 @@ async function startNativeFullscreenRecording(
 
     if (params.source === "region") {
       captureRegion = await selectRegionForRecording();
+      // Frame the selected area now so it stays visible through the countdown
+      // and the whole recording. hide_recording_chrome / hide_overlays tear it
+      // down on stop, cancel, and the error paths below.
+      await showRegionRecordBorder(captureRegion);
     }
 
     if (localOnly && localRecordingMode === "separate" && wantsCamera) {

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

@@ -12,6 +12,7 @@ import { MeetingNub } from "./overlays/meeting-nub";
 import { FlowBar } from "./overlays/flow-bar";
 import { RecordingPill } from "./overlays/recording-pill";
 import { RegionGuideEditor, RegionGuides } from "./overlays/region-guides";
+import { RegionRecordBorder } from "./overlays/region-record-border";
 import "./styles.css";
 
 /**
@@ -55,6 +56,8 @@ function pickRoute(route: string): React.ReactElement {
       return <RegionGuideEditor />;
     case "region-capture-selector":
       return <RegionGuideEditor mode="capture" />;
+    case "region-record-border":
+      return <RegionRecordBorder />;
     default:
       return <App />;
   }

package/corpus/templates/clips/desktop/src/overlays/region-record-border.tsx

@@ -0,0 +1,76 @@
+import { useEffect, useState } from "react";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+
+interface BorderRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+function clamp01(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(0, value));
+}
+
+/**
+ * The live recording region is handed to this overlay window as a normalized
+ * rect in the URL query (`?region=x,y,width,height`) so it never has to wait
+ * on a Tauri event (which could race the webview load). All four values are
+ * fractions [0,1] of the recording monitor — the same space the region-capture
+ * selector emitted them in.
+ */
+function parseRect(search: string): BorderRect | null {
+  const raw = new URLSearchParams(search).get("region");
+  if (!raw) return null;
+  const parts = raw.split(",").map((value) => Number.parseFloat(value));
+  if (parts.length !== 4 || parts.some((value) => !Number.isFinite(value))) {
+    return null;
+  }
+  const [x, y, width, height] = parts;
+  if (width <= 0 || height <= 0) return null;
+  return {
+    x: clamp01(x),
+    y: clamp01(y),
+    width: clamp01(width),
+    height: clamp01(height),
+  };
+}
+
+/**
+ * A thin frame painted around the screen region currently being recorded. The
+ * window itself is full-screen, click-through, and capture-excluded (see
+ * `show_region_record_border` on the Rust side). The frame is drawn entirely
+ * OUTWARD via an outset box-shadow with no fill, so its pixels sit just outside
+ * the captured rect and never leak into the recording even on the macOS 15.4+
+ * builds where `NSWindowSharingNone` is occasionally bypassed.
+ */
+export function RegionRecordBorder() {
+  const [rect] = useState<BorderRect | null>(() =>
+    typeof window === "undefined" ? null : parseRect(window.location.search),
+  );
+
+  useEffect(() => {
+    if (rect) return;
+    // No usable region — close the overlay so an empty window never lingers.
+    getCurrentWindow()
+      .close()
+      .catch(() => {});
+  }, [rect]);
+
+  if (!rect) return null;
+
+  return (
+    <div className="region-record-border-layer" aria-hidden>
+      <div
+        className="region-record-border-frame"
+        style={{
+          left: `${rect.x * 100}%`,
+          top: `${rect.y * 100}%`,
+          width: `${rect.width * 100}%`,
+          height: `${rect.height * 100}%`,
+        }}
+      />
+    </div>
+  );
+}

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

@@ -3749,6 +3749,55 @@ body[data-clips-route="recording-pill"] #root {
   backdrop-filter: blur(14px);
 }
 
+/* ------------------------------------------------------------------------- */
+/* Overlay: live recording-region border                                      */
+/* ------------------------------------------------------------------------- */
+
+.region-record-border-layer {
+  position: fixed;
+  inset: 0;
+  width: 100vw;
+  height: 100vh;
+  overflow: hidden;
+  pointer-events: none;
+}
+
+.region-record-border-frame {
+  position: absolute;
+  border-radius: 5px;
+  /* No fill, and the stroke is painted OUTWARD with an outset box-shadow so it
+     lands just outside the captured rect — never inside the recorded video. */
+  box-shadow:
+    0 0 0 2px rgba(239, 68, 68, 0.95),
+    0 0 0 4px rgba(239, 68, 68, 0.32),
+    0 0 26px 6px rgba(239, 68, 68, 0.26);
+  animation: region-record-border-pulse 1.8s ease-in-out infinite;
+}
+
+/* Gentle pulse that mirrors the live recording dot, signalling "recording
+   now". Honour reduced-motion by holding the frame steady. */
+@keyframes region-record-border-pulse {
+  0%,
+  100% {
+    box-shadow:
+      0 0 0 2px rgba(239, 68, 68, 0.9),
+      0 0 0 4px rgba(239, 68, 68, 0.28),
+      0 0 22px 5px rgba(239, 68, 68, 0.2);
+  }
+  50% {
+    box-shadow:
+      0 0 0 2px rgba(239, 68, 68, 1),
+      0 0 0 4px rgba(239, 68, 68, 0.44),
+      0 0 30px 8px rgba(239, 68, 68, 0.34);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .region-record-border-frame {
+    animation: none;
+  }
+}
+
 @keyframes flow-bar-in {
   from {
     opacity: 0;

package/corpus/templates/clips/desktop/src-tauri/capabilities/default.json

@@ -15,7 +15,8 @@
     "flow-bar",
     "recording-pill",
     "region-guides",
-    "region-guide-editor"
+    "region-guide-editor",
+    "region-record-border"
   ],
   "permissions": [
     "core:default",

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

@@ -31,6 +31,7 @@ const FINALIZING_LABEL: &str = "finalizing";
 const FLOW_BAR_LABEL: &str = "flow-bar";
 const REGION_GUIDES_LABEL: &str = "region-guides";
 const REGION_GUIDE_EDITOR_LABEL: &str = "region-guide-editor";
+const REGION_RECORD_BORDER_LABEL: &str = "region-record-border";
 
 /// Physical-pixel bubble sizes. Logical px on retina = physical / 2, so these
 /// map to ~96 (small) and ~180 (medium) logical px — matching Loom's camera
@@ -448,6 +449,65 @@ pub async fn hide_region_guides(app: AppHandle) -> Result<(), String> {
     Ok(())
 }
 
+/// Live border framing the region currently being recorded. Like the region
+/// guides this is a full-screen, click-through, capture-excluded overlay — but
+/// the rect is ephemeral (it belongs to one recording, not the saved preset),
+/// so it's handed in via the URL query rather than read from config. The React
+/// view paints only an OUTWARD frame so the stroke stays out of the captured
+/// pixels. The recording flow owns this window; it's torn down by
+/// `hide_recording_chrome` / `hide_overlays` when capture stops.
+#[tauri::command]
+pub async fn show_region_record_border(
+    app: AppHandle,
+    x: f64,
+    y: f64,
+    width: f64,
+    height: f64,
+) -> Result<(), String> {
+    if !(width > 0.0 && height > 0.0) {
+        return Ok(());
+    }
+    if let Some(existing) = app.get_webview_window(REGION_RECORD_BORDER_LABEL) {
+        let _ = existing.close();
+    }
+
+    let (mx, my, mw, mh) = tray_monitor_physical_rect(&app);
+    let url = WebviewUrl::App(
+        format!("index.html?region={x:.6},{y:.6},{width:.6},{height:.6}#region-record-border")
+            .into(),
+    );
+    let win = WebviewWindowBuilder::new(&app, REGION_RECORD_BORDER_LABEL, url)
+        .title("Clips Recording Region")
+        .decorations(false)
+        .transparent(true)
+        .always_on_top(true)
+        .skip_taskbar(true)
+        .resizable(false)
+        .shadow(false)
+        .visible(false)
+        .focused(false)
+        .build()
+        .map_err(|e| {
+            eprintln!("[clips-tray] region record border build failed: {}", e);
+            e.to_string()
+        })?;
+    let _ = win.set_size(tauri::Size::Physical(PhysicalSize::new(mw, mh)));
+    let _ = win.set_position(PhysicalPosition::new(mx, my));
+    let _ = win.set_ignore_cursor_events(true);
+    set_capture_excluded_always(&win);
+    configure_overlay_behavior(&win);
+    crate::util::show_without_activation(&win);
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn hide_region_record_border(app: AppHandle) -> Result<(), String> {
+    if let Some(w) = app.get_webview_window(REGION_RECORD_BORDER_LABEL) {
+        let _ = w.close();
+    }
+    Ok(())
+}
+
 /// Reconcile the always-on region-guides overlay with the current config.
 /// Called from config saves and on startup so the guides window matches the
 /// `always_visible` toggle without needing a recording-flow round trip. When a
@@ -748,6 +808,7 @@ pub async fn hide_overlays(app: AppHandle) -> Result<(), String> {
         FINALIZING_LABEL,
         FLOW_BAR_LABEL,
         REGION_GUIDES_LABEL,
+        REGION_RECORD_BORDER_LABEL,
     ] {
         if let Some(w) = app.get_webview_window(label) {
             let _ = w.close();
@@ -772,7 +833,9 @@ pub async fn hide_recording_chrome(app: AppHandle) -> Result<(), String> {
     // toggle — otherwise we'd flicker close→reopen right after stop.
     let g = crate::config::feature_config(&app).region_guides;
     let keep_region_guides = g.always_visible && g.enabled && !g.rects.is_empty();
-    let mut labels: Vec<&str> = vec![COUNTDOWN_LABEL, TOOLBAR_LABEL];
+    // The recording-region border belongs to a single recording (never pinned),
+    // so it always tears down here alongside the countdown + toolbar.
+    let mut labels: Vec<&str> = vec![COUNTDOWN_LABEL, TOOLBAR_LABEL, REGION_RECORD_BORDER_LABEL];
     if !keep_region_guides {
         labels.push(REGION_GUIDES_LABEL);
     }
@@ -1438,6 +1501,9 @@ pub async fn reset_state(app: AppHandle) -> Result<(), String> {
     if let Some(w) = app.get_webview_window(REGION_GUIDES_LABEL) {
         let _ = w.close();
     }
+    if let Some(w) = app.get_webview_window(REGION_RECORD_BORDER_LABEL) {
+        let _ = w.close();
+    }
     if let Some(window) = app.get_webview_window("popover") {
         // Restore normal size in case the window was shrunk to a pinhole
         // during recording — otherwise it would reappear as a 2×2 dot.

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

@@ -68,6 +68,8 @@ pub fn run() {
             clips::hide_recording_chrome,
             clips::show_region_guides,
             clips::hide_region_guides,
+            clips::show_region_record_border,
+            clips::hide_region_record_border,
             clips::show_region_guide_editor,
             clips::show_region_capture_selector,
             clips::close_bubble,

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

@@ -208,7 +208,10 @@ pub fn reapply_capture_exclusion_to_overlays(app: &tauri::AppHandle) {
                 set_window_capture_excluded(window, false);
                 continue;
             }
-            let private_guide = matches!(label.as_str(), "region-guides" | "region-guide-editor");
+            let private_guide = matches!(
+                label.as_str(),
+                "region-guides" | "region-guide-editor" | "region-record-border"
+            );
             set_window_capture_excluded(window, private_guide || !visible);
         }
     }