@agent-native/core 0.68.3 → 0.70.0

package/corpus/templates/clips/app/components/recorder/recorder-engine.ts

@@ -186,6 +186,17 @@ function errorName(err: unknown): string {
   return (err as { name?: string } | null)?.name ?? "";
 }
 
+// getUserMedia failed because the requested device is gone (unplugged / stale
+// saved id), not a permission error — recoverable by retrying with the default.
+function isDeviceUnavailableError(err: unknown): boolean {
+  const name = errorName(err);
+  return (
+    name === "OverconstrainedError" ||
+    name === "NotFoundError" ||
+    name === "DevicesNotFoundError"
+  );
+}
+
 function errorMessage(err: unknown): string {
   return err instanceof Error ? err.message : String(err || "Unknown error");
 }
@@ -409,6 +420,13 @@ export class RecorderEngine {
    */
   private cameraDisconnectNotified = false;
   private micDisconnectNotified = false;
+  /**
+   * Set when a stale/unavailable `micDeviceId` forces a fallback to the system
+   * default mic during `acquire()`. The recording then runs on the default
+   * device, so live transcription (which can only ever use the default mic) is
+   * safe to start even though a specific mic was originally requested.
+   */
+  private micFellBackToDefault = false;
 
   private state: RecorderState = "idle";
 
@@ -437,10 +455,30 @@ export class RecorderEngine {
     return this.cameraStream;
   }
 
+  /**
+   * True when `acquire()` had to fall back from the requested `micDeviceId` to
+   * the system default mic. Lets the UI start live transcription for this
+   * session even though a specific mic was originally selected.
+   */
+  didMicFallBackToDefault(): boolean {
+    return this.micFellBackToDefault;
+  }
+
   getPreviewStream(): MediaStream | null {
     return this.previewStream;
   }
 
+  /**
+   * The composited screen+camera canvas stream that actually gets recorded
+   * (screen with the camera bubble drawn in), or `null` for screen-only /
+   * camera-only modes where the visible preview already matches the recording.
+   * Used to grab a thumbnail that includes the presenter's camera — the raw
+   * preview stream in screen+camera mode is screen-only and has no face.
+   */
+  getCompositeStream(): MediaStream | null {
+    return this.cameraComposite?.stream ?? null;
+  }
+
   getElapsedMs(): number {
     if (this.startedAtMs === null) return 0;
     const now = performance.now();
@@ -504,6 +542,7 @@ export class RecorderEngine {
     const wantsCamera =
       this.opts.mode === "camera" || this.opts.mode === "screen+camera";
     const wantsMic = this.opts.micDeviceId !== NO_MIC_DEVICE_ID;
+    this.micFellBackToDefault = false;
 
     try {
       if (!isBrowserSecureContext()) {
@@ -592,7 +631,20 @@ export class RecorderEngine {
             audio: false,
           });
         } catch (err) {
-          throw this.friendlyError(err, "camera");
+          // Stale/unplugged cameraDeviceId — retry with the default camera
+          // instead of failing the recording.
+          if (this.opts.cameraDeviceId && isDeviceUnavailableError(err)) {
+            try {
+              this.cameraStream = await navigator.mediaDevices.getUserMedia({
+                video: true,
+                audio: false,
+              });
+            } catch (retryErr) {
+              throw this.friendlyError(retryErr, "camera");
+            }
+          } else {
+            throw this.friendlyError(err, "camera");
+          }
         }
       }
 
@@ -603,7 +655,22 @@ export class RecorderEngine {
             video: false,
           });
         } catch (err) {
-          throw this.friendlyError(err, "microphone");
+          // Same stale-device fallback as the camera — retry default mic.
+          if (this.opts.micDeviceId && isDeviceUnavailableError(err)) {
+            try {
+              this.micStream = await navigator.mediaDevices.getUserMedia({
+                audio: voiceFocusedAudioConstraints(),
+                video: false,
+              });
+              // Recording is now on the system default mic, so live
+              // transcription can run for this session after all.
+              this.micFellBackToDefault = true;
+            } catch (retryErr) {
+              throw this.friendlyError(retryErr, "microphone");
+            }
+          } else {
+            throw this.friendlyError(err, "microphone");
+          }
         }
       }
 

package/corpus/templates/clips/app/components/sharing/slack-share-hint.tsx

