@agent-native/core 0.114.5 → 0.114.7

package/corpus/templates/clips/app/components/editor/editor-toolbar.tsx

@@ -16,6 +16,7 @@ import {
   IconDownload,
   IconLoader2,
   IconTrash,
+  IconHistory,
 } from "@tabler/icons-react";
 import { useState } from "react";
 import { toast } from "sonner";
@@ -84,6 +85,10 @@ export interface EditorToolbarProps {
   onOpenThumbnailPicker: () => void;
   onOpenChapters: () => void;
   onOpenStitch: () => void;
+  onOpenRewind: () => void;
+  rewindAlreadyAdded?: boolean;
+  rewindAvailable?: boolean;
+  rewindRequiresPrivate?: boolean;
   chaptersOpen?: boolean;
 }
 
@@ -103,6 +108,10 @@ export function EditorToolbar({
   onOpenThumbnailPicker,
   onOpenChapters,
   onOpenStitch,
+  onOpenRewind,
+  rewindAlreadyAdded,
+  rewindAvailable = true,
+  rewindRequiresPrivate = false,
   chaptersOpen,
 }: EditorToolbarProps) {
   const t = useT();
@@ -482,6 +491,19 @@ export function EditorToolbar({
             <IconPuzzle className="mr-2 h-4 w-4" />
             {t("editorToolbar.stitchClips")}
           </DropdownMenuItem>
+          {rewindAvailable ? (
+            <DropdownMenuItem
+              disabled={rewindAlreadyAdded}
+              onSelect={onOpenRewind}
+            >
+              <IconHistory className="mr-2 h-4 w-4" />
+              {rewindAlreadyAdded
+                ? "Rewind history added"
+                : rewindRequiresPrivate
+                  ? "Make private and add Rewind history…"
+                  : "Add what happened before…"}
+            </DropdownMenuItem>
+          ) : null}
           <DropdownMenuSeparator />
           <DropdownMenuItem onSelect={() => setClearOpen(true)}>
             <IconTrash className="mr-2 h-4 w-4" />
@@ -490,6 +512,20 @@ export function EditorToolbar({
         </DropdownMenuContent>
       </DropdownMenu>
 
+      {rewindAvailable && !rewindAlreadyAdded ? (
+        <Button
+          size="sm"
+          variant="ghost"
+          className="hidden shrink-0 gap-1.5 xl:inline-flex"
+          onClick={onOpenRewind}
+        >
+          <IconHistory className="h-4 w-4" />
+          {rewindRequiresPrivate
+            ? "Make private + add earlier"
+            : "Add earlier…"}
+        </Button>
+      ) : null}
+
       <div className="min-w-3 flex-1" />
 
       <Separator orientation="vertical" className="mx-1 h-6" />

package/corpus/templates/clips/app/components/editor/rewind-extension-dialog.tsx

@@ -0,0 +1,338 @@
+import {
+  agentNativePath,
+  appBasePath,
+} from "@agent-native/core/client/api-path";
+import { useActionMutation } from "@agent-native/core/client/hooks";
+import { useT } from "@agent-native/core/client/i18n";
+import { IconHistory, IconLoader2 } from "@tabler/icons-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
+
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { exportConcat } from "@/lib/ffmpeg-export";
+import { uploadFileClient } from "@/lib/upload-file-client";
+
+interface RewindExtensionRequest {
+  requestId: string;
+  recordingId: string;
+  seconds: 30 | 300;
+  status:
+    | "pending"
+    | "processing"
+    | "ready"
+    | "applying"
+    | "applied"
+    | "failed";
+  preRollRecordingId?: string;
+  actualDurationMs?: number;
+  error?: string;
+}
+
+interface RewindExtensionDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  recordingId: string;
+  durationMs: number;
+  videoFormat: "webm" | "mp4";
+  hasAudio: boolean;
+  visibility: "private" | "org" | "public";
+  onVisibilityChanged: () => void | Promise<void>;
+  onApplied: () => void | Promise<void>;
+}
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => window.setTimeout(resolve, ms));
+}
+
+async function readRequest(
+  recordingId: string,
+): Promise<RewindExtensionRequest | null> {
+  const params = new URLSearchParams({ recordingId });
+  const response = await fetch(
+    agentNativePath(
+      `/_agent-native/actions/get-rewind-extension-request?${params}`,
+    ),
+  );
+  const json = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(json?.error || json?.message || "Could not check Rewind.");
+  }
+  return (json?.result ?? json)?.request ?? null;
+}
+
+export function RewindExtensionDialog({
+  open,
+  onOpenChange,
+  recordingId,
+  durationMs,
+  videoFormat,
+  hasAudio,
+  visibility,
+  onVisibilityChanged,
+  onApplied,
+}: RewindExtensionDialogProps) {
+  const t = useT();
+  const makePrivateForRewind = useActionMutation(
+    "make-recording-private-for-rewind",
+  );
+  const requestExtension = useActionMutation("request-rewind-extension");
+  const applyExtension = useActionMutation("apply-rewind-extension");
+  const requestTranscript = useActionMutation("request-transcript" as any);
+  const [busy, setBusy] = useState(false);
+  const [status, setStatus] = useState<string | null>(null);
+  const [progress, setProgress] = useState(0);
+  const [privacyConfirmed, setPrivacyConfirmed] = useState(false);
+  const mounted = useRef(true);
+
+  useEffect(() => {
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!open && !busy) {
+      setStatus(null);
+      setProgress(0);
+      setPrivacyConfirmed(false);
+    }
+  }, [busy, open]);
+
+  const makePrivate = useCallback(async () => {
+    setBusy(true);
+    setStatus("Making this Clip private…");
+    try {
+      await makePrivateForRewind.mutateAsync({ recordingId });
+      await onVisibilityChanged();
+      setPrivacyConfirmed(true);
+      setStatus(null);
+      toast.success(t("rewindExtension.privateReady"));
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : String(error));
+      setStatus(null);
+    } finally {
+      setBusy(false);
+    }
+  }, [makePrivateForRewind, onVisibilityChanged, recordingId, t]);
+
+  const addFromRewind = useCallback(
+    async (seconds: 30 | 300) => {
+      setBusy(true);
+      setProgress(0);
+      try {
+        setStatus("Asking Clips Alpha for local Rewind history…");
+        const created = (await requestExtension.mutateAsync({
+          recordingId,
+          seconds,
+        })) as RewindExtensionRequest;
+        let request = created;
+        for (let attempt = 0; attempt < 160; attempt += 1) {
+          if (request.status === "failed") {
+            throw new Error(
+              request.error || "Clips Alpha could not read Rewind.",
+            );
+          }
+          if (
+            request.status === "ready" &&
+            request.preRollRecordingId &&
+            request.actualDurationMs
+          ) {
+            break;
+          }
+          setStatus(
+            request.status === "processing"
+              ? "Clips Alpha is preparing that local interval…"
+              : "Waiting for Clips Alpha…",
+          );
+          await wait(1_500);
+          request = (await readRequest(recordingId)) ?? request;
+        }
+        if (
+          request.status !== "ready" ||
+          !request.preRollRecordingId ||
+          !request.actualDurationMs
+        ) {
+          throw new Error(
+            "Clips Alpha did not finish the Rewind request in time.",
+          );
+        }
+
+        setStatus("Combining the selected history with this Clip…");
+        const blob = await exportConcat(
+          [
+            {
+              url: `${appBasePath()}/api/video/${encodeURIComponent(request.preRollRecordingId)}`,
+              format: "mp4",
+              hasAudio,
+            },
+            {
+              url: `${appBasePath()}/api/video/${encodeURIComponent(recordingId)}`,
+              format: videoFormat,
+              hasAudio,
+            },
+          ],
+          (next) => mounted.current && setProgress(next.progress),
+        );
+        setStatus("Saving the longer Clip…");
+        const upload = await uploadFileClient(
+          blob,
+          `rewind-${recordingId}.mp4`,
+        );
+        if (!upload?.url) {
+          throw new Error(
+            "Connect video storage before adding Rewind history.",
+          );
+        }
+        await applyExtension.mutateAsync({
+          recordingId,
+          requestId: request.requestId,
+          preRollRecordingId: request.preRollRecordingId,
+          videoUrl: upload.url,
+          durationMs: durationMs + request.actualDurationMs,
+          addedMs: request.actualDurationMs,
+        });
+        if (hasAudio) {
+          void requestTranscript
+            .mutateAsync({ recordingId, force: true, regenerate: true })
+            .catch(() => {
+              toast.info(
+                "The longer Clip was saved; its transcript can be regenerated later.",
+              );
+            });
+        }
+        await onApplied();
+        toast.success(
+          `${request.actualDurationMs >= 60_000 ? "Five minutes" : "Thirty seconds"} added from Rewind.`,
+        );
+        onOpenChange(false);
+      } catch (error) {
+        toast.error(error instanceof Error ? error.message : String(error));
+        setStatus(null);
+      } finally {
+        if (mounted.current) {
+          setBusy(false);
+          setProgress(0);
+        }
+      }
+    },
+    [
+      applyExtension,
+      durationMs,
+      hasAudio,
+      onApplied,
+      onOpenChange,
+      recordingId,
+      requestExtension,
+      requestTranscript,
+      videoFormat,
+    ],
+  );
+
+  return (
+    <Dialog open={open} onOpenChange={(next) => !busy && onOpenChange(next)}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <IconHistory className="h-4 w-4 text-primary" />
+            {t("rewindExtension.title")}
+          </DialogTitle>
+          <DialogDescription>
+            {t("rewindExtension.description")}
+          </DialogDescription>
+        </DialogHeader>
+
+        {busy ? (
+          <div
+            className="rounded-lg border bg-muted/30 p-4 text-sm"
+            role="status"
+            aria-live="polite"
+          >
+            <div className="flex items-center gap-2 font-medium">
+              <IconLoader2
+                className="h-4 w-4 animate-spin"
+                aria-hidden="true"
+              />
+              {status}
+            </div>
+            {progress > 0 ? (
+              <div className="mt-3 h-1.5 overflow-hidden rounded-full bg-muted">
+                <div
+                  className="h-full bg-primary transition-[width]"
+                  role="progressbar"
+                  aria-label={t("rewindExtension.progressLabel")}
+                  aria-valuemin={0}
+                  aria-valuemax={100}
+                  aria-valuenow={Math.round(progress * 100)}
+                  style={{ width: `${Math.round(progress * 100)}%` }}
+                />
+              </div>
+            ) : null}
+          </div>
+        ) : visibility !== "private" && !privacyConfirmed ? (
+          <div className="grid gap-3">
+            <div className="rounded-lg border border-amber-500/30 bg-amber-500/10 p-3 text-sm">
+              <strong className="block">
+                {t("rewindExtension.privateFirstTitle")}
+              </strong>
+              <span className="mt-1 block text-muted-foreground">
+                {t("rewindExtension.privateFirstDescription")}
+              </span>
+            </div>
+            <Button onClick={() => void makePrivate()}>
+              {t("rewindExtension.makePrivateContinue")}
+            </Button>
+          </div>
+        ) : (
+          <div className="grid gap-2">
+            <Button
+              variant="outline"
+              className="h-auto justify-start py-3 text-left"
+              onClick={() => void addFromRewind(30)}
+            >
+              <span>
+                <strong className="block">
+                  {t("rewindExtension.add30Seconds")}
+                </strong>
+                <span className="text-xs font-normal text-muted-foreground">
+                  Useful when you clicked Record just after the important bit.
+                </span>
+              </span>
+            </Button>
+            <Button
+              variant="outline"
+              className="h-auto justify-start py-3 text-left"
+              onClick={() => void addFromRewind(300)}
+            >
+              <span>
+                <strong className="block">
+                  {t("rewindExtension.add5Minutes")}
+                </strong>
+                <span className="text-xs font-normal text-muted-foreground">
+                  {t("rewindExtension.add5MinutesDescription")}
+                </span>
+              </span>
+            </Button>
+          </div>
+        )}
+
+        <DialogFooter>
+          <Button
+            variant="ghost"
+            disabled={busy}
+            onClick={() => onOpenChange(false)}
+          >
+            Cancel
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/corpus/templates/clips/app/components/editor/stitch-manager.tsx

@@ -24,24 +24,9 @@ import {
 import { ScrollArea } from "@/components/ui/scroll-area";
 import { exportConcat } from "@/lib/ffmpeg-export";
 import { formatMs } from "@/lib/timestamp-mapping";
+import { uploadFileClient } from "@/lib/upload-file-client";
 import { cn } from "@/lib/utils";
 
-/** Client-side upload via the framework's auto-mounted `/file-upload` route. */
-async function uploadFileClient(
-  blob: Blob,
-  filename: string,
-): Promise<{ url: string } | null> {
-  const form = new FormData();
-  form.append("file", blob, filename);
-  const res = await fetch(agentNativePath("/_agent-native/file-upload"), {
-    method: "POST",
-    body: form,
-  });
-  if (!res.ok) return null;
-  const json = await res.json();
-  return json?.url ? { url: json.url as string } : null;
-}
-
 export interface StitchManagerProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;

package/corpus/templates/clips/app/components/editor/timeline.tsx

@@ -1,3 +1,4 @@
+import { useT } from "@agent-native/core/client/i18n";
 import { useMemo } from "react";
 
 import {
@@ -21,6 +22,8 @@ export interface TimelineProps {
   chapters?: TimelineChapter[];
   excludedRanges?: Array<{ startMs: number; endMs: number }>;
   splitPoints?: number[];
+  /** Countdown-complete start after explicit Rewind history was prepended. */
+  originalStartMs?: number;
   onSeek?: (originalMs: number) => void;
   onClickChapter?: (chapter: TimelineChapter) => void;
   className?: string;
@@ -44,10 +47,12 @@ export function Timeline({
   chapters = [],
   excludedRanges = [],
   splitPoints = [],
+  originalStartMs,
   onSeek,
   onClickChapter,
   className,
 }: TimelineProps) {
+  const t = useT();
   const ticks = useMemo(() => {
     if (durationMs <= 0) return [];
     // Target ~1 tick per 100px at the current zoom, rounded to a human interval.
@@ -133,6 +138,27 @@ export function Timeline({
           );
         })}
 
+        {typeof originalStartMs === "number" && originalStartMs > 0 ? (
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <div
+                className="absolute top-0 z-10 h-full w-0.5 cursor-help bg-amber-500"
+                style={{
+                  left: (originalStartMs / Math.max(durationMs, 1)) * width - 1,
+                }}
+                aria-label={`Original Clip start at ${formatMs(originalStartMs)}`}
+              >
+                <span className="absolute left-1 top-0 whitespace-nowrap rounded-sm bg-amber-500 px-1 text-[9px] font-semibold text-black">
+                  {t("timeline.clipStartedHere")}
+                </span>
+              </div>
+            </TooltipTrigger>
+            <TooltipContent>
+              Recording began after the countdown · {formatMs(originalStartMs)}
+            </TooltipContent>
+          </Tooltip>
+        ) : null}
+
         {/* Playhead */}
         <div
           className="absolute top-0 h-full pointer-events-none"

package/corpus/templates/clips/app/components/meetings/meeting-card.tsx

@@ -1,5 +1,4 @@
 import { useT } from "@agent-native/core/client/i18n";
-import { resolveNativeMeetingJoinUrl } from "@shared/meeting-join-url";
 import {
   IconCheck,
   IconClock,
@@ -285,7 +284,7 @@ export function UpcomingMeetingCard({
           <div className="flex items-center gap-1.5">
             {meeting.joinUrl && (
               <a
-                href={resolveNativeMeetingJoinUrl(meeting.joinUrl)}
+                href={meeting.joinUrl}
                 target="_blank"
                 rel="noopener noreferrer"
                 onClick={(e) => e.stopPropagation()}

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

@@ -1493,6 +1493,24 @@ All notable user-facing changes to Clips are documented here. Open it any time f
     guideStartDescription:
       "Use the desktop reminder or the menu-bar Start Meeting Notes item when the call begins.",
   },
+  rewindExtension: {
+    title: "Add what happened before",
+    description:
+      "Pull a specific interval from local Rewind and add it to the start of this Clip. Nothing is added automatically.",
+    progressLabel: "Rewind history processing progress",
+    privateFirstTitle: "Make this Clip private first",
+    privateFirstDescription:
+      "Local Rewind history can contain context from before you chose to record. This changes the Clip to private. If anyone still has direct access, Clips will stop here so you can remove them in Share first.",
+    makePrivateContinue: "Make private and continue",
+    add30Seconds: "Add the previous 30 seconds",
+    add5Minutes: "Add the previous 5 minutes",
+    add5MinutesDescription:
+      "Good for recovering the lead-in to a longer explanation.",
+    privateReady: "This Clip is private. You can now add local Rewind history.",
+  },
+  timeline: {
+    clipStartedHere: "Clip started here",
+  },
 };
 
 export default messages;

package/corpus/templates/clips/app/lib/ffmpeg-export.ts

@@ -349,7 +349,11 @@ export async function exportGif(
  * before calling the `stitch-recordings` action with the uploaded URL.
  */
 export async function exportConcat(
-  sources: Array<{ url: string; format?: "webm" | "mp4" }>,
+  sources: Array<{
+    url: string;
+    format?: "webm" | "mp4";
+    hasAudio?: boolean;
+  }>,
   onProgress?: (p: ExportProgress) => void,
 ): Promise<Blob> {
   if (sources.length < 2) {
@@ -377,38 +381,41 @@ export async function exportConcat(
       "-i",
       `src${i}.${s.format ?? "webm"}`,
     ]);
+    const includesAudio = sources.every((source) => source.hasAudio !== false);
     const filterParts: string[] = [];
     const concatInputs: string[] = [];
     for (let i = 0; i < sources.length; i++) {
       filterParts.push(`[${i}:v]setpts=PTS-STARTPTS[v${i}]`);
-      filterParts.push(`[${i}:a]asetpts=PTS-STARTPTS[a${i}]`);
-      concatInputs.push(`[v${i}][a${i}]`);
+      if (includesAudio) {
+        filterParts.push(`[${i}:a]asetpts=PTS-STARTPTS[a${i}]`);
+        concatInputs.push(`[v${i}][a${i}]`);
+      } else {
+        concatInputs.push(`[v${i}]`);
+      }
     }
     filterParts.push(
-      `${concatInputs.join("")}concat=n=${sources.length}:v=1:a=1[outv][outa]`,
+      `${concatInputs.join("")}concat=n=${sources.length}:v=1:a=${includesAudio ? 1 : 0}[outv]${includesAudio ? "[outa]" : ""}`,
     );
-    await ffmpeg.exec([
+    const outputArgs = [
       ...inputArgs,
       "-filter_complex",
       filterParts.join(";"),
       "-map",
       "[outv]",
-      "-map",
-      "[outa]",
       "-c:v",
       "libx264",
       "-preset",
       "veryfast",
       "-crf",
       "22",
-      "-c:a",
-      "aac",
-      "-b:a",
-      "128k",
+      ...(includesAudio
+        ? ["-map", "[outa]", "-c:a", "aac", "-b:a", "128k"]
+        : []),
       "-movflags",
       "+faststart",
       "stitched.mp4",
-    ]);
+    ];
+    await ffmpeg.exec(outputArgs);
 
     const data = (await ffmpeg.readFile("stitched.mp4")) as Uint8Array;
     const blob = new Blob([data as BlobPart], { type: "video/mp4" });

package/corpus/templates/clips/app/lib/rewind-visibility.ts

@@ -0,0 +1,31 @@
+export type ClipVisibility = "private" | "org" | "public";
+
+export function isPrivateClip(
+  visibility: ClipVisibility | string | null | undefined,
+): boolean {
+  return visibility === "private";
+}
+
+export function canAddRewindHistory(
+  role: string | null | undefined,
+  visibility: ClipVisibility | string | null | undefined,
+): boolean {
+  return role === "owner" && isPrivateClip(visibility);
+}
+
+export function canOfferRewindHistory(
+  role: string | null | undefined,
+): boolean {
+  return role === "owner";
+}
+
+export function rewindHistoryUnavailableReason(
+  role: string | null | undefined,
+  visibility: ClipVisibility | string | null | undefined,
+): string | undefined {
+  if (role !== "owner") return "Only the owner can add Rewind history";
+  if (visibility !== "private") {
+    return "Make this Clip private before adding Rewind history";
+  }
+  return undefined;
+}

package/corpus/templates/clips/app/lib/timestamp-mapping.ts

@@ -45,6 +45,8 @@ export interface EditsJson {
   thumbnail?: ThumbnailSpec | null;
   /** Provenance: source recording IDs when this recording was created via stitch-recordings. */
   stitchedFrom?: string[];
+  /** Original countdown-complete boundary after an explicit Rewind pre-roll was prepended. */
+  rewindOriginalStartMs?: number;
 }
 
 export const DEFAULT_EDITS: EditsJson = {
@@ -73,6 +75,11 @@ export function parseEdits(raw: string | null | undefined): EditsJson {
       ...(Array.isArray(j.stitchedFrom)
         ? { stitchedFrom: j.stitchedFrom as string[] }
         : {}),
+      ...(typeof j.rewindOriginalStartMs === "number" &&
+      Number.isFinite(j.rewindOriginalStartMs) &&
+      j.rewindOriginalStartMs > 0
+        ? { rewindOriginalStartMs: Math.round(j.rewindOriginalStartMs) }
+        : {}),
     };
   } catch {
     return { ...DEFAULT_EDITS };

package/corpus/templates/clips/app/lib/upload-file-client.ts

@@ -0,0 +1,17 @@
+import { agentNativePath } from "@agent-native/core/client/api-path";
+
+/** Upload a browser-produced file through Clips' authenticated file route. */
+export async function uploadFileClient(
+  blob: Blob,
+  filename: string,
+): Promise<{ url: string } | null> {
+  const form = new FormData();
+  form.append("file", blob, filename);
+  const response = await fetch(agentNativePath("/_agent-native/file-upload"), {
+    method: "POST",
+    body: form,
+  });
+  if (!response.ok) return null;
+  const json = await response.json();
+  return json?.url ? { url: json.url as string } : null;
+}

package/corpus/templates/clips/changelog/2026-07-14-rewind-keeps-recent-screen-context-local-and-turns-it-into-clips.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-14
+---
+
+Rewind can keep recent screen context local, make it searchable on your Mac, and explicitly include the previous 30 seconds or 5 minutes in a Clip without starting another recorder

package/corpus/templates/clips/changelog/2026-07-17-active-clips-keep-rewind-stable-and-settings-clear.md

@@ -0,0 +1,12 @@
+---
+type: fixed
+date: 2026-07-17
+---
+
+Active Clips now keep Rewind's shared screen and audio capture stable until the Clip ends. Rewind's on/off, pause, and capture-mode controls visibly lock during recording, with a native safeguard for non-UI callers, so changing Rewind can no longer strand a Clip in optimization with a coverage gap.
+
+Rewind Settings also use application exclusions as the single privacy model, return Back through the surface that opened them, describe local-memory maintenance before asking someone to act, and speak plainly about local agents finding moments on request.
+
+The recording toolbar's timer now opens Clips without stopping the active recording, and Dock, tray, and shortcut opens all restore the active popover. Rewind-derived hosted Clips now create the resumable storage session they need before recording, and exact-range encoding uses an interactive-speed preset so Stop no longer appears frozen for roughly the Clip's full duration. The compact Rewind settings rows also reserve separate label and control columns to prevent overlap.
+
+Recorder Home now keeps its bottom navigation fixed while the content region adapts to the available popover height. After Rewind's first-time setup, its single Home switch means remembering or paused; the duplicate Pause button and active-recording lock paragraph are gone. Full disable and capture-mode setup remain in Rewind Settings, while the active-Clip switch uses an unmistakable disabled treatment until recording ends.