61:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 62:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 63:T3568,"use client"; // @litt/thinking 2026.11.08. What changed: https://littmd.vercel.app/changelog.md /** * Thinking: the agent's reasoning as a quiet disclosure above its answer. While the agent thinks it reads * "Thinking 4s" with the reasoning streaming in underneath; when it stops it reads "Thought for 12s" and folds * itself away. The reader can open any thought and read it. * * - Row (components.md, Thinking): a button 32px tall (44px on a coarse pointer, or inside a phone * DeviceProvider) with no fill and no padding, so the chevron sits on the column's edge. A 16px chevron, the label * at the small size in fg-muted and the clock in the caption in fg-subtle with tabular numbers. Hover steps * the label to fg, and a press on a finger does the same. The text sits on a shared baseline, so the clock never * rides high or low beside the label. * - Flat: a grey card at the surface radius with no frame; the reasoning keeps its indent inside it. * - No shimmer, no pulse, no spinner, no dots, no caret (R2, and "no motion that is not a response to the person"). * The only live signal is the clock, which counts whole seconds from when `active` turned true. It is a number * changing, not an animation. * - Clock words: under a minute "12s", then "1m 5s", a whole minute "2m", and past an hour "1h 5m". Seconds * are always rounded down. A thought that lasted * under a second reads "Thought for a moment", with no clock. A thought with no known time (never active, no * `duration`) reads just "Thought". `label` replaces the words and keeps the clock: "Reasoning 4s". * - Body: the reasoning at the small size in fg-subtle, indented by the chevron and its gap so it lines up with the * label, with no box, no rail and no tint. A grid with --litt-space-2 between paragraphs, so a fragment of

