64: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"] 65: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"] 66:Tb9f,/** * Frozen cross-lane contracts (P11). Lane 2 (Chat) and later Thinking items import these; * add members only with a coordinated change, because consumers switch over them exhaustively. */ /** * Where one step of a run is. * * pending queued, not started * active running now (one per level, usually) * complete finished successfully * error failed; the run may continue or stop * skipped not needed after all (cancelled plan steps, short-circuited checks) */ export type StepStatus = "pending" | "active" | "complete" | "error" | "skipped"; /** * Where one tool call is. A superset of the AI SDK's tool-part states, collapsed to what the * UI distinguishes; map AI SDK parts with `toolStateFromPart`. * * pending input still streaming in, or queued * awaiting-approval needs the user to approve or deny before it runs * running executing * done returned output * error threw or returned an error * denied the user declined it */ export type ToolState = "pending" | "awaiting-approval" | "running" | "done" | "error" | "denied"; /** States after which a step or tool will not change again. */ export const SETTLED_STEP: ReadonlySet = new Set(["complete", "error", "skipped"]); export const SETTLED_TOOL: ReadonlySet = new Set(["done", "error", "denied"]); /** One step of a run: a chain-of-thought line, a plan item, an agent action. */ export type Step = { /** Stable id: steps are keyed by it, so re-ordering moves rows instead of re-mounting them. */ id: string; label: string; status: StepStatus; /** A secondary line: a URL read, a count found, an error message. */ detail?: string; /** Epoch ms when the step became active. */ startedAt?: number; /** Epoch ms when it settled. */ endedAt?: number; /** Nested sub-steps. */ steps?: Step[]; }; /** The AI SDK (v5+) tool-part `state` values `toolStateFromPart` understands. */ export type AISDKToolPartState = | "input-streaming" | "input-available" | "approval-requested" | "approval-responded" | "output-available" | "output-error" | "output-denied"; /** * Maps an AI SDK tool part to a `ToolState`, so `useChat` messages drive Eased tool UI directly: * `toolStateFromPart(part)` where `part.type` starts with `tool-`. Unknown states read as `pending`. */ export function toolStateFromPart(part: { state?: string; approval?: { approved?: boolean } }): ToolState { switch (part.state as AISDKToolPartState | undefined) { case "input-available": return "running"; case "approval-requested": return "awaiting-approval"; case "approval-responded": return part.approval?.approved === false ? "denied" : "running"; case "output-available": return "done"; case "output-error": return "error"; case "output-denied": return "denied"; default: return "pending"; } } 67:Te1b,import { SETTLED_STEP, type Step, type StepStatus } from "./types"; /** A run's summary, derived from its steps. Pure: call it in render. */ export type StepSummary = { /** Leaf and parent steps at the top level. */ total: number; /** Top-level steps that have settled (complete, error or skipped). */ settled: number; completed: number; errored: number; /** settled / total, 0–1: what a progress rail draws to. 0 for an empty run. */ progress: number; /** The first active top-level step, or the first pending one if none is active yet. */ current: Step | undefined; /** The run as one status: error if any step failed and nothing is still going, active while anything is pending or active, complete when all settled. */ status: StepStatus; /** Epoch ms span from the first start to the last end, when the steps carry times. */ durationMs: number | undefined; }; /** Summarises a list of steps for a rail, a header ("4 of 7"), or a collapsed run ("7 steps · 45s"). */ export function summarizeSteps(steps: readonly Step[]): StepSummary { let settled = 0; let completed = 0; let errored = 0; let current: Step | undefined; let firstPending: Step | undefined; let start = Infinity; let end = -Infinity; for (const s of steps) { if (SETTLED_STEP.has(s.status)) settled++; if (s.status === "complete") completed++; if (s.status === "error") errored++; if (s.status === "active" && !current) current = s; if (s.status === "pending" && !firstPending) firstPending = s; if (s.startedAt !== undefined) start = Math.min(start, s.startedAt); if (s.endedAt !== undefined) end = Math.max(end, s.endedAt); } const total = steps.length; const running = settled < total; return { total, settled, completed, errored, progress: total ? settled / total : 0, current: current ?? firstPending, status: total === 0 ? "pending" : running ? (current || settled ? "active" : "pending") : errored ? "error" : "complete", durationMs: Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : undefined, }; } /** * Immutable update of one step by id, anywhere in the tree. Stamps `startedAt` when a step * becomes active and `endedAt` when it settles, unless the patch sets them. * * setSteps((s) => updateStep(s, "search", { status: "complete", detail: "14 sources" })) */ export function updateStep(steps: readonly Step[], id: string, patch: Partial>, now = Date.now()): Step[] { return steps.map((s) => { if (s.id === id) { const next = { ...s, ...patch }; if (patch.status === "active" && s.status !== "active" && patch.startedAt === undefined) next.startedAt = now; if (patch.status && SETTLED_STEP.has(patch.status) && !SETTLED_STEP.has(s.status) && patch.endedAt === undefined) next.endedAt = now; return next; } return s.steps ? { ...s, steps: updateStep(s.steps, id, patch, now) } : s; }); } /** * Settles the active step and activates the next pending one: the usual "next" in a linear run. * Returns the steps unchanged when nothing is left to advance. */ export function advanceSteps(steps: readonly Step[], outcome: "complete" | "error" | "skipped" = "complete", now = Date.now()): Step[] { const active = steps.find((s) => s.status === "active"); let next: Step[] = [...steps]; if (active) next = updateStep(next, active.id, { status: outcome }, now); const pending = next.find((s) => s.status === "pending"); if (pending) next = updateStep(next, pending.id, { status: "active" }, now); return next; } 68:Tb9f,"use client"; import { useEffect, useRef, useState } from "react"; export type UseElapsedOptions = { /** Counting while true. When it turns false the value freezes (at `endedAt` if given). Default true. */ running?: boolean; /** When the clock started (epoch ms or Date). Omit to start when `running` first turns true. */ startedAt?: number | Date; /** When it stopped. Use it to show a finished run's exact duration, e.g. from the server. */ endedAt?: number | Date; }; const ms = (t: number | Date | undefined) => (t === undefined ? undefined : typeof t === "number" ? t : t.getTime()); /** * Whole seconds since a start, ticking exactly on each second boundary of the start time (not * of the wall clock), so "1s" appears one second after the start, not up to two. It reads * `Date.now()` on every tick rather than counting ticks, so a throttled background tab is * still right when it returns. Re-renders once a second while running, and never on the * server (it returns 0 until mounted). * * const seconds = useElapsed({ running: status === "thinking", startedAt }); */ export function useElapsed({ running = true, startedAt, endedAt }: UseElapsedOptions = {}): number { const start = useRef(ms(startedAt)); const frozen = useRef(undefined); const [seconds, setSeconds] = useState(0); const startMs = ms(startedAt); const endMs = ms(endedAt); useEffect(() => { if (startMs !== undefined) start.current = startMs; const from = () => start.current ?? Date.now(); if (!running) { // Freeze: at the given end, else at the moment it stopped. if (start.current === undefined && endMs === undefined) return; const stop = endMs ?? frozen.current ?? Date.now(); frozen.current = stop; setSeconds(Math.max(0, Math.floor((stop - from()) / 1000))); return; } // Without a `startedAt`, every new run (running false → true) starts from now. if (startMs === undefined && (start.current === undefined || frozen.current !== undefined)) start.current = Date.now(); frozen.current = undefined; let timer = 0; const tick = () => { const elapsed = Date.now() - from(); setSeconds(Math.max(0, Math.floor(elapsed / 1000))); // Next boundary of the start's own second grid, plus a hair so floor() lands on it. timer = window.setTimeout(tick, 1000 - (((elapsed % 1000) + 1000) % 1000) + 4); }; tick(); return () => clearTimeout(timer); }, [running, startMs, endMs]); return seconds; } /** * Seconds as a compact duration: `12s`, `1m 4s`, `1h 2m`. Every digit is a digit, so it rolls * cleanly when passed to Number Roll as a `formatter`. */ export function formatElapsed(seconds: number): string { const s = Math.max(0, Math.floor(seconds)); if (s < 60) return `${s}s`; const m = Math.floor(s / 60); if (m < 60) return `${m}m ${s % 60}s`; return `${Math.floor(m / 60)}h ${m % 60}m`; } 69:Tba0,"use client"; import { useMotionValue, type MotionValue } from "motion/react"; import { useEffect, useRef } from "react"; export type UseTokenRateOptions = { /** Tokens per second that reads as full speed (`rate` = 1). Default 60, a fast model's stream. */ max?: number; /** * Smoothing time constant in seconds. Streams arrive in bursts; the rate follows the average * over roughly this window, so a 40-token chunk reads as a surge, not a spike. Default 0.6. */ smoothing?: number; /** Characters per token when `source` is a string. Default 4 (English prose). */ charsPerToken?: number; }; export type TokenRate = { /** Smoothed tokens per second. */ tps: MotionValue; /** `tps / max`, clamped to 0–1: feed it to anything that should move with the stream. */ rate: MotionValue; }; /** * How fast a stream is flowing, as motion values, so an orb or a meter can follow it without * re-rendering. Pass the streaming text (or a running token count); every change counts the * new tokens, and a frame loop turns them into a smoothed tokens-per-second that rises with * bursts and decays to 0 when the stream pauses. The loop runs only while the rate is * non-zero. If the text shrinks (a new message), it starts over. * * const { rate } = useTokenRate(message.text); * */ export function useTokenRate(source: string | number, { max = 60, smoothing = 0.6, charsPerToken = 4 }: UseTokenRateOptions = {}): TokenRate { const tps = useMotionValue(0); const rate = useMotionValue(0); const last = useRef(null); const pending = useRef(0); const frame = useRef(0); const opts = useRef({ max, smoothing }); useEffect(() => { opts.current = { max, smoothing }; }); useEffect(() => { const count = typeof source === "number" ? source : source.length / charsPerToken; const prev = last.current; last.current = count; if (prev === null || count < prev) return; // first sight, or a reset pending.current += count - prev; if (frame.current) return; let then = performance.now(); const step = (now: number) => { const dt = Math.min(0.1, Math.max(0.001, (now - then) / 1000)); then = now; const observed = pending.current / dt; pending.current = 0; const { max, smoothing } = opts.current; const k = 1 - Math.exp(-dt / Math.max(0.05, smoothing)); const next = tps.get() + (observed - tps.get()) * k; if (next < 0.05) { tps.set(0); rate.set(0); frame.current = 0; return; } tps.set(next); rate.set(Math.min(1, next / max)); frame.current = requestAnimationFrame(step); }; frame.current = requestAnimationFrame(step); }, [source, charsPerToken, tps, rate]); useEffect( () => () => { cancelAnimationFrame(frame.current); frame.current = 0; }, [], ); return { tps, rate }; } 6a:Tc7e,"use client"; import { useEffect, useState } from "react"; export type UseStatusCarouselOptions = { /** * A real status. While set it is shown instead of the rotation, at once; when it clears the * rotation resumes where it left off. Use it for "Reading stripe.com…" from a tool event. */ status?: string | null; /** * Milliseconds each line stays. Default: by length, 2.2s plus 45ms a character, capped at * 4s, so a long line can be read and a short one does not linger. */ interval?: number | ((line: string) => number); /** Stop rotating (keeps the current line). Default false. */ paused?: boolean; /** Start over at the first line when the lines change. Default true. */ restartOnChange?: boolean; /** Cycle back to the first line after the last. Default false: hold on the last line. */ loop?: boolean; }; const byLength = (line: string) => Math.min(4000, 2200 + line.length * 45); /** * The line to show from a rotating set of status lines ("Pondering…", "Reading the diff…"), * interrupted by a real `status` whenever there is one. By default it holds on the last line * instead of looping back, since a status that repeats reads as stuck; set `loop` for * ambient lines that may cycle. It does not advance while the tab is hidden. Render the result * through Text Swap or Shimmer Text so each change is a swap, not a pop. * * const line = useStatusCarousel(["Searching…", "Reading 4 pages…", "Comparing…"], { status }); * {line} */ export function useStatusCarousel(lines: readonly string[], { status, interval, paused = false, restartOnChange = true, loop = false }: UseStatusCarouselOptions = {}): string { const [index, setIndex] = useState(0); // Compared by content, so an inline array literal does not restart the rotation every render. const linesKey = lines.join("\u0000"); const [source, setSource] = useState(linesKey); // Adjust state while rendering when the lines change (no effect, no flash of the old line). if (source !== linesKey) { setSource(linesKey); if (restartOnChange) setIndex(0); } const i = Math.min(index, Math.max(0, lines.length - 1)); const line = lines[i] ?? ""; const hold = status ? null : typeof interval === "function" ? interval(line) : (interval ?? byLength(line)); const atEnd = lines.length < 2 || (!loop && i >= lines.length - 1); useEffect(() => { if (hold === null || paused || atEnd) return; let timer = 0; let remaining = hold; let since = performance.now(); const arm = () => { since = performance.now(); timer = window.setTimeout(() => setIndex((n) => (n + 1) % lines.length), remaining); }; const onVisibility = () => { if (document.hidden) { clearTimeout(timer); remaining = Math.max(0, remaining - (performance.now() - since)); } else arm(); }; if (!document.hidden) arm(); document.addEventListener("visibilitychange", onVisibility); return () => { clearTimeout(timer); document.removeEventListener("visibilitychange", onVisibility); }; }, [hold, paused, atEnd, i, lines.length]); return status || line; } 63:["$","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"}]]}]}]]}],["$","$L64",null,{"namespace":"@registrydirectory","registryDependencies":["https://eased.dev/r/eased-tokens.json"]}]]}],null]}],["$","$L65",null,{"files":[{"path":"src/registry/eased/_primitives/thinking-core/thinking-core.ts","content":"/**\n * P11 thinking-core: the clocks, models and contracts shared by every Eased thinking state\n * (Shimmer Text, Thinking Bar, Agent Orb, Step Rail, Reasoning, Tool Call Row, Agent Run).\n * Import from here; the files behind it may move.\n */\nexport {\n SETTLED_STEP,\n SETTLED_TOOL,\n toolStateFromPart,\n type AISDKToolPartState,\n type Step,\n type StepStatus,\n type ToolState,\n} from \"./types\";\nexport { advanceSteps, summarizeSteps, updateStep, type StepSummary } from \"./steps\";\nexport { formatElapsed, useElapsed, type UseElapsedOptions } from \"./use-elapsed\";\nexport { useTokenRate, type TokenRate, type UseTokenRateOptions } from \"./use-token-rate\";\nexport { useStatusCarousel, type UseStatusCarouselOptions } from \"./use-status-carousel\";\n","type":"registry:ui","target":"@components/eased/_primitives/thinking-core/thinking-core.ts"},{"path":"src/registry/eased/_primitives/thinking-core/types.ts","content":"$66","type":"registry:ui","target":"@components/eased/_primitives/thinking-core/types.ts"},{"path":"src/registry/eased/_primitives/thinking-core/steps.ts","content":"$67","type":"registry:ui","target":"@components/eased/_primitives/thinking-core/steps.ts"},{"path":"src/registry/eased/_primitives/thinking-core/use-elapsed.ts","content":"$68","type":"registry:ui","target":"@components/eased/_primitives/thinking-core/use-elapsed.ts"},{"path":"src/registry/eased/_primitives/thinking-core/use-token-rate.ts","content":"$69","type":"registry:ui","target":"@components/eased/_primitives/thinking-core/use-token-rate.ts"},{"path":"src/registry/eased/_primitives/thinking-core/use-status-carousel.ts","content":"$6a","type":"registry:ui","target":"@components/eased/_primitives/thinking-core/use-status-carousel.ts"}],"className":"h-[70svh] min-h-80"}]]}]