4e: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/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.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"] 4f: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/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.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"] 50:Te04,"use client"; // Renders children into a different place in the document (defaults to // ) and takes them out again on unmount. // // The Svelte counterpart is an action that MOVES an already-rendered node; // `createPortal` RENDERS INTO the target instead. Same resulting DOM, a // different route — and two consequences worth stating out loud: // // * There is no "portal before focus-trap" ordering hazard here. React // commits portalled children into the container before any effect runs // and populates refs before layout effects, so a node is always connected // by the time anything focuses it. The Svelte action had to be applied // first or `.focus()` was a silent no-op on a detached node. // * SYNTHETIC events still bubble through the React tree even though the // DOM node lives elsewhere, where a moved node's native events stop at // . Inert in practice: `useDismissable` listens natively on // `document`, and no compound root that owns a portalled surface renders // handlers of its own. // // Usage: //

…

// … // … import { useState } from "react"; import type { ReactElement, ReactNode } from "react"; import { createPortal } from "react-dom"; import { useIsHydrated, useIsomorphicLayoutEffect } from "./dom/ssr"; export interface PortalProps { /** * Element, CSS selector, or undefined for `document.body`. A selector * matching nothing falls back to `document.body`. */ target?: HTMLElement | string; /** Render children in place instead of portalling. */ disabled?: boolean; children?: ReactNode; } /** * Resolves a portal target argument to an actual element. * Falls back to `document.body` when a string selector matches nothing. */ export function resolvePortalTarget(target?: HTMLElement | string): HTMLElement { if (target instanceof HTMLElement) { return target; } if (typeof target === "string") { const match = document.querySelector(target); if (match) { return match; } } return document.body; } /** * The mounted target, or `null` on the server and during the hydration * render. * * The gate is what makes a hydration mismatch structurally impossible: the * server emits nothing, the hydration render emits nothing, and the target is * only resolved once from a layout effect. It costs one extra client render * for a surface that is open during SSR — a case that does not occur, since * every portalled surface is gated on an `open` that starts false. * * Never a lazy `useState` initializer reading `document` (convention C-7). */ export function usePortalTarget(target?: HTMLElement | string): HTMLElement | null { const hydrated = useIsHydrated(); const [container, setContainer] = useState(null); useIsomorphicLayoutEffect(() => { if (!hydrated) return; setContainer(resolvePortalTarget(target)); }, [hydrated, target]); return hydrated ? container : null; } /** * Renders `children` into `target` for as long as it is mounted. * * SSR-safe: renders `null` on the server and during hydration, then portals. */ export function Portal({ target, disabled, children }: PortalProps): ReactElement | null { // Above the early returns, always — a conditional hook throws the first // time `disabled` flips (convention C-2). const container = usePortalTarget(target); if (disabled) return <>{children}; if (!container) return null; return createPortal(children, container); } 51:T768,"use client"; import type { CSSProperties, JSX } from "react"; import { cn } from "../utils"; import { useLiveRef } from "./dom/use-live-ref"; import { useIsomorphicLayoutEffect } from "./dom/ssr"; import { useTextStream } from "./use-text-stream"; import "./stream-text.css"; export interface StreamTextProps { /** The whole text so far. Hand over a longer string to stream more in. */ text: string; /** How long a newly arrived chunk stays tinted, in ms. */ settleMs?: number; /** Additional CSS classes */ className?: string; } /** * Renders `text`, tinting only the delta between renders while it settles. * * Built once from the first `text`/`settleMs` it sees — the server renders * the whole string as a single plain span, and only later growth animates — * mirroring the Svelte source's `untrack(() => createTextStream(...))`. The * push that reconciles the stream with a new `text` runs in a layout effect, * before paint, so a re-render never flashes the previous content for a * frame. */ export function StreamText({ text, settleMs = 350, className }: StreamTextProps): JSX.Element { // A live getter, read once per pushed chunk (never during render), so a // later `settleMs` reaches later chunks instead of only the CSS custom // property. const settleMsRef = useLiveRef(settleMs); const { segments, push } = useTextStream(text, { settleMs: () => settleMsRef.current }); useIsomorphicLayoutEffect(() => { // The first run pushes the text the stream was built from, which is a // no-op. push(text); }, [text, push]); return ( {segments.map((segment) => ( {segment.text} ))} ); } 52:Tda1,"use client"; /** * Shared data model for the AI component family. * * Every conversational and agent-activity component reads from these shapes, so * one message object can flow from a thread list into a transcript, a tool * timeline, or a citation card without translation at each boundary. Types only: * nothing here runs, imports, or touches the DOM. */ /** Who produced a turn in a conversation. */ export type ChatRole = "user" | "assistant" | "system"; /** Lifecycle of a token stream, from the first chunk to its terminal state. */ export type StreamStatus = "idle" | "streaming" | "done" | "error"; /** Lifecycle of anything the model kicks off and can finish, fail, or abandon. */ export type RunStatus = "pending" | "running" | "done" | "error" | "cancelled"; /** One conversation turn — consumed by message bubbles, transcripts, and branch switchers. */ export interface ChatMessageData { id: string; role: ChatRole; content: string; status?: StreamStatus; createdAt?: Date | number; branchIndex?: number; branchCount?: number; } /** A single tool invocation — consumed by tool-call cards and their input/output panels. */ export interface ToolCallData { id: string; name: string; status: RunStatus; input?: unknown; output?: unknown; error?: string; durationMs?: number; } /** A document backing an answer — consumed by source lists and inline citations. */ export interface SourceData { id: string; title: string; url: string; snippet?: string; domain?: string; } /** One hit from a web lookup — consumed by search-result surfaces. */ export interface SearchResultData { id: string; title: string; url: string; snippet?: string; } /** A file riding along with a turn — consumed by composer attachment chips and previews. */ export interface AttachmentData { id: string; name: string; size?: number; type?: string; previewUrl?: string; progress?: number; status?: "uploading" | "done" | "error"; } /** A node in an agent's plan — consumed by plan trees and task checklists, nests via `substeps`. */ export interface PlanStepData { id: string; label: string; status: RunStatus; detail?: string; substeps?: PlanStepData[]; } /** A delegated worker — consumed by subagent cards and fan-out activity views. */ export interface SubagentData { id: string; name: string; task: string; status: RunStatus; progress?: number; model?: string; } /** A conversation in the sidebar — consumed by thread lists and history pickers. */ export interface ThreadData { id: string; title: string; preview?: string; updatedAt: Date | number; unread?: boolean; } /** A selectable action — consumed by slash-command menus and command palettes. */ export interface CommandItemData { id: string; label: string; description?: string; hint?: string; } /** A model the user can switch to — consumed by model pickers in the composer. */ export interface ModelOptionData { id: string; label: string; badge?: string; description?: string; } /** Context-window consumption — consumed by token meters and context rings. */ export interface TokenUsageData { used: number; max: number; breakdown?: Array<{ label: string; tokens: number }>; } /** One line of agent activity — consumed by tool timelines that read as an action log. */ export interface ToolTimelineItemData { id: string; verb: string; target: string; detail?: string; additions?: number; deletions?: number; timestamp?: Date | number; } 53:T34ff,"use client"; // Framework-agnostic floating-element positioning: given an anchor rect and // the size of a floating element (popover / tooltip / menu), computes the // x/y coordinates that place it on the requested side, aligned against the // anchor, offset away from it, flipped to the opposite side when it would // overflow the viewport, and clamped so it never renders off-screen. // // `computePosition` is a pure function: it takes a DOMRect-shaped anchor and // plain dimensions, so it is fully testable without a DOM. `attachAnchorPosition` // is the framework-free core that wires it up to a live anchor element; the // React binding lives in `use-anchor-position.ts`. // // Usage: // const { x, y, side } = computePosition(anchorEl.getBoundingClientRect(), { width: 200, height: 40 }); // // const handle = attachAnchorPosition(node, { anchor: () => anchorEl, side: "bottom" }); export type Side = "top" | "bottom" | "left" | "right"; export type Align = "start" | "center" | "end"; export interface ComputePositionOptions { /** Side of the anchor to place the floating element on. Defaults to "bottom". */ side?: Side; /** Alignment along the cross axis of `side`. Defaults to "center". */ align?: Align; /** Gap in pixels between the anchor and the floating element. Defaults to 8. */ offset?: number; /** Viewport bounds used for flip/clamp. Defaults to `window` when available, otherwise unbounded (SSR). */ viewport?: { width: number; height: number }; /** Flip to the opposite side when the requested side would overflow the viewport. Defaults to true. */ flip?: boolean; } export interface ComputePositionResult { x: number; y: number; /** The side actually used, which may differ from the requested one when flipped. */ side: Side; /** * The cross-axis alignment the element actually ended up with, which * differs from the requested one whenever clamping slid it along that * axis. Read it — not the requested `align` — for anything that has to * point back at the anchor, such as a transform origin or a caret. */ align: Align; } const OPPOSITE_SIDE: Record = { top: "bottom", bottom: "top", left: "right", right: "left", }; function isHorizontalSide(side: Side): boolean { return side === "top" || side === "bottom"; } function clamp(value: number, min: number, max: number): number { return Math.max(min, Math.min(value, max)); } function getDefaultViewport(): { width: number; height: number } { if (typeof window !== "undefined") { return { width: window.innerWidth, height: window.innerHeight }; } // SSR fallback: no viewport to overflow against, so flip/clamp become no-ops. return { width: Number.POSITIVE_INFINITY, height: Number.POSITIVE_INFINITY }; } /** Whether placing the floating element on `side` would overflow the viewport. */ function overflows( side: Side, anchor: DOMRect, floating: { width: number; height: number }, offset: number, viewport: { width: number; height: number } ): boolean { switch (side) { case "top": return anchor.top - floating.height - offset < 0; case "bottom": return anchor.bottom + offset + floating.height > viewport.height; case "left": return anchor.left - floating.width - offset < 0; case "right": return anchor.right + offset + floating.width > viewport.width; } } /** Computes the raw (unclamped) x/y for `side` + `align`, before flip/clamp are applied. */ function placeAt( side: Side, anchor: DOMRect, floating: { width: number; height: number }, align: Align, offset: number ): { x: number; y: number } { if (isHorizontalSide(side)) { const y = side === "top" ? anchor.top - floating.height - offset : anchor.bottom + offset; let x: number; switch (align) { case "start": x = anchor.left; break; case "end": x = anchor.right - floating.width; break; default: x = anchor.left + anchor.width / 2 - floating.width / 2; } return { x, y }; } const x = side === "left" ? anchor.left - floating.width - offset : anchor.right + offset; let y: number; switch (align) { case "start": y = anchor.top; break; case "end": y = anchor.bottom - floating.height; break; default: y = anchor.top + anchor.height / 2 - floating.height / 2; } return { x, y }; } /** * Where the anchor's cross-axis centre falls inside the element as finally * placed, expressed in the same vocabulary as the requested `align`. * * The requested alignment cannot answer this: clamping moves x/y without * touching either input, so a menu asked for `align: "start"` next to the * viewport's right edge is reported as `start` while the anchor now sits by * its right edge. Deriving from the clamped coordinates keeps that honest. * The thirds are the natural split of the three-value vocabulary. */ function resolveAlign( side: Side, anchor: DOMRect, floating: { width: number; height: number }, x: number, y: number, requested: Align ): Align { const horizontal = isHorizontalSide(side); const extent = horizontal ? floating.width : floating.height; // A zero-size element has no inside for the anchor to fall in — an // unlaid-out first frame, a `display: none` ancestor, or jsdom, where // every element measures zero. Nothing was clamped in that state either, // so the requested alignment is both the honest answer and the one that // keeps a never-measured panel behaving exactly as it did before. if (extent <= 0) return requested; const anchorCentre = horizontal ? anchor.left + anchor.width / 2 : anchor.top + anchor.height / 2; const ratio = (anchorCentre - (horizontal ? x : y)) / extent; if (ratio < 1 / 3) return "start"; if (ratio > 2 / 3) return "end"; return "center"; } /** * Computes where to place a floating element relative to an anchor rect. * * Pure function — no DOM access, so it is testable with plain objects that * satisfy the `DOMRect` shape. */ export function computePosition( anchor: DOMRect, floating: { width: number; height: number }, opts: ComputePositionOptions = {} ): ComputePositionResult { const { side = "bottom", align = "center", offset = 8, flip = true } = opts; const viewport = opts.viewport ?? getDefaultViewport(); const resolvedSide = flip && overflows(side, anchor, floating, offset, viewport) ? OPPOSITE_SIDE[side] : side; const { x, y } = placeAt(resolvedSide, anchor, floating, align, offset); const maxX = Math.max(0, viewport.width - floating.width); const maxY = Math.max(0, viewport.height - floating.height); const clampedX = clamp(x, 0, maxX); const clampedY = clamp(y, 0, maxY); return { x: clampedX, y: clampedY, side: resolvedSide, align: resolveAlign(resolvedSide, anchor, floating, clampedX, clampedY, align), }; } export interface AnchorPositionOptions { /** Resolves the current anchor element. Called on every recompute so it can track a moving target. */ anchor: () => HTMLElement | null; side?: Side; align?: Align; offset?: number; /** * Called with the side the element was actually placed on, which differs * from the requested `side` whenever a flip occurred, and with the * cross-axis alignment it actually ended up with, which differs from the * requested `align` whenever clamping slid it along that axis. Fires once * on the initial placement and thereafter only when either resolved value * changes, so a consumer can react (move a caret, set a transform origin, * mirror a submenu's open direction) without re-rendering on every scroll * frame. * * Without this, `computePosition`'s resolved placement is computed and * discarded here, and a consumer has no way to learn a flip or a clamp * happened. */ onPlacement?: (side: Side, align: Align) => void; } export interface AnchorPositionHandle { /** Swaps the options and recomputes — the action's `update` under a new name. */ update(options: AnchorPositionOptions): void; /** Recomputes against the current options, for a caller that knows the geometry moved. */ recompute(): void; /** Detaches the scroll and resize listeners, and strips the position `update()` wrote. */ destroy(): void; } /** * Positions `node` with `position: fixed` against a live anchor element, using * `computePosition`. Recomputes on scroll and resize (passive, capturing * listeners so nested scroll containers are caught too) and cleans up its * listeners — and the position it wrote — on destroy. * * SSR-safe: does nothing when `window` is unavailable. */ export function attachAnchorPosition( node: HTMLElement, opts: AnchorPositionOptions ): AnchorPositionHandle { if (typeof window === "undefined") { return { update() {}, recompute() {}, destroy() {} }; } let options = opts; // The last placement reported through `onPlacement`, so a scroll or resize // that recomputes to the same one stays silent. `null` means "nothing // reported yet", which is distinct from any real value and makes the first // placement always fire. let reportedSide: Side | null = null; let reportedAlign: Align | null = null; /** * The floating element's size as LAID OUT, never as PAINTED. * * `getBoundingClientRect()` reports the box AFTER transforms, and every * anchored surface in this package is mid-entrance the first time this * runs. The presence clock pins `transform: scale(0.92)` on the panel in * the commit its node attaches; the node reaches this module one commit * later, because the transition takes it through a plain ref callback and * the position takes it through state. Measuring the painted box would * size the panel 8% small, place it that much off its anchor, and leave it * there — the entrance settles and nothing recomputes. * * `offsetWidth`/`offsetHeight` are layout metrics: a transform does not * touch them. They round to whole pixels, a quarter pixel of placement * against the several the transform costs. Zero means there is no layout * box to read — a detached node, a `display: none` ancestor, or jsdom, * where every element measures zero — so the rect answers for that case, * and the two agree everywhere else. */ function measureFloating(): { width: number; height: number } { const rect = node.getBoundingClientRect(); return { width: node.offsetWidth || rect.width, height: node.offsetHeight || rect.height, }; } function update(): void { const anchorEl = options.anchor(); if (!anchorEl) return; const anchorRect = anchorEl.getBoundingClientRect(); // Measured as the box it is about to become. Before the first update // a portalled node is a static block as wide as its container, so a // panel with no width of its own would centre on the full page width // and clamp to the left edge. Parked at the origin, a fixed box // shrinks to its content with the whole viewport to grow into, // wherever the last update left it. node.style.position = "fixed"; node.style.left = "0px"; node.style.top = "0px"; const { x, y, side, align } = computePosition(anchorRect, measureFloating(), { side: options.side, align: options.align, offset: options.offset, viewport: { width: window.innerWidth, height: window.innerHeight }, }); node.style.position = "fixed"; node.style.left = `${x}px`; node.style.top = `${y}px`; if (side !== reportedSide || align !== reportedAlign) { reportedSide = side; reportedAlign = align; options.onPlacement?.(side, align); } } // Everything `update()` wrote onto the node, cleared. // // DIVERGENCE from the Svelte action, deliberate. There, destroy runs only // when the element the action is attached to is itself being removed, so // leftover inline styles are unobservable. The React binding adds an // `enabled` option that tears this handle down while the node stays // mounted, and the same leftovers then read as a surface frozen at its // last computed coordinates — `position: fixed` at a stale left/top, over // content it no longer belongs to, until something re-enables it. Clearing // here also matches `FloatHandle.destroy()`, the sibling core, which // already promises to strip the node's own styles. function reset(): void { node.style.position = ""; node.style.left = ""; node.style.top = ""; } update(); window.addEventListener("scroll", update, { passive: true, capture: true }); window.addEventListener("resize", update, { passive: true }); return { update(newOpts: AnchorPositionOptions) { // A new `onPlacement` is a new listener that has never been told // anything, so it gets a report even if the side did not move. // Without this, the idiomatic call site — an inline arrow in the // options object, rebuilt on every re-render — silently never // fires after the first one: `reportedSide` is scoped to the node, // not to the callback, so the gate that exists to suppress // duplicate reports to the *same* listener ends up suppressing the // first report to a *different* one. Unreachable from the React // hook, whose `onPlacement` goes through `useEventCallback` and so // keeps one identity for the life of the component; kept because // the core is public to any caller that hands over a fresh arrow. if (newOpts.onPlacement !== options.onPlacement) { reportedSide = null; reportedAlign = null; } options = newOpts; update(); }, recompute() { update(); }, destroy() { window.removeEventListener("scroll", update, { capture: true }); window.removeEventListener("resize", update); reset(); }, }; } 54:Tdba,"use client"; // Pure calendar math shared by date-picker style components. Everything here // operates on native `Date` objects in local time and has no DOM dependency, // so it is trivially unit-testable and safe to call during SSR. // // Usage: // const weeks = getMonthGrid(2024, 1); // February 2024, 6 weeks x 7 days export type WeekStartsOn = 0 | 1; export interface MonthGridDay { date: Date; /** False for the leading/trailing days that pad the grid but belong to an adjacent month. */ inMonth: boolean; } const DAYS_IN_WEEK = 7; const WEEKS_IN_GRID = 6; /** * Builds a 6-week x 7-day grid for `month` (0-11) of `year`, padded with the * trailing days of the previous month and the leading days of the next one * so every week is complete. * * @param weekStartsOn - 0 for Sunday, 1 for Monday. Defaults to 0. */ export function getMonthGrid( year: number, month: number, weekStartsOn: WeekStartsOn = 0 ): MonthGridDay[][] { // Normalize through Date so out-of-range month values (e.g. 12) resolve // the same way the rest of this module treats them. const reference = new Date(year, month, 1); const firstWeekday = reference.getDay(); const leadingDays = (firstWeekday - weekStartsOn + 7) % 7; const gridStart = new Date(reference.getFullYear(), reference.getMonth(), 1 - leadingDays); const days: MonthGridDay[] = []; for (let i = 0; i < WEEKS_IN_GRID * DAYS_IN_WEEK; i++) { const date = new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + i); days.push({ date, inMonth: date.getMonth() === reference.getMonth() && date.getFullYear() === reference.getFullYear(), }); } const weeks: MonthGridDay[][] = []; for (let w = 0; w < WEEKS_IN_GRID; w++) { weeks.push(days.slice(w * DAYS_IN_WEEK, (w + 1) * DAYS_IN_WEEK)); } return weeks; } /** * Returns a new date `n` months away from `date`. Clamps the day-of-month to * the target month's length instead of letting it roll over (e.g. Jan 31 + 1 * month lands on Feb 28/29, not Mar 2/3). */ export function addMonths(date: Date, n: number): Date { const day = date.getDate(); // Move to day 1 first so setMonth can't overflow into an unrelated month. const result = new Date(date); result.setDate(1); result.setMonth(result.getMonth() + n); const daysInTargetMonth = new Date(result.getFullYear(), result.getMonth() + 1, 0).getDate(); result.setDate(Math.min(day, daysInTargetMonth)); result.setHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()); return result; } /** Whether `a` and `b` fall on the same calendar day (year/month/date), ignoring time. */ export function isSameDay(a: Date, b: Date): boolean { return ( a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate() ); } /** Clamps `date` into the `[min, max]` range (either bound optional). Always returns a new Date. */ export function clampDate(date: Date, min?: Date, max?: Date): Date { if (min && date.getTime() < min.getTime()) { return new Date(min); } if (max && date.getTime() > max.getTime()) { return new Date(max); } return new Date(date); } /** Formats `date` as a "YYYY-MM-DD" string using its local date components. */ export function formatISODate(date: Date): string { const year = date.getFullYear().toString().padStart(4, "0"); const month = (date.getMonth() + 1).toString().padStart(2, "0"); const day = date.getDate().toString().padStart(2, "0"); return `${year}-${month}-${day}`; } 55:T1e49,"use client"; /** * Unified diff parser. * * Total and side-effect free: every input yields a value and nothing throws. * Malformed, truncated or headerless patches degrade to a best-effort reading, * so a patch that is still streaming in can be re-parsed on every chunk. */ export type DiffLineType = "add" | "del" | "context" | "meta"; /** * One line of a hunk. `text` drops the leading `+`/`-`/space marker; `meta` * lines (`\ No newline at end of file`) keep their raw text. A line number is * null on the side where the line does not exist. */ export interface DiffLine { type: DiffLineType; text: string; oldLine: number | null; newLine: number | null; } export interface DiffHunk { header: string; oldStart: number; oldCount: number; newStart: number; newCount: number; lines: DiffLine[]; } export interface DiffFile { oldPath: string | null; newPath: string | null; hunks: DiffHunk[]; additions: number; deletions: number; isNew: boolean; isDeleted: boolean; isRename: boolean; } const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/; const FILE_HEADER = /^(?:---|\+\+\+) /; const GIT_HEADER = "diff --git "; interface State { files: DiffFile[]; file: DiffFile | null; hunk: DiffHunk | null; oldLine: number; newLine: number; remainingOld: number; remainingNew: number; } function isBodyLine(line: string): boolean { const marker = line.charAt(0); return marker === "+" || marker === "-" || marker === " "; } /** Drops trailing timestamp metadata, surrounding quotes and the `a/` `b/` prefixes. */ function cleanPath(raw: string, stripAffix: boolean): string | null { let path = raw.replace(/\s+$/, ""); const tab = path.indexOf("\t"); if (tab !== -1) path = path.slice(0, tab).replace(/\s+$/, ""); if (path.length > 1 && path.startsWith('"') && path.endsWith('"')) path = path.slice(1, -1); if (path === "/dev/null" || path === "") return null; if (stripAffix && (path.startsWith("a/") || path.startsWith("b/"))) path = path.slice(2); return path === "" ? null : path; } function gitHeaderPaths(line: string): [string | null, string | null] { const rest = line.slice(GIT_HEADER.length); // Greedy on purpose: a path may itself contain " b/". const paired = /^a\/(.*) b\/(.*)$/.exec(rest); // Both groups exist whenever the pattern matched at all. if (paired) return [cleanPath(paired[1]!, false), cleanPath(paired[2]!, false)]; const parts = rest.split(" "); if (parts.length < 2) return [null, null]; // `parts[0]` exists: the length check on the line above passed. return [cleanPath(parts[0]!, true), cleanPath(parts.slice(1).join(" "), true)]; } function openFile(state: State): DiffFile { const file: DiffFile = { oldPath: null, newPath: null, hunks: [], additions: 0, deletions: 0, isNew: false, isDeleted: false, isRename: false, }; state.files.push(file); state.file = file; state.hunk = null; return file; } function currentFile(state: State): DiffFile { return state.file ?? openFile(state); } function openHunk(state: State, hunk: DiffHunk): void { currentFile(state).hunks.push(hunk); state.hunk = hunk; state.oldLine = hunk.oldStart; state.newLine = hunk.newStart; state.remainingOld = hunk.oldCount; state.remainingNew = hunk.newCount; } function appendBody(state: State, raw: string): void { const hunk = state.hunk; const file = state.file; if (!hunk || !file) return; const marker = raw.charAt(0); const known = marker === "+" || marker === "-" || marker === " "; const text = known ? raw.slice(1) : raw; if (marker === "+") { hunk.lines.push({ type: "add", text, oldLine: null, newLine: state.newLine++ }); file.additions++; if (state.remainingNew > 0) state.remainingNew--; return; } if (marker === "-") { hunk.lines.push({ type: "del", text, oldLine: state.oldLine++, newLine: null }); file.deletions++; if (state.remainingOld > 0) state.remainingOld--; return; } // Space, empty, or anything unrecognised inside a hunk: treated as context. hunk.lines.push({ type: "context", text, oldLine: state.oldLine++, newLine: state.newLine++ }); if (state.remainingOld > 0) state.remainingOld--; if (state.remainingNew > 0) state.remainingNew--; } export function parseUnifiedDiff(src: string): DiffFile[] { if (typeof src !== "string" || src.trim() === "") return []; const state: State = { files: [], file: null, hunk: null, oldLine: 0, newLine: 0, remainingOld: 0, remainingNew: 0, }; const lines = src.split(/\r?\n/); if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop(); for (const raw of lines) { if (state.hunk) { if (raw.startsWith("\\")) { state.hunk.lines.push({ type: "meta", text: raw, oldLine: null, newLine: null }); continue; } // `---`/`+++` are ambiguous with content, so only unmistakable // boundaries end a hunk early; otherwise the declared counts do. Once // the counts are spent they stop being ambiguous: concatenated `diff -u` // output has no `diff --git` separator, and its next file announces // itself with exactly those two headers. const budget = state.remainingOld > 0 || state.remainingNew > 0; const boundary = raw.startsWith(GIT_HEADER) || HUNK_HEADER.test(raw) || (!budget && FILE_HEADER.test(raw)); if (!boundary && (budget || isBodyLine(raw))) { appendBody(state, raw); continue; } state.hunk = null; } const header = HUNK_HEADER.exec(raw); if (header) { openHunk(state, { header: raw, oldStart: Number(header[1]), oldCount: header[2] === undefined ? 1 : Number(header[2]), newStart: Number(header[3]), newCount: header[4] === undefined ? 1 : Number(header[4]), lines: [], }); continue; } if (raw.startsWith("@@")) continue; if (raw.startsWith(GIT_HEADER)) { const file = openFile(state); [file.oldPath, file.newPath] = gitHeaderPaths(raw); continue; } if (raw.startsWith("--- ")) { // A bare `---` with no `diff --git` above it starts the next file. const file = !state.file || state.file.hunks.length > 0 ? openFile(state) : state.file; file.oldPath = cleanPath(raw.slice(4), true); if (file.oldPath === null) file.isNew = true; continue; } if (raw.startsWith("+++ ")) { const file = currentFile(state); file.newPath = cleanPath(raw.slice(4), true); if (file.newPath === null) file.isDeleted = true; continue; } if (raw.startsWith("rename from ")) { const file = currentFile(state); file.isRename = true; file.oldPath = cleanPath(raw.slice("rename from ".length), false); continue; } if (raw.startsWith("rename to ")) { const file = currentFile(state); file.isRename = true; file.newPath = cleanPath(raw.slice("rename to ".length), false); continue; } // A binary add or delete carries no `--- /dev/null` / `+++ /dev/null` to // clear the path the git header already copied onto both sides, so the mode // marker has to do it: `{ isNew: true, oldPath: "new.bin" }` is nonsense. if (raw.startsWith("new file mode")) { const file = currentFile(state); file.isNew = true; file.oldPath = null; continue; } if (raw.startsWith("deleted file mode")) { const file = currentFile(state); file.isDeleted = true; file.newPath = null; continue; } if (isBodyLine(raw)) { openHunk(state, { header: "", oldStart: 1, oldCount: 0, newStart: 1, newCount: 0, lines: [], }); appendBody(state, raw); continue; } // Index lines, binary notices and prose between files are ignored. } return state.files.filter( (file) => file.hunks.length > 0 || file.oldPath !== null || file.newPath !== null || file.isNew || file.isDeleted || file.isRename ); } 56:T3494,"use client"; // Calls `onDismiss` when the user presses Escape and/or clicks outside of the // node. Both triggers are on by default and can be disabled individually. // `exclude` lets callers ignore extra elements that live outside the node but // should not count as "outside" (e.g. a trigger button that toggles the // dismissable element). // // `attachDismissable` is the framework-free core with the action's exact // body; `useDismissable` is the React binding on top of it. The nested-overlay // contract — the layer stack, the downward scan past inactive layers, and the // order of the `isActive()` guard against `stopImmediatePropagation()` — lives // entirely in the core and must not drift. import { useCallback, useEffect, useRef } from "react"; import type { ElementRef } from "./dom/types"; import { useEventCallback } from "./dom/use-event-callback"; import { useLiveRef } from "./dom/use-live-ref"; export interface DismissableCoreOptions { /** Called when the node should be dismissed. */ onDismiss: () => void; /** Whether pressing Escape dismisses. Defaults to true. */ escape?: boolean; /** Whether a pointerdown outside the node dismisses. Defaults to true. */ outsideClick?: boolean; /** Elements to ignore when detecting outside clicks (e.g. a trigger button). */ exclude?: () => (HTMLElement | null)[]; /** * Whether this layer is still the live one. A GETTER, not a boolean, and * read fresh on every Escape and every outside pointerdown, so a layer * that goes inactive stops answering without anything having to hand the * core a new value first. * * Every overlay that animates its exit passes its `open`. The moment * `open` flips false the layer stops answering Escape AND stops counting * as the top layer, so a second Escape during the fade is a no-op and the * dialog underneath gets it instead of having it swallowed by a panel that * is already leaving. Defaults to always-active. */ active?: () => boolean; /** * Whether an outside press that dismisses should keep the focus the * overlay hands back. Defaults to false. Only an overlay that returns focus * to a trigger on dismiss passes true (dialog, sheet, drawer, popover, menu, * command menu). A panel anchored to an input that keeps focus while it is * open (combobox, autocomplete) leaves it off: there the press must blur * the input as usual, or the field stays focused, a focus-to-open field * never reopens on the next click, and a touch keyboard stays up. * * With `outsideClick: false` it also keeps focus that is inside the layer * through an outside press that does not dismiss, so a modal that ignores * such presses does not lose focus to ``. That case cancels every * outside mousedown while the layer holds focus, so only a modal layer may * combine the two: a non-modal one that ignores outside presses (a * non-dismissible popover) leaves `keepFocus` off and the page untouched. */ keepFocus?: boolean; } // Stack of currently mounted dismissable layers. With nested overlays (e.g. a // popover inside a dialog) only the top-most layer reacts to Escape or an // outside pointerdown, so one interaction closes one layer at a time. // // A layer stays on this stack for as long as its node is mounted — which, for // an overlay that animates its exit, is the whole length of the fade, because // the surface is kept mounted through its exit leg. So "on the stack" and // "live" are two different things, and each entry carries its own liveness // getter to tell them apart. interface Layer { node: HTMLElement; isActive: () => boolean; } const layers: Layer[] = []; // What a mousedown can move focus to by itself. A press on anything else — // plain text, a scrim, empty page — makes the browser blur to ``. const FOCUS_TAKING_SELECTOR = 'a[href], area[href], button, input, select, textarea, label, summary, iframe, [tabindex], [contenteditable]:not([contenteditable="false"])'; // An outside press dismisses on `pointerdown`, and an overlay with `keepFocus` // hands focus back (to its trigger) right then — but the press's own // `mousedown` comes after, and on a target that cannot take focus its default // action blurs whatever is focused to ``, undoing the return a moment // after it happened. Cancelling that ONE default keeps the returned focus. A // press on something focusable is left alone: focus moving there is what the // user asked for. // // The guard must never outlive its press. It disarms on the first of: // - mousedown (the default it exists to cancel), click, pointercancel; // - contextmenu (a touch long-press can open the menu with neither a click // nor a pointercancel); // - a mouse pointerup, one microtask later (a mouse press dispatches its // mousedown before pointerup, so none is coming); // - a timeout after a touch or pen pointerup, whose compatibility mousedown // arrives AFTER pointerup and so has to be waited for, but not forever. const TOUCH_MOUSEDOWN_WINDOW_MS = 750; function keepFocusThroughPress(target: Node) { const el = target instanceof Element ? target : target.parentElement; if (el?.closest(FOCUS_TAKING_SELECTOR)) return; let timer: ReturnType | undefined; let armed = true; function preventBlur(event: Event) { event.preventDefault(); disarm(); } function handlePointerup(event: Event) { const pointerType = (event as PointerEvent).pointerType; if (pointerType === "touch" || pointerType === "pen") { clearTimeout(timer); timer = setTimeout(disarm, TOUCH_MOUSEDOWN_WINDOW_MS); } else { queueMicrotask(disarm); } } function disarm() { if (!armed) return; armed = false; clearTimeout(timer); document.removeEventListener("mousedown", preventBlur, true); document.removeEventListener("click", disarm, true); document.removeEventListener("pointercancel", disarm, true); document.removeEventListener("contextmenu", disarm, true); document.removeEventListener("pointerup", handlePointerup, true); } document.addEventListener("mousedown", preventBlur, true); document.addEventListener("click", disarm, true); document.addEventListener("pointercancel", disarm, true); document.addEventListener("contextmenu", disarm, true); document.addEventListener("pointerup", handlePointerup, true); } export interface DismissableHandle { /** Swaps the options in place — the action's `update` under a new name. */ update(options: DismissableCoreOptions): void; /** Pops this layer off the stack and detaches the document listeners. */ destroy(): void; } /** * Registers `node` as a dismissable layer and wires the document listeners. * * SSR-safe: does nothing when `document` is unavailable. */ export function attachDismissable( node: HTMLElement, opts: DismissableCoreOptions ): DismissableHandle { if (typeof document === "undefined") { return { update() {}, destroy() {} }; } let onDismiss = opts.onDismiss; let escape = opts.escape ?? true; let outsideClick = opts.outsideClick ?? true; let exclude = opts.exclude; let isActive = opts.active ?? (() => true); let keepFocus = opts.keepFocus ?? false; // Scans DOWN past inactive layers rather than testing only the last entry: // a closing panel is still ON the stack (it stays mounted for its exit), // it just must not be TOP of it. The first live layer found from the top // is the one that owns the interaction. function isTopLayer(): boolean { for (let i = layers.length - 1; i >= 0; i -= 1) { const candidate = layers[i]!; if (candidate.isActive()) return candidate.node === node; } return false; } function handleKeydown(event: KeyboardEvent) { // Before `stopImmediatePropagation()`, deliberately: an inactive layer // must not swallow the key on its way to whatever is underneath. if (!isActive()) return; if (!escape) return; if (event.key !== "Escape") return; if (!isTopLayer()) return; event.stopImmediatePropagation(); onDismiss(); } function handlePointerdown(event: PointerEvent) { if (!isActive()) return; if (!outsideClick && !keepFocus) return; if (!isTopLayer()) return; const target = event.target as Node | null; if (!target || node.contains(target)) return; const excluded = exclude?.() ?? []; if (excluded.some((el) => el?.contains(target))) return; if (!outsideClick) { // A layer that ignores outside presses (an alert dialog) still owns // the focus it holds: a press on its scrim or on plain page text // must not blur that focus out of the panel to . if (node.contains(document.activeElement)) keepFocusThroughPress(target); return; } if (keepFocus) keepFocusThroughPress(target); onDismiss(); } const layer: Layer = { node, isActive: () => isActive() }; layers.push(layer); document.addEventListener("keydown", handleKeydown); document.addEventListener("pointerdown", handlePointerdown); return { update(newOpts: DismissableCoreOptions) { onDismiss = newOpts.onDismiss; escape = newOpts.escape ?? true; outsideClick = newOpts.outsideClick ?? true; exclude = newOpts.exclude; isActive = newOpts.active ?? (() => true); keepFocus = newOpts.keepFocus ?? false; }, destroy() { // Spliced BY IDENTITY, so a StrictMode double cycle // (push → splice → push) leaves a stack of one at the same depth. const i = layers.indexOf(layer); if (i !== -1) layers.splice(i, 1); document.removeEventListener("keydown", handleKeydown); document.removeEventListener("pointerdown", handlePointerdown); }, }; } /** Test-only. Not exported from index.ts. */ export function __dismissableLayerCount(): number { return layers.length; } export interface DismissableOptions { /** Called when the node should be dismissed. */ onDismiss: () => void; /** Escape dismisses. Default true. */ escape?: boolean; /** A pointerdown outside dismisses. Default true. */ outsideClick?: boolean; /** * Elements that do not count as "outside" — typically the trigger. An * array of nodes or refs, resolved at event time, or the getter form for * a genuinely dynamic set. */ exclude?: | Array | HTMLElement | null | undefined> | (() => (HTMLElement | null)[]); /** * Whether this layer is still LIVE. Pass the surface's `open`. Default true. * * A plain boolean where the core takes a getter: React re-renders the * still-mounted exiting surface normally, so the hook can hold the current * value in a live ref and hand the core a getter over it. Semantics are * unchanged — a layer stays ON the stack for its whole exit and stops * being TOP of it the instant `active` flips. */ active?: boolean; /** * Keep the focus the overlay hands back through a dismissing outside press. * Default false; only an overlay that returns focus to a trigger passes * true. See the core option of the same name. */ keepFocus?: boolean; /** Whether the layer is registered at all. Default true. */ enabled?: boolean; } /** * Dismissable behaviour for `node`. * * Returns nothing: this hook owns behaviour, not state — nothing it does is * rendered, so neither `useState` nor `useSyncExternalStore` has any part in * it. * * A passive effect, not a layout one: the layer push and the two document * listeners are invisible in the first painted frame, and no key can be * pressed before they land. */ export function useDismissable(node: HTMLElement | null, options: DismissableOptions): void { const { escape = true, outsideClick = true, active = true, keepFocus = false, enabled = true, } = options; const onDismiss = useEventCallback(options.onDismiss); const activeRef = useLiveRef(active); const excludeRef = useLiveRef(options.exclude); const escapeRef = useLiveRef(escape); const outsideClickRef = useLiveRef(outsideClick); const keepFocusRef = useLiveRef(keepFocus); // Getter closures over the live refs, with an identity that never changes: // the layer's `isActive()` and both handlers read the current render's // values with zero listener churn. const getActive = useCallback(() => activeRef.current, [activeRef]); const getExclude = useCallback((): (HTMLElement | null)[] => { const exclude = excludeRef.current; if (!exclude) return []; if (typeof exclude === "function") return exclude(); return exclude.map((entry) => (entry && "current" in entry ? entry.current : (entry ?? null))); }, [excludeRef]); const handleRef = useRef(null); useEffect(() => { if (!node || !enabled) return; const handle = attachDismissable(node, { onDismiss, escape: escapeRef.current, outsideClick: outsideClickRef.current, exclude: getExclude, active: getActive, keepFocus: keepFocusRef.current, }); handleRef.current = handle; return () => { handleRef.current = null; handle.destroy(); }; }, [node, enabled, onDismiss, getActive, getExclude, escapeRef, outsideClickRef, keepFocusRef]); // `escape`, `outsideClick` and `keepFocus` are the options the core holds as // plain values rather than getters, so a change to any is pushed through // `update()` — which reassigns locals and touches no listener. useEffect(() => { handleRef.current?.update({ onDismiss, escape, outsideClick, exclude: getExclude, active: getActive, keepFocus, }); }, [escape, outsideClick, keepFocus, onDismiss, getActive, getExclude]); } 57:T1ddb,"use client"; /** * The contract between a FormField and whatever control it wraps. * * `FormField` owns the id, the label/help/error wiring and the required/ * disabled flags; every control in this wave (Input, Textarea, Checkbox, ...) * reads all of that through `useField()` instead of a caller threading ids * and aria attributes by hand. A control mounted outside a `FormField` * degrades to `undefined` — it must still work standalone, falling back to * its own props, exactly like `ToggleGroupItem` degrades outside a * `ToggleGroup`. * * `FieldContext` below is the frozen surface every other component in this * wave was built against — its shape must not change. `createFieldState` is * this file's own implementation detail: what `FormField` actually * constructs and publishes, and the only thing that changes if the wiring * inside `describedBy` ever needs to change. */ import { createContext, createElement, useContext } from "react"; import type { ReactNode } from "react"; /** What a `FormField` publishes to the control (and `Label`) it wraps. */ export interface FieldContext { /** * The id the labelled control must carry. Pair it with a native * `for`/`id` association — only meaningful for a control whose *root* is * one of the elements `` can target (button, input, meter, * output, progress, select, textarea). A control whose root is anything * else (a `