* or a bare string both work. It holds to about 68ch, like an answer, and wraps long words instead of widening the page. * - Open and closed: uncontrolled, it is open while `active` and closes itself when `active` goes false, unless * the reader toggled it during that thought, so a reader's choice always wins. A new thought opens it again. * `open` and `onOpenChange` control it, and then the auto open and close are the caller's: only a reader's * toggle calls `onOpenChange`. `defaultOpen` sets the first state, which is otherwise `active`. * - Motion: the chevron turns a quarter on the instant tier (the `rotate` property, nothing else), and the label's * color fades on the instant tier. The body fades in and travels a quarter of the travel token down on the responsive * tier, and leaves with a fade on the exit token. Its height snaps, never animates: the body unmounts when the fade * ends. It has its own AnimatePresence, without `initial={false}`, so an ancestor's cannot swallow its entrance. * - Indicator: an optional slot beside the row while `active`, for an AgentIndicator under Device (decision 7 of * worlds.md). It is a sibling of the button, not inside it, so the row's name is unchanged; it is 31px tall at * the caption size, inside the row's 32px, so the row never changes height when the thought ends and it goes. * Without the prop the DOM is exactly as it was. * - Semantics: a real button with aria-expanded and aria-controls, pointing at a region that is always in the DOM * (empty while closed). The ticking clock is aria-hidden; the finished clock is read as words ("12 seconds"). * A polite live region says the label once when the thought starts and "Thought for 12 seconds" when it ends, * in words. It stays silent for a thought loaded from history, and the reasoning is never announced as it streams. */ import { useEffect, useId, useLayoutEffect, useRef, useState, type ReactNode } from "react"; import { AnimatePresence, motion } from "motion/react"; import { ChevronRightIcon } from "./icons"; import { useDevice, useExit, useTransition, useTravel } from "../../lib/litt/motion"; /* ----------------------------------------------------------------- the clock's words */ const whole = (n: number) => Math.max(0, Math.floor(n)); /** "12s", "1m 5s", "2m", "1h 5m": what the row shows. Whole seconds, rounded down. */ function formatClock(total: number): string { const s = whole(total); const h = Math.floor(s / 3600); const m = Math.floor((s % 3600) / 60); const r = s % 60; if (h) return m ? `${h}h ${m}m` : `${h}h`; if (m) return r ? `${m}m ${r}s` : `${m}m`; return `${r}s`; } /** "12 seconds", "1 minute 5 seconds": what a screen reader should say where the row shows "12s". */ function speakClock(total: number): string { const s = whole(total); const h = Math.floor(s / 3600); const m = Math.floor((s % 3600) / 60); const r = s % 60; const unit = (n: number, one: string) => `${n} ${n === 1 ? one : `${one}s`}`; if (h) return m ? `${unit(h, "hour")} ${unit(m, "minute")}` : unit(h, "hour"); if (m) return r ? `${unit(m, "minute")} ${unit(r, "second")}` : unit(m, "minute"); return unit(r, "second"); } /** The words before the clock, for a finished thought. `seconds` is null when the time is not known. */ function finishedWords(seconds: number | null): string { if (seconds === null) return "Thought"; return seconds < 1 ? "Thought for a moment" : "Thought for"; } /* ----------------------------------------------------------------- Thinking */ export type ThinkingProps = { /** True while the agent is thinking. The clock counts whole seconds from when it turned true, the body is open, and when it turns false the thought is finished. */ active?: boolean; /** Seconds a finished thought took, for one loaded from history. It is rounded down, and it is ignored while `active`. Without it, a thought that ran here shows the time its clock reached. */ duration?: number; /** Whether the reasoning is open, when you control it. Pair it with onOpenChange. The automatic open and close are then yours. */ open?: boolean; /** Whether it starts open when you do not control it. It starts open while `active` and closed otherwise. */ defaultOpen?: boolean; /** Called with the new state when the reader toggles the row. */ onOpenChange?: (open: boolean) => void; /** Replaces the words "Thinking" and "Thought for", such as "Reasoning". The clock still follows it: "Reasoning 4s", then "Reasoning 12s". */ label?: string; /** The reasoning: paragraphs in the small size, spaced apart. It can be empty while the first words are still on their way. */ children?: ReactNode; /** Something that shows what the agent is doing while it thinks, such as an AgentIndicator under Device. It sits beside the row while `active` and is gone once the thought is finished. Leave it out and the row is exactly as it was. */ indicator?: ReactNode; /** Extra classes for the whole component, such as a width. */ className?: string; }; /** The agent's reasoning as a disclosure: a row with a label and a clock, and the reasoning folded under it. Open while the agent thinks, closed once it has, and always the reader's to toggle. */ export function Thinking({ active = false, duration, open: openProp, defaultOpen, onOpenChange, label, children, indicator, className = "", }: ThinkingProps) { const uid = useId(); const bodyId = `${uid}-body`; const { coarse } = useDevice(); const enter = useTransition("responsive"); const exit = useExit("responsive"); const travel = useTravel(); const controlled = openProp !== undefined; const [innerOpen, setInnerOpen] = useState(defaultOpen ?? active); const open = controlled ? openProp : innerOpen; /* The clock: whole seconds since `active` turned true. It keeps its last value once the thought ends, which is what the finished label shows. */ const [elapsed, setElapsed] = useState(0); const [ran, setRan] = useState(active); const [touched, setTouched] = useState(false); const [prevActive, setPrevActive] = useState(active); const [said, setSaid] = useState(""); /* A thought starting or stopping is adjusted while rendering, so the first frame after the change is already right: a new thought starts at 0s and open, and a finished one closes itself unless the reader toggled it. */ if (active !== prevActive) { setPrevActive(active); if (active) { setElapsed(0); setRan(true); setTouched(false); setInnerOpen(true); } else if (!touched) { setInnerOpen(false); } } /* Count from the moment it turned on. Each tick lands on the next whole second, so the clock does not drift, and the time is read from the clock rather than counted, so a throttled background tab still shows the truth. A layout effect, so the final reading is in place before the frame in which the thought reads as finished. */ const finished = useRef(null); useLayoutEffect(() => { if (!active) return; const start = performance.now(); const read = () => Math.floor((performance.now() - start) / 1000); let timer: ReturnType; const tick = () => { setElapsed(read()); timer = setTimeout(tick, 1000 - ((performance.now() - start) % 1000)); }; timer = setTimeout(tick, 1000); return () => { clearTimeout(timer); finished.current = read(); setElapsed(finished.current); }; }, [active]); const given = typeof duration === "number" && Number.isFinite(duration) ? whole(duration) : null; const seconds = active ? elapsed : (given ?? (ran ? elapsed : null)); const words = label ?? (active ? "Thinking" : finishedWords(seconds)); const showClock = seconds !== null && (active || seconds >= 1); /* The two announcements, in words: once at the start and once at the end. Nothing for a thought that was loaded finished, and nothing while the reasoning streams. */ const announced = useRef(false); useEffect(() => { if (active) { announced.current = true; setSaid(label ?? "Thinking"); } else if (announced.current) { announced.current = false; const took = given ?? finished.current ?? seconds; const spoken = took !== null && took >= 1 ? speakClock(took) : null; setSaid(label ? (spoken ? `${label} finished after ${spoken}` : `${label} finished`) : spoken ? `Thought for ${spoken}` : finishedWords(took)); } // Only a change of `active` is an announcement, and it says the words of the render that changed it. }, [active]); // eslint-disable-line react-hooks/exhaustive-deps function toggle() { const next = !open; setTouched(true); if (!controlled) setInnerOpen(next); onOpenChange?.(next); } const row = ( ); return (

{indicator === undefined ? ( row ) : (

{row} {active && {indicator}}

)} {/* The region is always here, so aria-controls always points at something. Its own AnimatePresence keeps an ancestor's initial={false} from swallowing the entrance. */}

{open && ( {children} )}

{said}

); } 60:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[["$","ul",null,{"className":"flex min-w-0 flex-wrap gap-2","aria-label":"Package dependencies","children":[["$","li","motion",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/motion","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"motion"}]]}]}]]}],["$","$L61",null,{"namespace":"@litt","registryDependencies":["https://littmd.vercel.app/r/litt.json","https://littmd.vercel.app/r/icons.json","https://littmd.vercel.app/r/motion.json"]}]]}],null]}],["$","$L62",null,{"files":[{"path":"registry/litt/ui/thinking.tsx","content":"$63","type":"registry:ui","target":"components/litt/thinking.tsx"}],"className":"h-[70svh] min-h-80"}]]}]