@@ -0,0 +1,71 @@
+import { IconBrandSlack } from "@tabler/icons-react";
+import { appPath, useActionQuery } from "@agent-native/core/client";
+
+interface SlackInstallation {
+  status: string;
+}
+
+interface SlackInstallationsResponse {
+  oauthConfigured: boolean;
+  installations: SlackInstallation[];
+}
+
+/**
+ * Contextual nudge shown in the share popover's Link tab for public clips.
+ *
+ * A public Clips link unfurls into a playable video when pasted in a connected
+ * Slack workspace, but that integration is otherwise only discoverable in
+ * Settings. When a workspace is connected we confirm the payoff; when none is,
+ * clip owners/admins get a one-click link to connect one in Settings.
+ *
+ * Only rendered for public clips (the caller gates on `isPublic`), so the
+ * `list-slack-installations` query never runs for private shares.
+ */
+export function SlackShareHint({ canManage }: { canManage: boolean }) {
+  const slack = useActionQuery<SlackInstallationsResponse>(
+    "list-slack-installations",
+    undefined,
+    { retry: false },
+  );
+
+  const data = slack.data;
+  const connected =
+    data?.installations?.some((i) => i.status === "connected") ?? false;
+
+  if (connected) {
+    return (
+      <div className="flex items-center gap-2.5 rounded-md border border-border bg-muted/40 px-3 py-2">
+        <IconBrandSlack className="h-4 w-4 shrink-0 text-muted-foreground" />
+        <div className="min-w-0">
+          <div className="text-xs font-medium">Plays inline in Slack</div>
+          <p className="text-[11px] text-muted-foreground">
+            Paste this link in any connected workspace to play it inline.
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  // No workspace connected yet. Connecting needs the deployment's Slack OAuth
+  // credentials, so only point managers at Settings when it's actually set up —
+  // otherwise the Connect button there is disabled and the link is a dead end.
+  // While the query is loading or errored, `data` is undefined and we render
+  // nothing rather than guess at the workspace state.
+  if (!data || !canManage || !data.oauthConfigured) return null;
+
+  return (
+    <a
+      href={appPath("/settings#slack")}
+      className="flex items-center gap-2.5 rounded-md border border-border px-3 py-2 transition-colors hover:bg-muted/50"
+    >
+      <IconBrandSlack className="h-4 w-4 shrink-0 text-muted-foreground" />
+      <div className="min-w-0 flex-1">
+        <div className="text-xs font-medium">Make it play inline in Slack</div>
+        <p className="text-[11px] text-muted-foreground">
+          Connect a workspace so this link unfurls as a video.
+        </p>
+      </div>
+      <span className="shrink-0 text-xs font-medium text-primary">Connect</span>
+    </a>
+  );
+}

package/corpus/templates/clips/app/lib/recorder-preferences.ts

@@ -0,0 +1,67 @@
+import type { CameraBubbleSize } from "@/components/recorder/camera-bubble";
+import type {
+  DisplaySurface,
+  RecordingMode,
+} from "@/components/recorder/recorder-engine";
+
+/**
+ * Last-used recorder selections, remembered across `/record` visits via
+ * localStorage so the panel doesn't reset to defaults every time. Device ids
+ * are best-effort: a remembered mic/camera that no longer exists (machine
+ * changed, permission revoked) falls back to "default" in the panel, so we
+ * never feed a stale `deviceId: { exact }` to getUserMedia.
+ *
+ * `?mode=` / `?surface=` URL params still win over a saved preference — those
+ * are explicit deep-link intents (e.g. the agent navigating to a specific
+ * capture mode).
+ */
+export interface RecorderPreferences {
+  mode: RecordingMode;
+  displaySurface: DisplaySurface;
+  micId: string;
+  cameraId: string;
+  cameraSize: CameraBubbleSize;
+}
+
+const STORAGE_KEY = "clips:recorder-preferences";
+
+const VALID_MODES: RecordingMode[] = ["screen", "camera", "screen+camera"];
+const VALID_SURFACES: DisplaySurface[] = ["monitor", "window", "browser"];
+const VALID_SIZES: CameraBubbleSize[] = ["sm", "md", "lg"];
+
+export function loadRecorderPreferences(): Partial<RecorderPreferences> {
+  if (typeof window === "undefined") return {};
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return {};
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    const prefs: Partial<RecorderPreferences> = {};
+    if (VALID_MODES.includes(parsed.mode as RecordingMode)) {
+      prefs.mode = parsed.mode as RecordingMode;
+    }
+    if (VALID_SURFACES.includes(parsed.displaySurface as DisplaySurface)) {
+      prefs.displaySurface = parsed.displaySurface as DisplaySurface;
+    }
+    if (typeof parsed.micId === "string") prefs.micId = parsed.micId;
+    if (typeof parsed.cameraId === "string") prefs.cameraId = parsed.cameraId;
+    if (VALID_SIZES.includes(parsed.cameraSize as CameraBubbleSize)) {
+      prefs.cameraSize = parsed.cameraSize as CameraBubbleSize;
+    }
+    return prefs;
+  } catch {
+    return {};
+  }
+}
+
+export function saveRecorderPreferences(
+  patch: Partial<RecorderPreferences>,
+): void {
+  if (typeof window === "undefined") return;
+  try {
+    const next = { ...loadRecorderPreferences(), ...patch };
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+  } catch {
+    // localStorage may be unavailable (private mode, quota) — preferences are
+    // a nicety, never block recording on a write failure.
+  }
+}

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

@@ -21,6 +21,7 @@ import {
 } from "@agent-native/core/client";
 import { IconCheck, IconSun, IconMoon } from "@tabler/icons-react";
 import { useTheme } from "next-themes";
+import changelog from "../CHANGELOG.md?raw";
 import { Toaster } from "@/components/ui/sonner";
 import { Button } from "@/components/ui/button";
 import {
@@ -258,7 +259,12 @@ function AppContent() {
       {standalonePublic ? null : <DbSyncSetup />}
       {standalonePublic ? null : <ClipsExtensionAuthBridge />}
       {standalonePublic ? null : (
-        <CommandMenu open={cmdkOpen} onOpenChange={setCmdkOpen}>
+        <CommandMenu
+          open={cmdkOpen}
+          onOpenChange={setCmdkOpen}
+          changelog={changelog}
+          changelogKey="clips"
+        >
           <CommandMenu.Group heading="Actions">
             <CommandMenu.Item onSelect={() => {}}>Search</CommandMenu.Item>
           </CommandMenu.Group>

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/_app.trash.tsx

@@ -88,6 +88,16 @@ export default function TrashRoute() {
   };
 
   const selectedIds = Array.from(selected);
+  const allSelected =
+    recordings.length > 0 && selected.size === recordings.length;
+
+  const toggleSelectAll = () => {
+    setSelected((prev) =>
+      prev.size === recordings.length
+        ? new Set()
+        : new Set(recordings.map((r) => r.id)),
+    );
+  };
 
   return (
     <div className="flex flex-1 flex-col min-h-0">
@@ -96,6 +106,17 @@ export default function TrashRoute() {
         <div className="ml-auto flex items-center gap-2">
           {selectedIds.length > 0 && (
             <>
+              <span className="text-sm text-muted-foreground">
+                {selectedIds.length} selected
+              </span>
+              <Button
+                size="sm"
+                variant="ghost"
+                className="gap-1.5"
+                onClick={toggleSelectAll}
+              >
+                {allSelected ? "Deselect all" : "Select all"}
+              </Button>
               <Button
                 size="sm"
                 variant="outline"

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

@@ -53,6 +53,10 @@ import {
   compressBlobIfTooLarge,
   formatMb,
 } from "@/lib/compress";
+import {
+  loadRecorderPreferences,
+  saveRecorderPreferences,
+} from "@/lib/recorder-preferences";
 import { cn } from "@/lib/utils";
 
 // Client-side app-state writer (the server module pulls in Node's `events`
@@ -482,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;
@@ -718,7 +781,14 @@ export default function RecordRoute() {
   const [isPaused, setIsPaused] = useState(false);
   const [elapsedMs, setElapsedMs] = useState(0);
   const [cameraStream, setCameraStream] = useState<MediaStream | null>(null);
-  const [cameraSize, setCameraSize] = useState<CameraBubbleSize>("md");
+  const [cameraSize, setCameraSize] = useState<CameraBubbleSize>(
+    () => loadRecorderPreferences().cameraSize ?? "md",
+  );
+  // Remember the bubble size across visits alongside the panel's selections.
+  const handleCameraSizeChange = useCallback((size: CameraBubbleSize) => {
+    setCameraSize(size);
+    saveRecorderPreferences({ cameraSize: size });
+  }, []);
   const [previewStream, setPreviewStream] = useState<MediaStream | null>(null);
   // The capture surface the user actually picked in the browser's native screen
   // picker (authority over the requested `displaySurface` hint). Drives whether
@@ -1013,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();
         }
 
@@ -1662,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
@@ -2058,7 +2142,7 @@ export default function RecordRoute() {
                   onImportLoom={importLoom}
                   importingLoom={loomImporting}
                   cameraSize={cameraSize}
-                  onCameraSizeChange={setCameraSize}
+                  onCameraSizeChange={handleCameraSizeChange}
                 />
               ) : (
                 <StorageSetupCard
@@ -2137,7 +2221,7 @@ export default function RecordRoute() {
         <CameraBubble
           stream={cameraStream}
           size={cameraSize}
-          onSizeChange={setCameraSize}
+          onSizeChange={handleCameraSizeChange}
           hidden={
             (uiState !== "recording" && uiState !== "countdown") ||
             hideBubbleForFullScreenCapture

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