@westonkd/sprint 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,2544 @@
+import { ComponentPropsWithRef } from 'react';
+import { JSX } from 'react';
+import { MouseEventHandler } from 'react';
+import { Provider } from 'react';
+import { ReactNode } from 'react';
+import { Ref } from 'react';
+
+export declare function accessibleText(element: Element): string | undefined;
+
+export declare function afterCommit(): Promise<void>;
+
+export declare const AGENT_ATTRIBUTE = "data-sprint-agent";
+
+export declare interface AgentActionSpec {
+    description: string;
+    selector: string;
+    params?: Record<string, AgentPropSpec>;
+    idempotent?: boolean;
+}
+
+export declare interface AgentAttributeOptions {
+    part?: string;
+    state?: Record<string, AgentAttributeValue>;
+}
+
+export declare function agentAttributes(component: string, options?: AgentAttributeOptions): Record<string, string>;
+
+export declare function agentAttributesFor(node: AgentNode): Record<string, string>;
+
+export declare type AgentAttributeValue = string | number | boolean | null | undefined;
+
+export declare interface AgentComponentMeta {
+    name: string;
+    category: string;
+    summary: string;
+    whenToUse: string;
+    whenNotToUse?: string;
+    status: "experimental" | "stable" | "deprecated";
+    props: Record<string, AgentPropSpec>;
+    actions?: Record<string, AgentActionSpec>;
+    state?: Record<string, AgentStateSpec>;
+    examples: readonly AgentExample[];
+    tools?: Record<string, AgentToolSpec>;
+    agentView?: {
+        example: string;
+    };
+    a11y?: {
+        role?: string;
+        keyboard?: readonly string[];
+        notes?: string;
+    };
+    relatedComponents?: readonly string[];
+}
+
+export declare function AgentControl(props: AgentControlProps): JSX.Element;
+
+export declare function AgentControlGroup(props: AgentControlGroupProps): JSX.Element;
+
+export declare interface AgentControlGroupProps {
+    node: AgentNode;
+    onActivate: (part: AgentPart, index: number) => void;
+    isActionable?: (part: AgentPart, index: number) => boolean;
+    children?: ReactNode;
+}
+
+export declare type AgentControlProps = Omit<ComponentPropsWithRef<"button">, "children" | "ref" | "onClick"> & {
+    node: AgentNode;
+    as?: "button" | "a" | undefined;
+    href?: string | undefined;
+    target?: string | undefined;
+    rel?: string | undefined;
+    onClick?: MouseEventHandler<HTMLButtonElement> | MouseEventHandler<HTMLAnchorElement> | undefined;
+    ref?: Ref<HTMLButtonElement> | Ref<HTMLAnchorElement> | undefined;
+    children?: ReactNode;
+};
+
+export declare interface AgentExample {
+    title: string;
+    description?: string;
+    code: string;
+}
+
+export declare type AgentFormatter = (nodes: readonly AgentNode[]) => string;
+
+export declare function AgentLine(props: AgentLineProps): JSX.Element;
+
+export declare interface AgentLineProps {
+    node: AgentNode;
+    children?: ReactNode;
+}
+
+export declare interface AgentManifest {
+    library: string;
+    version: string;
+    conventions: {
+        componentAttribute: string;
+        partAttribute: string;
+        stateAttributePrefix: string;
+        toolAttribute: string;
+        ownerAttribute: string;
+        regionAttribute: string;
+        agentViewFormat: "markdown";
+        toolNaming: string;
+        toolOutputLimit: number;
+    };
+    components: readonly AgentComponentMeta[];
+}
+
+export declare interface AgentNode {
+    component: string;
+    summary?: string;
+    label?: string;
+    state: Record<string, AgentStateValue>;
+    parts: AgentPart[];
+    tool?: string;
+    owner?: string;
+    region?: true;
+    children: AgentNode[];
+    truncated?: true;
+}
+
+export declare interface AgentPart {
+    part: string;
+    label?: string;
+    state: Record<string, AgentStateValue>;
+    tool?: string;
+}
+
+export declare function agentPartAttributesFor(part: AgentPart): Record<string, string>;
+
+export declare function agentPartControlAttributes(component: string, part: AgentPart): Record<string, string>;
+
+export declare type AgentPropKind = "string" | "number" | "boolean" | "enum" | "node" | "handler" | "object" | "array";
+
+export declare interface AgentPropSpec {
+    kind: AgentPropKind;
+    description: string;
+    required?: boolean;
+    default?: unknown;
+    values?: readonly string[];
+    deprecated?: string;
+}
+
+export declare function AgentRegion(props: AgentRegionProps): JSX.Element;
+
+export declare interface AgentRegionProps {
+    children: ReactNode;
+    label: string;
+}
+
+export declare const AgentScopeProvider: Provider<AgentScopeValue>;
+
+export declare interface AgentScopeValue {
+    path: readonly string[];
+}
+
+export declare function agentSelector(component: string, part?: string): string;
+
+export declare interface AgentStateSpec {
+    description: string;
+    attribute: string;
+    values?: readonly string[];
+}
+
+export declare type AgentStateValue = string | true;
+
+export declare interface AgentToolSpec {
+    verb: string;
+    description: string;
+    inputSchema: JsonSchemaObject;
+    readOnly: boolean;
+    untrustedContent: boolean;
+    registeredWhen: string;
+    unregisteredWhen?: string;
+}
+
+export declare function Alert(props: AlertProps): JSX.Element;
+
+export declare const alertMeta: {
+    readonly name: "Alert";
+    readonly category: "feedback";
+    readonly summary: "A status message for the outcome of something that already happened: a notice, a warning, or a failure.";
+    readonly whenToUse: "Use to report the result of an action or a condition the person did not just cause: \"check your inbox\", \"invalid credentials\", \"this key expires soon\". Use tone=\"danger\" for failures, \"warning\" for conditions needing attention, \"info\" for neutral notices, and \"neutral\" for quiet confirmations. Pass onDismiss when the message can be acknowledged and cleared.";
+    readonly whenNotToUse: "Do not use for validation on a specific field; the field's own error prop places the message where the problem is. Do not use for confirmation of an action the person is about to take; that is a Dialog.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The message. Inline content only; it is flattened to text for the agent view.";
+            readonly required: true;
+        };
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "A short uppercase title above the message. Also derives the dismiss tool name, so prefer a stable phrase.";
+        };
+        readonly tone: {
+            readonly kind: "enum";
+            readonly description: "The message's severity. Danger and warning announce assertively; info and neutral announce politely.";
+            readonly values: readonly ["neutral", "info", "warning", "danger"];
+            readonly default: "info";
+        };
+        readonly onDismiss: {
+            readonly kind: "handler";
+            readonly description: "Called when the dismiss control is pressed. Providing it renders the control and registers the dismiss tool; the page owns removing the alert.";
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the dismiss tool name. Required for a dismissible alert with no label.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render a dismissible alert without registering a tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly tone: {
+            readonly description: "The alert's severity.";
+            readonly attribute: "data-sprint-tone";
+            readonly values: readonly ["neutral", "info", "warning", "danger"];
+        };
+        readonly dismissible: {
+            readonly description: "Present when the alert has a dismiss control.";
+            readonly attribute: "data-sprint-dismissible";
+        };
+    };
+    readonly tools: {
+        readonly dismiss: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Alert** \"Check your inbox\" [dismissible, tone=info]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A sign-in notice";
+        readonly description: "The default info tone for a neutral status message.";
+        readonly code: "<Alert label=\"Check your inbox\">We sent a sign-in link to nomad@escadrille.test.</Alert>";
+    }, {
+        readonly title: "A dismissible confirmation";
+        readonly description: "Providing onDismiss renders the dismiss control and registers the dismiss tool. Removing the alert is the page's job.";
+        readonly code: "<Alert tone=\"neutral\" label=\"Key revoked\" onDismiss={acknowledge}>The key can no longer authenticate.</Alert>";
+    }, {
+        readonly title: "A failure";
+        readonly description: "Danger announces assertively via role=alert.";
+        readonly code: "<Alert tone=\"danger\" label=\"Sign-in failed\">Wrong callsign or access code.</Alert>";
+    }];
+    readonly a11y: {
+        readonly role: "status";
+        readonly notes: "Danger and warning render role=alert and announce assertively; info and neutral render role=status. The dismiss control is a labelled button. Render the alert when the condition occurs rather than toggling its visibility, or the announcement is lost.";
+    };
+};
+
+export declare interface AlertProps extends ComponentPropsWithRef<"div"> {
+    tone?: AlertTone;
+    label?: string;
+    onDismiss?: () => void;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare type AlertTone = "neutral" | "info" | "warning" | "danger";
+
+export declare function buildAgentManifest(version: string): AgentManifest;
+
+export declare function buildAgentNode(input: NodeInput): AgentNode;
+
+export declare function Button(props: ButtonProps): JSX.Element;
+
+export declare const buttonMeta: {
+    readonly name: "Button";
+    readonly category: "action";
+    readonly summary: "A single action a person or an agent can trigger. Registers one press tool named from its own label.";
+    readonly whenToUse: "Use for any discrete action: submitting, confirming, dismissing, advancing a step. tone=\"action\" with block marks the one primary action in a view; tone=\"danger\" marks destructive actions.";
+    readonly whenNotToUse: "Do not use for navigation between pages; use a link. Do not use for toggling a persistent on/off state; that needs a switch or a checkbox.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The button label. Its text also derives the WebMCP tool name, so prefer a verb phrase like \"Prepare launch\" over \"OK\".";
+            readonly required: true;
+        };
+        readonly tone: {
+            readonly kind: "enum";
+            readonly description: "Visual and semantic weight. Acid is rationed to one primary action per view.";
+            readonly values: readonly ["neutral", "action", "danger"];
+            readonly default: "neutral";
+        };
+        readonly block: {
+            readonly kind: "boolean";
+            readonly description: "Render as a full-width bar. Combine with tone=\"action\" for the primary action of a region.";
+            readonly default: false;
+        };
+        readonly loading: {
+            readonly kind: "boolean";
+            readonly description: "Mark work in progress. Sets aria-busy, disables the control, and unregisters the press tool until it clears.";
+            readonly default: false;
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable the control and unregister its press tool.";
+            readonly default: false;
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name. Set this on icon-only buttons, when two buttons would otherwise collide, and whenever the visible label contains changing values such as a count.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the button without registering any WebMCP tool.";
+            readonly default: true;
+        };
+        readonly onClick: {
+            readonly kind: "handler";
+            readonly description: "Standard click handler. The press tool dispatches a real click, so this runs for agent presses too.";
+        };
+    };
+    readonly state: {
+        readonly tone: {
+            readonly description: "The button's current tone.";
+            readonly attribute: "data-sprint-tone";
+            readonly values: readonly ["neutral", "action", "danger"];
+        };
+        readonly block: {
+            readonly description: "Present when the button renders as a full-width bar.";
+            readonly attribute: "data-sprint-block";
+        };
+        readonly loading: {
+            readonly description: "Present while the button is busy.";
+            readonly attribute: "data-sprint-loading";
+        };
+        readonly disabled: {
+            readonly description: "Present when the button cannot be pressed.";
+            readonly attribute: "data-sprint-disabled";
+        };
+    };
+    readonly tools: {
+        readonly press: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Button** \"Prepare launch\" [tone=action] → tool `press-prepare-launch`";
+    };
+    readonly examples: readonly [{
+        readonly title: "Primary action";
+        readonly description: "The one rationed acid action bar for a view.";
+        readonly code: "<Button tone=\"action\" block onClick={prepare}>Prepare launch</Button>";
+    }, {
+        readonly title: "Destructive action";
+        readonly code: "<Button tone=\"danger\" onClick={purge}>Purge vault</Button>";
+    }, {
+        readonly title: "Busy state";
+        readonly description: "While loading the press tool is unregistered, so an agent cannot double-submit.";
+        readonly code: "<Button loading={saving} onClick={save}>Save loadout</Button>";
+    }, {
+        readonly title: "Disambiguating two identical labels";
+        readonly description: "Without agentName both buttons would claim press-save and neither would register a tool.";
+        readonly code: "<Button agentName=\"Save billing\">Save</Button>";
+    }, {
+        readonly title: "Keeping the tool name stable under a changing label";
+        readonly description: "A label carrying a value would otherwise rename the tool on every change, churning registration and staling any name an agent already holds.";
+        readonly code: "<Button agentName=\"Increment\">Increment ({count})</Button>";
+    }];
+    readonly a11y: {
+        readonly role: "button";
+        readonly keyboard: readonly ["Enter activates", "Space activates"];
+        readonly notes: "Loading sets aria-busy and disables the control. Focus is an offset keyline, never a rounded ring.";
+    };
+};
+
+export declare interface ButtonProps extends ComponentPropsWithRef<"button"> {
+    tone?: ButtonTone;
+    block?: boolean;
+    loading?: boolean;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare type ButtonTone = "neutral" | "action" | "danger";
+
+export declare function Card(props: CardProps): JSX.Element;
+
+export declare const cardMeta: {
+    readonly name: "Card";
+    readonly category: "navigation";
+    readonly summary: "One entry in a catalogue: a title, a line or two of body, and the whole block clickable. Give it an href and it is a link; give it onClick and it is an action that registers an open tool.";
+    readonly whenToUse: "Use it in a grid of comparable things a person picks between: components in a catalogue, results in a list, templates to start from. The title is the accessible name, so it is also what an agent selects on.";
+    readonly whenNotToUse: "Do not use it for a static region with a header; that is Panel. Do not put separate controls inside one, because the whole card is already a single control and nesting buttons inside a link is invalid.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "The card's title, and its accessible name. Also derives the tool name when the card acts.";
+            readonly required: true;
+        };
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "A line or two describing the entry. Carried in the agent view as the body part.";
+        };
+        readonly href: {
+            readonly kind: "string";
+            readonly description: "Destination, which makes the card a link. A card that navigates registers no tool by default.";
+        };
+        readonly onClick: {
+            readonly kind: "handler";
+            readonly description: "What clicking does. Alone it makes the card a button that registers an open tool by default. Alongside href the card stays a link and the handler rides the click, so a client-side router can intercept the navigation.";
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable an acting card and unregister its tool. Has no effect on a card that navigates.";
+            readonly default: false;
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Override the default: on for a card that acts, off for a card that navigates, because an agent can reach an href on its own.";
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name, when two cards share a title.";
+        };
+    };
+    readonly state: {
+        readonly href: {
+            readonly description: "Where the card goes, when it navigates.";
+            readonly attribute: "data-sprint-href";
+        };
+        readonly disabled: {
+            readonly description: "Present when the card cannot be opened.";
+            readonly attribute: "data-sprint-disabled";
+        };
+    };
+    readonly tools: {
+        readonly open: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Card** \"Button\" [href=#/Button]\n  - part `title` \"Button\"\n  - part `body` \"A single action a person or an agent can trigger.\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "A catalogue entry";
+        readonly description: "A card that navigates. No tool, because the href is already public.";
+        readonly code: "<Card label=\"Button\" href=\"#/Button\">\n  A single action a person or an agent can trigger.\n</Card>";
+    }, {
+        readonly title: "A card that acts";
+        readonly description: "onClick instead of href, so the card registers open-start-from-blank and an agent can take it.";
+        readonly code: "<Card label=\"Start from blank\" onClick={create}>\n  An empty page with the provider already wired up.\n</Card>";
+    }];
+    readonly a11y: {
+        readonly notes: "The whole block is one control: a link when it has an href, a button when it acts. The title names it, and the body is read as its content rather than as part of the name.";
+    };
+};
+
+export declare interface CardProps extends Omit<ComponentPropsWithRef<"button">, "ref" | "onClick" | "children"> {
+    label: string;
+    children?: ReactNode;
+    href?: string;
+    onClick?: MouseEventHandler<HTMLElement>;
+    disabled?: boolean;
+    agentTool?: boolean;
+    agentName?: string;
+    ref?: Ref<HTMLButtonElement> | Ref<HTMLAnchorElement>;
+}
+
+export declare function Checkbox(props: CheckboxProps): JSX.Element;
+
+export declare const checkboxMeta: {
+    readonly name: "Checkbox";
+    readonly category: "input";
+    readonly summary: "A single on/off choice recorded as form data. It registers one set tool that takes the end state rather than toggling.";
+    readonly whenToUse: "Use it for a boolean a form will submit: accepting terms, opting in, including something in a request. The set tool takes checked as true or false, so an agent states the end state and never has to read before writing.";
+    readonly whenNotToUse: "Do not use it for a setting that takes effect the moment it changes; that is a Switch. Do not use it for choosing one of several options, which is a SegmentedControl or a Select.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What checking it means. Names the box for a screen reader and derives the tool name, so prefer a statement such as \"Accept the terms\".";
+            readonly required: true;
+        };
+        readonly checked: {
+            readonly kind: "boolean";
+            readonly description: "Whether the box is checked. The box is fully controlled.";
+            readonly required: true;
+        };
+        readonly onChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the new checked state. The set tool drives a real click, so this runs for agent changes too.";
+            readonly required: true;
+        };
+        readonly hint: {
+            readonly kind: "string";
+            readonly description: "Guidance shown under the box and carried into the agent view. Replaced by error while one is set.";
+        };
+        readonly error: {
+            readonly kind: "string";
+            readonly description: "A validation message. Marks the box invalid for people, screen readers, and agents alike.";
+        };
+        readonly name: {
+            readonly kind: "string";
+            readonly description: "The native form name submitted with the surrounding form.";
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable the box and unregister its set tool.";
+            readonly default: false;
+        };
+        readonly required: {
+            readonly kind: "boolean";
+            readonly description: "Mark the box as one that must be checked.";
+            readonly default: false;
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name, when two boxes on a page would otherwise collide.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the box without registering a set tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly checked: {
+            readonly description: "Present while the box is checked.";
+            readonly attribute: "data-sprint-checked";
+        };
+        readonly disabled: {
+            readonly description: "Present when the box cannot be changed.";
+            readonly attribute: "data-sprint-disabled";
+        };
+        readonly required: {
+            readonly description: "Present when the box must be checked.";
+            readonly attribute: "data-sprint-required";
+        };
+        readonly invalid: {
+            readonly description: "Present while an error is set.";
+            readonly attribute: "data-sprint-invalid";
+        };
+    };
+    readonly tools: {
+        readonly set: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Checkbox** \"Accept the terms\" [required] → tool `set-accept-the-terms`\n  - part `error` \"Required before launch\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "A consent box";
+        readonly description: "In agent view the box renders as one control; pressing it toggles, while the set tool states the end state.";
+        readonly code: "<Checkbox\n  label=\"Accept the terms\"\n  checked={accepted}\n  onChange={setAccepted}\n  required\n/>";
+    }, {
+        readonly title: "An error on a required box";
+        readonly description: "The error marks the box invalid on every surface until it clears.";
+        readonly code: "<Checkbox\n  label=\"Confirm the manifest\"\n  checked={confirmed}\n  onChange={setConfirmed}\n  required\n  error=\"Confirm before launch.\"\n/>";
+    }, {
+        readonly title: "A disabled box";
+        readonly description: "Disabled unregisters the tool, so an agent cannot change what a person could not.";
+        readonly code: "<Checkbox\n  label=\"Telemetry\"\n  checked\n  disabled\n  onChange={setTelemetry}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "checkbox";
+        readonly keyboard: readonly ["Space toggles", "Tab moves through the box"];
+        readonly notes: "A native checkbox input wrapped by its label, visually replaced by a keylined square. Focus draws an offset keyline around the square; errors set aria-invalid and link with aria-describedby.";
+    };
+};
+
+export declare interface CheckboxProps extends Omit<ComponentPropsWithRef<"div">, "onChange"> {
+    label: string;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    hint?: string;
+    error?: string;
+    name?: string;
+    disabled?: boolean;
+    required?: boolean;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare function clamp(text: string, max: number): string;
+
+export declare const CLOSE_DIALOG_TOOL: AgentToolSpec;
+
+export declare function CodeBlock(props: CodeBlockProps): JSX.Element;
+
+export declare const codeBlockMeta: {
+    readonly name: "CodeBlock";
+    readonly category: "display";
+    readonly summary: "A snippet of code with a caption band and a copy control. In agent view the snippet is carried verbatim as the code part, so an agent reads the source instead of the highlighting.";
+    readonly whenToUse: "Use it for any code a reader is meant to run or copy: an install snippet, an example, a generated tool descriptor. It scrolls horizontally rather than wrapping, so a long line stays a long line.";
+    readonly whenNotToUse: "Do not use it for a short inline identifier inside a sentence; use a code element inside Text. Do not use it for prose you want to look technical.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly code: {
+            readonly kind: "string";
+            readonly description: "The snippet, verbatim. Newlines are preserved and this exact string is what an agent reads and what the copy control copies.";
+            readonly required: true;
+        };
+        readonly caption: {
+            readonly kind: "string";
+            readonly description: "What the snippet is, shown in the band above it and used as the block's accessible name. Defaults to the language.";
+        };
+        readonly language: {
+            readonly kind: "enum";
+            readonly description: "What the snippet is written in. Drives the caption default.";
+            readonly values: readonly ["tsx", "json", "bash", "text"];
+            readonly default: "tsx";
+        };
+        readonly copyLabel: {
+            readonly kind: "string";
+            readonly description: "Label for the copy control.";
+            readonly default: "Copy";
+        };
+    };
+    readonly state: {
+        readonly language: {
+            readonly description: "The language the snippet is in.";
+            readonly attribute: "data-sprint-language";
+            readonly values: readonly ["tsx", "json", "bash", "text"];
+        };
+        readonly lines: {
+            readonly description: "How many lines the snippet has.";
+            readonly attribute: "data-sprint-lines";
+        };
+        readonly copied: {
+            readonly description: "Present for a moment after the copy control has put the snippet on the clipboard.";
+            readonly attribute: "data-sprint-copied";
+        };
+        readonly token: {
+            readonly description: "On a highlight span: which token class it is. Colour comes from this, so a theme can recolour code without touching the component.";
+            readonly attribute: "data-sprint-token";
+            readonly values: readonly ["tag", "attr", "string", "keyword", "number", "punct", "comment"];
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **CodeBlock** \"install\" [language=bash, lines=1]\n  - part `copy` \"Copy\"\n  - part `code` \"npm install sprint\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "An example snippet";
+        readonly description: "No caption, so the language names the block. It registers no WebMCP tool: an agent has nothing to gain from putting text on a person's clipboard, and it can already read the code.";
+        readonly code: "<CodeBlock code={'<Button tone=\"action\">Prepare launch</Button>'} />";
+    }, {
+        readonly title: "A captioned descriptor";
+        readonly code: "<CodeBlock\n  caption=\"descriptor\"\n  language=\"json\"\n  code={JSON.stringify(descriptor, null, 2)}\n/>";
+    }];
+    readonly a11y: {
+        readonly notes: "The frame is a figure named by its caption. The copy control is a real button and reports back in its own label once the snippet is on the clipboard; the label swap is a polite live region, so a screen reader hears the confirmation too.";
+    };
+};
+
+export declare interface CodeBlockProps extends ComponentPropsWithRef<"figure"> {
+    code: string;
+    caption?: string;
+    language?: CodeLanguage;
+    copyLabel?: string;
+}
+
+export declare type CodeLanguage = "tsx" | "json" | "bash" | "text";
+
+export declare const COMPONENT_ATTRIBUTE = "data-sprint";
+
+export declare const defaultAgentFormat: AgentFormatter;
+
+export declare function defineAgentMeta<const T extends AgentComponentMeta>(meta: T): T;
+
+export declare interface DescriptionItem {
+    term: ReactNode;
+    description: ReactNode;
+}
+
+export declare function DescriptionList(props: DescriptionListProps): JSX.Element;
+
+export declare const descriptionListMeta: {
+    readonly name: "DescriptionList";
+    readonly category: "display";
+    readonly summary: "Labelled term–description pairs for the details of one thing: metadata, settings, profile fields.";
+    readonly whenToUse: "Use for the properties of a single entity: a token's created date and scopes, a session's device and last activity, a profile's fields. Each item pairs one term with one description.";
+    readonly whenNotToUse: "Do not use for many entities with the same fields; that is a Table. Do not put components inside term or description; both are flattened to text for the agent view, so only inline content survives. Do not use for prose sequences; that is a List.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "The accessible name for the list, describing what entity it details.";
+            readonly required: true;
+        };
+        readonly items: {
+            readonly kind: "array";
+            readonly description: "The pairs, in order. Each item is { term, description }; both are inline content flattened to text for the agent view.";
+            readonly required: true;
+        };
+        readonly emptyLabel: {
+            readonly kind: "string";
+            readonly description: "Text shown when items is empty. The region keeps its frame.";
+            readonly default: "Empty";
+        };
+    };
+    readonly state: {
+        readonly items: {
+            readonly description: "The number of pairs.";
+            readonly attribute: "data-sprint-items";
+        };
+        readonly empty: {
+            readonly description: "Present when there are no pairs.";
+            readonly attribute: "data-sprint-empty";
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **DescriptionList** \"Key sk-prod\" [items=2]";
+    };
+    readonly examples: readonly [{
+        readonly title: "Token metadata";
+        readonly code: "<DescriptionList\n  label=\"Key sk-prod\"\n  items={[\n    { term: \"Created\", description: \"2026-08-01\" },\n    { term: \"Last used\", description: \"2 hours ago\" },\n    { term: \"Scopes\", description: \"read, write\" },\n  ]}\n/>";
+    }, {
+        readonly title: "An empty list";
+        readonly description: "The region keeps its frame and states its emptiness.";
+        readonly code: "<DescriptionList label=\"Recovery codes\" items={[]} emptyLabel=\"None generated\" />";
+    }];
+    readonly a11y: {
+        readonly role: "definition list";
+        readonly notes: "Renders a native dl with an aria-label. Terms are dt elements and descriptions dd, so structure survives without styling.";
+    };
+};
+
+export declare interface DescriptionListProps extends ComponentPropsWithRef<"dl"> {
+    label: string;
+    items: readonly DescriptionItem[];
+    emptyLabel?: string;
+}
+
+export declare function Dialog(props: DialogProps): JSX.Element | null;
+
+export declare type DialogHeadingLevel = 2 | 3 | 4;
+
+export declare const dialogMeta: {
+    readonly name: "Dialog";
+    readonly category: "overlay";
+    readonly summary: "A modal that interrupts the page for one decision: confirm a destructive action, complete a short step, acknowledge something before continuing.";
+    readonly whenToUse: "Use when the page must not continue until the person decides: confirming a revocation or deletion, a short focused form, a required acknowledgement. Keep one decision per dialog and put its actions inside as ordinary Buttons; tools registered inside the dialog compose their names under its label.";
+    readonly whenNotToUse: "Do not use for status messages; that is an Alert. Do not use for anything the person should be able to ignore; a modal takes the whole page hostage. Do not nest dialogs.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "The dialog's title. Names the dialog for assistive tech, derives the close tool name, and scopes the names of tools registered inside.";
+            readonly required: true;
+        };
+        readonly open: {
+            readonly kind: "boolean";
+            readonly description: "Whether the dialog is shown. A closed dialog renders nothing at all; the page owns this state.";
+            readonly required: true;
+        };
+        readonly onClose: {
+            readonly kind: "handler";
+            readonly description: "Called when the person or an agent asks to close: the close control, Escape, or the close tool. Set open to false in response.";
+            readonly required: true;
+        };
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The dialog's contents. Ordinary components; anything actionable registers its own tools, scoped under the dialog's label.";
+            readonly required: true;
+        };
+        readonly headingLevel: {
+            readonly kind: "enum";
+            readonly description: "Render the title as a real heading at this level, joining the page outline.";
+            readonly values: readonly ["2", "3", "4"];
+        };
+        readonly owner: {
+            readonly kind: "string";
+            readonly description: "The tool name of the control that opened this dialog. Published as data-sprint-owner so a reading agent can attach the dialog to its opener.";
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the close tool name.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render without registering the close tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly open: {
+            readonly description: "Present while the dialog is shown. A closed dialog is absent from the DOM entirely.";
+            readonly attribute: "data-sprint-open";
+        };
+    };
+    readonly tools: {
+        readonly close: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Dialog** \"Revoke key\" [open] with part `close` → tool `close-revoke-key`";
+    };
+    readonly examples: readonly [{
+        readonly title: "A destructive confirmation";
+        readonly description: "The confirm Button registers its tool only while the dialog is open, and its name is scoped under the dialog's label.";
+        readonly code: "<Dialog label=\"Revoke key\" open={confirming} onClose={() => setConfirming(false)}>\n  <Stack gap=\"tight\">\n    <Text>The key stops authenticating immediately. This cannot be undone.</Text>\n    <Button tone=\"danger\" onClick={revoke}>Revoke sk-prod</Button>\n  </Stack>\n</Dialog>";
+    }, {
+        readonly title: "Owned by its opener";
+        readonly description: "Passing the opener's tool name lets a reading agent attach the dialog to the control that produced it.";
+        readonly code: "<Dialog\n  label=\"Rotate secret\"\n  open={rotating}\n  owner=\"press-rotate-secret\"\n  onClose={() => setRotating(false)}\n>\n  <Text>The current secret keeps working for one hour.</Text>\n</Dialog>";
+    }];
+    readonly a11y: {
+        readonly role: "dialog";
+        readonly keyboard: readonly ["Escape closes", "Tab cycles within the dialog"];
+        readonly notes: "A native dialog element shown with showModal, so focus containment, inerting the page behind, and Escape come from the browser. The title names the dialog via aria-label.";
+    };
+};
+
+export declare interface DialogProps extends Omit<ComponentPropsWithRef<"dialog">, "onClose" | "open"> {
+    label: string;
+    open: boolean;
+    onClose: () => void;
+    headingLevel?: DialogHeadingLevel;
+    owner?: string;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare const DISMISS_ALERT_TOOL: AgentToolSpec;
+
+export declare const FILL_TEXTAREA_TOOL: AgentToolSpec;
+
+export declare const FILL_TOOL: AgentToolSpec;
+
+export declare function getAgentMeta(name: string): AgentComponentMeta | undefined;
+
+export declare function getModelContext(): ModelContext | null;
+
+export declare function Heading(props: HeadingProps): JSX.Element;
+
+export declare type HeadingLevel = 1 | 2 | 3 | 4;
+
+export declare const headingMeta: {
+    readonly name: "Heading";
+    readonly category: "typography";
+    readonly summary: "A section title, rendered as a real h element at the level you pick so it joins the document outline.";
+    readonly whenToUse: "Use it for the title of a page or of a region inside one, and keep levels in document order so the outline an agent or a screen reader builds is the outline you meant.";
+    readonly whenNotToUse: "Do not use it for the label on a bordered region; Panel takes a label prop, draws its own header, and joins the outline through its headingLevel prop. Do not pick a level for its size, only for its place in the outline.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The title. Keep it short; long titles truncate in chrome.";
+            readonly required: true;
+        };
+        readonly level: {
+            readonly kind: "enum";
+            readonly description: "Outline depth, rendered as the matching h element. 1 is the page title and there should be one per page.";
+            readonly values: readonly ["1", "2", "3", "4"];
+            readonly default: "2";
+        };
+    };
+    readonly state: {
+        readonly level: {
+            readonly description: "The outline depth, and so the type voice in use.";
+            readonly attribute: "data-sprint-level";
+            readonly values: readonly ["1", "2", "3", "4"];
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Heading** \"WebMCP tools\" [level=2]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A page title";
+        readonly code: "<Heading level={1}>Button</Heading>";
+    }, {
+        readonly title: "A section title";
+        readonly description: "The default level, for a region inside a page.";
+        readonly code: "<Heading>Every variant</Heading>";
+    }];
+};
+
+export declare interface HeadingProps extends ComponentPropsWithRef<"h2"> {
+    level?: HeadingLevel;
+}
+
+export declare function isModelContextAvailable(): boolean;
+
+export declare interface JsonSchemaObject {
+    type: "object";
+    properties: Record<string, JsonSchemaProperty>;
+    required?: readonly string[];
+}
+
+export declare interface JsonSchemaProperty {
+    type: JsonSchemaType;
+    description?: string;
+    enum?: readonly string[];
+    minimum?: number;
+    default?: string | number | boolean;
+}
+
+export declare type JsonSchemaType = "string" | "number" | "integer" | "boolean";
+
+export declare function Link(props: LinkProps): JSX.Element;
+
+export declare const linkMeta: {
+    readonly name: "Link";
+    readonly category: "navigation";
+    readonly summary: "A navigation link. It publishes its destination as state, so an agent reading the page in text learns the URL rather than having to click to find out, and it renders a real anchor in both views.";
+    readonly whenToUse: "Use it for anything that changes the address: a nav item, a cross-reference, a link out to a specification. Set active on the item matching the current route so the agent view and the human view agree about where you are. Under a client-side router, pass an onClick that prevents default and navigates; the handler rides the anchor in both views, so agent clicks and open tools go through the router too.";
+    readonly whenNotToUse: "Do not use it for an action that stays on the page; that is a Button. Do not register a tool on ordinary navigation: an agent can already reach a URL, and a page of links would flood its tool list for no gain.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly href: {
+            readonly kind: "string";
+            readonly description: "The destination. Published as data-sprint-href and carried in the agent view, so the URL is readable without a click.";
+            readonly required: true;
+        };
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The link text. It names the destination, so prefer the page's name over here or read more.";
+            readonly required: true;
+        };
+        readonly active: {
+            readonly kind: "boolean";
+            readonly description: "Mark the link as the current location. Sets aria-current so a screen reader and an agent learn it the same way.";
+            readonly default: false;
+        };
+        readonly external: {
+            readonly kind: "boolean";
+            readonly description: "Mark a destination outside this app. Opens in a new context and adds the usual rel protections.";
+            readonly default: false;
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set true to register an open tool for this link. Off by default: navigation is reachable by URL, so a tool per link is cost without benefit.";
+            readonly default: false;
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name, for icon-only links or two links with the same text.";
+        };
+    };
+    readonly state: {
+        readonly href: {
+            readonly description: "Where this link goes.";
+            readonly attribute: "data-sprint-href";
+        };
+        readonly active: {
+            readonly description: "Present when this link is the current location.";
+            readonly attribute: "data-sprint-active";
+        };
+        readonly external: {
+            readonly description: "Present when the destination is outside this app.";
+            readonly attribute: "data-sprint-external";
+        };
+    };
+    readonly tools: {
+        readonly open: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Link** \"Button\" [active, href=#/Button]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A nav item";
+        readonly code: "<Link href=\"#/Button\" active={route === \"Button\"}>Button</Link>";
+    }, {
+        readonly title: "A link out";
+        readonly code: "<Link href=\"https://developer.chrome.com/docs/ai/webmcp\" external>\n  Chrome docs\n</Link>";
+    }, {
+        readonly title: "A link an agent may follow itself";
+        readonly description: "Opting in is for the one link that completes a task, not for a nav list.";
+        readonly code: "<Link href=\"#/checkout\" agentTool>Go to checkout</Link>";
+    }];
+    readonly a11y: {
+        readonly role: "link";
+        readonly keyboard: readonly ["Enter follows the link"];
+        readonly notes: "active sets aria-current=page. External links open in a new context with rel=noreferrer noopener, and carry their outward mark as a pseudo-element with empty alternative text so it never reaches the accessible name or the tool name. Inside Text a link is underlined all the time, so colour is never the only thing distinguishing it from the prose around it.";
+    };
+};
+
+export declare interface LinkProps extends ComponentPropsWithRef<"a"> {
+    href: string;
+    active?: boolean;
+    external?: boolean;
+    agentTool?: boolean;
+    agentName?: string;
+}
+
+export declare function List(props: ListProps): JSX.Element;
+
+export declare function listAgentMeta(): AgentComponentMeta[];
+
+export declare const listMeta: {
+    readonly name: "List";
+    readonly category: "display";
+    readonly summary: "A bulleted or numbered list built from an array of items. Each item is an addressable part carrying its position, so an agent can cite item three without counting lines.";
+    readonly whenToUse: "Use it for a short sequence of related points: rules, steps, links, caveats. Passing items as data rather than as children is what lets the agent view carry each one as its own part.";
+    readonly whenNotToUse: "Do not use it for records with fields; that is Table. Do not use it as a layout for cards or controls; that is Stack.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What the list is a list of. Names it for a screen reader and for the agent view.";
+            readonly required: true;
+        };
+        readonly items: {
+            readonly kind: "array";
+            readonly description: "The items in order. Inline content, not components: each is flattened to text for the agent view.";
+            readonly required: true;
+        };
+        readonly ordered: {
+            readonly kind: "boolean";
+            readonly description: "Number the items instead of bulleting them. Use it when the order is the point.";
+            readonly default: false;
+        };
+        readonly emptyLabel: {
+            readonly kind: "string";
+            readonly description: "What the list says when it has no items.";
+            readonly default: "Empty";
+        };
+    };
+    readonly state: {
+        readonly items: {
+            readonly description: "How many items the list has.";
+            readonly attribute: "data-sprint-items";
+        };
+        readonly ordered: {
+            readonly description: "Present when the items are numbered rather than bulleted.";
+            readonly attribute: "data-sprint-ordered";
+        };
+        readonly empty: {
+            readonly description: "Present when the list has no items.";
+            readonly attribute: "data-sprint-empty";
+        };
+        readonly index: {
+            readonly description: "On an item: its 1-based position in the list.";
+            readonly attribute: "data-sprint-index";
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **List** \"Tool rules\" [items=1]\n  - part `item` \"One tool, one action.\" [index=1]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A list of rules";
+        readonly code: "<List\n  label=\"Tool rules\"\n  items={[\n    <>\n      <strong>One tool, one action.</strong> Overlapping tools make selection\n      harder.\n    </>,\n  ]}\n/>";
+    }, {
+        readonly title: "A numbered sequence";
+        readonly code: "<List\n  ordered\n  label=\"Steps\"\n  items={[\"Register the tool.\", \"Drive the DOM.\", \"Return the new state.\"]}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "list";
+        readonly notes: "A real ul or ol named by its label, with an explicit list role because the custom markers require list-style none and Safari would otherwise drop the list semantics. The item count is announced, and the markers are drawn as pseudo-elements.";
+    };
+};
+
+export declare interface ListProps extends ComponentPropsWithRef<"ul"> {
+    label: string;
+    items: readonly ReactNode[];
+    ordered?: boolean;
+    emptyLabel?: string;
+}
+
+export declare interface MarkdownOptions {
+    includeSummary?: boolean;
+}
+
+export declare function MetaLine(props: MetaLineProps): JSX.Element | null;
+
+export declare interface MetaLineEntry {
+    term: string;
+    detail: string;
+}
+
+export declare const metaLineMeta: {
+    readonly name: "MetaLine";
+    readonly category: "display";
+    readonly summary: "A slash-separated manifest line of term–detail pairs: serials, build strings, issue dates. It is chrome, not content, and in the agent view it reads as the same single line of text a person sees.";
+    readonly whenToUse: "Use it for the compact strip of identifying metadata that belongs to a page, panel, or footer: version and build identifiers, timestamps, serial numbers, owners. Values are short and the line truncates rather than wraps.";
+    readonly whenNotToUse: "Do not use it for the details of a record a person is meant to study; that is a DescriptionList. Do not put anything interactive in it, and do not use it for prose.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly entries: {
+            readonly kind: "array";
+            readonly description: "Term–detail pairs in display order: { term, detail }, both strings. Rendered as TERM: DETAIL, slash-separated, and carried as one line in the agent view. An empty array renders nothing.";
+            readonly required: true;
+        };
+    };
+    readonly state: {
+        readonly entries: {
+            readonly description: "How many term–detail pairs the line carries.";
+            readonly attribute: "data-sprint-entries";
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **MetaLine** \"SERIAL: NU-TYPE-CORE-A1 / ISSUED: 2744.07.22\" [entries=2]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A build strip";
+        readonly description: "The manifest voice: uppercase mono, slash-separated, terms muted and details in ink.";
+        readonly code: "<MetaLine\n  entries={[\n    { term: \"Serial\", detail: \"NU-TYPE-CORE-A1\" },\n    { term: \"Issued\", detail: \"2744.07.22\" },\n  ]}\n/>";
+    }, {
+        readonly title: "Version chrome for a footer";
+        readonly description: "The line an app pins under its content or into a Shell rail.";
+        readonly code: "<MetaLine\n  entries={[\n    { term: \"Sprint\", detail: \"v0.0.0\" },\n    { term: \"Channel\", detail: \"dev\" },\n    { term: \"WebMCP\", detail: \"chrome 149\" },\n  ]}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "paragraph";
+        readonly notes: "The separators are real text, so the accessible name is the same line the agent view carries. Nothing in the line is interactive.";
+    };
+};
+
+export declare interface MetaLineProps extends ComponentPropsWithRef<"p"> {
+    entries: readonly MetaLineEntry[];
+}
+
+export declare interface ModelContext {
+    registerTool: (descriptor: ToolDescriptor, options?: RegisterToolOptions) => Promise<void> | void;
+    getTools?: (options?: {
+        fromOrigins?: readonly string[];
+    }) => Promise<readonly ToolDescriptor[]>;
+    executeTool?: (tool: ToolDescriptor, inputJson: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<string | null>;
+}
+
+export declare function Nav(props: NavProps): JSX.Element;
+
+export declare function NavGroup(props: NavGroupProps): JSX.Element;
+
+export declare const navGroupMeta: {
+    readonly name: "NavGroup";
+    readonly category: "navigation";
+    readonly summary: "A labelled cluster of links inside a Nav. The label names the group for screen readers and agents alike.";
+    readonly whenToUse: "Use it when a Nav holds more than one kind of destination: guides versus components, product versus account. The label tells every reader, including an agent scanning for the right link, what the links below it have in common.";
+    readonly whenNotToUse: "Do not use it outside a Nav; on its own it is just a heading over links, which Panel does better. Do not nest groups; one level of grouping is all a sidebar can carry.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What the links in this group have in common. Rendered as the rubric and as the group's accessible name.";
+            readonly required: true;
+        };
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The Link components this group collects.";
+            readonly required: true;
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **NavGroup** \"Components\"";
+    };
+    readonly a11y: {
+        readonly role: "group";
+        readonly notes: "The group carries its label as an accessible name, so screen readers announce the rubric when entering the cluster rather than reading an unlabelled run of links.";
+    };
+    readonly relatedComponents: readonly ["Nav", "Link"];
+    readonly examples: readonly [{
+        readonly title: "A labelled group of links";
+        readonly code: "<NavGroup label=\"Reference\">\n  <Link href=\"https://developer.chrome.com/docs/ai/webmcp\" external>\n    Chrome docs\n  </Link>\n  <Link href=\"https://github.com/webmachinelearning/webmcp\" external>\n    Specification\n  </Link>\n</NavGroup>";
+    }];
+};
+
+export declare interface NavGroupProps extends ComponentPropsWithRef<"div"> {
+    label: string;
+}
+
+export declare const navMeta: {
+    readonly name: "Nav";
+    readonly category: "navigation";
+    readonly summary: "A labelled navigation landmark: the region that holds a page's links to elsewhere.";
+    readonly whenToUse: "Use it around any set of links whose job is getting around the app: a sidebar, a table of contents, a footer link block. The label names the landmark, so a person navigating by landmark, a screen reader, and an agent reading the page all know these links are wayfinding rather than content. Group related links inside it with NavGroup.";
+    readonly whenNotToUse: "Do not use it for a link that sits inside prose; a bare Link is already readable there. Do not use it for a set of actions that stay on the page; those are Buttons in a Stack.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What this navigation is for. Rendered as the landmark's accessible name, so two navs on one page stay distinguishable.";
+            readonly required: true;
+        };
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "Link components, or NavGroup components wrapping them.";
+            readonly required: true;
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Nav** \"Workbench\"";
+    };
+    readonly a11y: {
+        readonly role: "navigation";
+        readonly notes: "The label is the landmark's accessible name via aria-label. Active links inside it carry aria-current=page, so the current location is announced without any styling cue.";
+    };
+    readonly relatedComponents: readonly ["NavGroup", "Link", "Shell"];
+    readonly examples: readonly [{
+        readonly title: "A grouped sidebar nav";
+        readonly description: "Each NavGroup names a cluster of destinations. The active link carries the current-page mark in every view.";
+        readonly code: "<Nav label=\"Docs\">\n  <NavGroup label=\"Guides\">\n    <Link href=\"#/guide/webmcp\">WebMCP</Link>\n  </NavGroup>\n  <NavGroup label=\"Components\">\n    <Link href=\"#/Button\" active>Button</Link>\n    <Link href=\"#/Table\">Table</Link>\n  </NavGroup>\n</Nav>";
+    }, {
+        readonly title: "A flat nav";
+        readonly description: "A short list of destinations needs no grouping.";
+        readonly code: "<Nav label=\"Site\">\n  <Link href=\"#/\">Home</Link>\n  <Link href=\"#/pricing\">Pricing</Link>\n</Nav>";
+    }];
+};
+
+export declare interface NavProps extends ComponentPropsWithRef<"nav"> {
+    label: string;
+}
+
+export declare interface NodeInput {
+    component: string;
+    label?: string | undefined;
+    summary?: string | undefined;
+    tool?: string | undefined;
+    owner?: string | undefined;
+    region?: boolean | undefined;
+    state?: Record<string, AgentStateValue | false | null | undefined>;
+    parts?: AgentPart[];
+}
+
+export declare function nodeLine(node: AgentNode): string;
+
+export declare const OPEN_CARD_TOOL: AgentToolSpec;
+
+export declare const OPEN_LINK_TOOL: AgentToolSpec;
+
+export declare const OWNER_ATTRIBUTE = "data-sprint-owner";
+
+export declare function PageHeader(props: PageHeaderProps): JSX.Element;
+
+export declare const pageHeaderMeta: {
+    readonly name: "PageHeader";
+    readonly category: "layout";
+    readonly summary: "The top of a page: its h1 title, the Tag chips that classify it, an optional page-level control, and a lede underneath.";
+    readonly whenToUse: "Use it once per page, as the first thing inside the content region. The label becomes the page's only h1, so the document outline starts here. Put status or category Tags in tags, a control that affects the whole page in actions, and the introductory sentence or two in children as Text.";
+    readonly whenNotToUse: "Do not use it for a section within a page; that is a Panel with a headingLevel. Do not put navigation in actions; the page's links belong in a Nav.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "The page title. Rendered as the page's h1.";
+            readonly required: true;
+        };
+        readonly tags: {
+            readonly kind: "node";
+            readonly description: "Tag components that classify the page, rendered on the title line. Keep it to two or three.";
+        };
+        readonly actions: {
+            readonly kind: "node";
+            readonly description: "A control that acts on the whole page, rendered at the end of the title line.";
+        };
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The lede: a Text or two introducing the page.";
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **PageHeader** \"Button\"";
+    };
+    readonly a11y: {
+        readonly notes: "The label renders as the page's h1, so keep to one PageHeader per page. Tags and the lede are ordinary content after it; the header element itself takes no landmark role because it sits inside main.";
+    };
+    readonly relatedComponents: readonly ["Panel", "Heading", "Tag"];
+    readonly examples: readonly [{
+        readonly title: "A titled page with a lede";
+        readonly code: "<PageHeader label=\"Reports\">\n  <Text>Everything the quarter produced, in one place.</Text>\n</PageHeader>";
+    }, {
+        readonly title: "Status tags and a page-level control";
+        readonly description: "Tags classify the page on the title line; the action slot holds the one control that affects the whole page.";
+        readonly code: "<PageHeader\n  label=\"Button\"\n  tags={<Tag tone=\"warning\" filled>experimental</Tag>}\n  actions={<Button agentTool={false}>Refresh</Button>}\n>\n  <Text>A single action a person or an agent can trigger.</Text>\n</PageHeader>";
+    }];
+};
+
+export declare interface PageHeaderProps extends ComponentPropsWithRef<"header"> {
+    label: string;
+    tags?: ReactNode;
+    actions?: ReactNode;
+}
+
+export declare function paginate(text: string, size: number): string[];
+
+export declare function Panel(props: PanelProps): JSX.Element;
+
+declare type PanelHeadingLevel = 2 | 3 | 4;
+
+export declare const panelMeta: {
+    readonly name: "Panel";
+    readonly category: "layout";
+    readonly summary: "A labelled region with a header band and an optional slot for the controls that act on it. Everything on a Sprint page lives inside one.";
+    readonly whenToUse: "Use it for every distinct region of a page: a section of documentation, a form, a readout, a preview. The label is the region's accessible name, so a person, a screen reader, and an agent all address the region by the same words.";
+    readonly whenNotToUse: "Do not use it as a spacer or a plain box; that is Stack. Nesting reads clearly to about three deep, because each level alternates its ground and demotes its frame; past that, the depth cues repeat and the region wants a page of its own.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What this region is. Rendered in the header band and used as the region's accessible name.";
+            readonly required: true;
+        };
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The region's content. An empty panel says it is empty rather than collapsing.";
+        };
+        readonly headingLevel: {
+            readonly kind: "enum";
+            readonly description: "Render the label as a real heading at this outline depth, so the section is reachable when a screen reader navigates by headings. Set it on every panelled section of a page; leave it unset only for chrome such as a preview frame.";
+            readonly values: readonly ["2", "3", "4"];
+        };
+        readonly actions: {
+            readonly kind: "node";
+            readonly description: "Controls that act on this region, rendered at the end of the header band. Keep it to one or two.";
+        };
+        readonly flush: {
+            readonly kind: "boolean";
+            readonly description: "Drop the body padding, for content that draws its own edges such as a Table or a CodeBlock.";
+            readonly default: false;
+        };
+        readonly emptyLabel: {
+            readonly kind: "string";
+            readonly description: "What the panel says when it has no content.";
+            readonly default: "Empty";
+        };
+    };
+    readonly state: {
+        readonly flush: {
+            readonly description: "Present when the body carries no padding of its own.";
+            readonly attribute: "data-sprint-flush";
+        };
+        readonly empty: {
+            readonly description: "Present when the panel has no content. The panel still renders its keyline and says it is empty.";
+            readonly attribute: "data-sprint-empty";
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Panel** \"WebMCP tools\"";
+    };
+    readonly a11y: {
+        readonly role: "region";
+        readonly notes: "The section is a named landmark either way: the label is its accessible name. With headingLevel the label is also a heading element, so the page outline includes the region; without it the region is reachable only by landmark navigation.";
+    };
+    readonly examples: readonly [{
+        readonly title: "A section of a page";
+        readonly description: "headingLevel puts the label in the page outline, so a screen reader finds the section by heading as well as by landmark.";
+        readonly code: "<Panel label=\"When to use\" headingLevel={2}>\n  <Text>Use it for any discrete action.</Text>\n</Panel>";
+    }, {
+        readonly title: "A panel with a control in its header";
+        readonly description: "The header slot is for controls that act on the region, not for navigation.";
+        readonly code: "<Panel\n  label=\"Preview\"\n  actions={<Button agentName=\"Reset preview\">Reset</Button>}\n>\n  <Button tone=\"action\">Prepare launch</Button>\n</Panel>";
+    }, {
+        readonly title: "A flush panel around a table";
+        readonly description: "Content that draws its own keylines sits flush, so borders do not double up.";
+        readonly code: "<Panel label=\"Conventions\" flush>\n  <Table label=\"Conventions\" columns={columns} rows={rows} />\n</Panel>";
+    }, {
+        readonly title: "Nested panels";
+        readonly description: "Depth styles itself: the outermost panel carries a doubled keyline, each nested level alternates its ground, and nested headers demote to a dashed rule, so a reader ranks the levels without counting borders.";
+        readonly code: "<Panel label=\"The shape\" headingLevel={2}>\n  <Panel label=\"Human view\" headingLevel={3}>\n    <Panel label=\"Crew\" headingLevel={4}>\n      <Text>Registration fields live here.</Text>\n    </Panel>\n  </Panel>\n</Panel>";
+    }, {
+        readonly title: "An empty region";
+        readonly description: "An empty panel keeps its border and states that it is empty, rather than vanishing and leaving a person or an agent unsure whether it failed to load.";
+        readonly code: "<Panel label=\"Registered tools\" emptyLabel=\"No tools registered\" />";
+    }];
+};
+
+export declare interface PanelProps extends ComponentPropsWithRef<"section"> {
+    label: string;
+    headingLevel?: PanelHeadingLevel;
+    actions?: ReactNode;
+    flush?: boolean;
+    emptyLabel?: string;
+}
+
+export declare const PARAM_DESCRIPTION_LIMIT = 150;
+
+export declare const PART_ATTRIBUTE = "data-sprint-part";
+
+export declare const PRESS_TOOL: AgentToolSpec;
+
+export declare function reactText(node: ReactNode): string | undefined;
+
+export declare const REGION_ATTRIBUTE = "data-sprint-region";
+
+export declare function registerTool(descriptor: ToolDescriptor, signal: AbortSignal): boolean;
+
+declare interface RegisterToolOptions {
+    signal?: AbortSignal;
+    exposedTo?: readonly string[];
+}
+
+export declare const RESERVED_STATE_KEYS: readonly string[];
+
+export declare function SecretField(props: SecretFieldProps): JSX.Element;
+
+export declare const secretFieldMeta: {
+    readonly name: "SecretField";
+    readonly category: "display";
+    readonly summary: "A sensitive value shown once or on demand: an API key, a recovery code, a signing secret. Masked by default with reveal and copy controls, and the value never reaches any agent surface.";
+    readonly whenToUse: "Use to hand a person a secret the page holds. The mask is fixed-length so nothing leaks, and copy places the value on the clipboard without revealing it.";
+    readonly whenNotToUse: "Do not use for entering a secret; that is a TextInput with type password. Do not use for values that are safe to read; a DescriptionList or CodeBlock keeps those on the agent surface where they belong.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What the secret is, shown as the field's uppercase title.";
+            readonly required: true;
+        };
+        readonly value: {
+            readonly kind: "string";
+            readonly description: "The secret. Never appears in agent attributes, the agent view, or the copyable text stream; only reveal and copy touch it.";
+            readonly required: true;
+        };
+        readonly hint: {
+            readonly kind: "string";
+            readonly description: "Guidance below the value, e.g. \"Store it now. It is not shown again.\"";
+        };
+        readonly defaultRevealed: {
+            readonly kind: "boolean";
+            readonly description: "Start revealed instead of masked.";
+            readonly default: false;
+        };
+    };
+    readonly state: {
+        readonly filled: {
+            readonly description: "Present when the field holds a secret.";
+            readonly attribute: "data-sprint-filled";
+        };
+        readonly revealed: {
+            readonly description: "Present while the value is shown in clear text.";
+            readonly attribute: "data-sprint-revealed";
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **SecretField** \"API key\" [filled]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A key shown once";
+        readonly code: "<SecretField\n  label=\"API key\"\n  value={key}\n  hint=\"Store it now. It is not shown again.\"\n/>";
+    }, {
+        readonly title: "Starting revealed";
+        readonly description: "For a value the person is expected to transcribe immediately.";
+        readonly code: "<SecretField label=\"Recovery code\" value={code} defaultRevealed />";
+    }];
+    readonly a11y: {
+        readonly notes: "The reveal control is a toggle button with aria-pressed; the masked value is announced as a hidden secret rather than as bullet characters. Copy announces its success by swapping its label to Copied.";
+    };
+};
+
+export declare interface SecretFieldProps extends ComponentPropsWithRef<"div"> {
+    label: string;
+    value: string;
+    hint?: string;
+    defaultRevealed?: boolean;
+}
+
+export declare function SegmentedControl(props: SegmentedControlProps): JSX.Element;
+
+export declare const segmentedControlMeta: {
+    readonly name: "SegmentedControl";
+    readonly category: "input";
+    readonly summary: "A short row of mutually exclusive options, all visible at once: a radio group that registers a single select tool whose schema enumerates the options currently on screen.";
+    readonly whenToUse: "Use it for two to four exclusive choices a person should be able to compare without opening anything: a view switch, a density setting, a filter. One tool with an enum beats one tool per option, and it keeps a page's tool count flat as options are added.";
+    readonly whenNotToUse: "Do not use it for more than about four options or for long labels; that is a select. Do not use it for an on/off setting, which is a switch, and never for navigation.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What is being chosen. Names the group for a screen reader and derives the tool name, so prefer a noun phrase such as \"Page view\".";
+            readonly required: true;
+        };
+        readonly options: {
+            readonly kind: "array";
+            readonly description: "The choices in display order: { value, label }. The label is what a person sees and what the select tool accepts, so an agent never has to know the value.";
+            readonly required: true;
+        };
+        readonly value: {
+            readonly kind: "string";
+            readonly description: "The value of the selected option. The control is fully controlled.";
+            readonly required: true;
+        };
+        readonly onChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the newly selected value. The select tool drives a real click, so this runs for agent selections too.";
+            readonly required: true;
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable every option and unregister the select tool.";
+            readonly default: false;
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name, when two controls on a page would otherwise collide.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the control without registering a select tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly value: {
+            readonly description: "The value of the option currently selected.";
+            readonly attribute: "data-sprint-value";
+        };
+        readonly disabled: {
+            readonly description: "Present when no option can be chosen.";
+            readonly attribute: "data-sprint-disabled";
+        };
+    };
+    readonly tools: {
+        readonly select: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **SegmentedControl** \"Page view\" [value=human] → tool `select-page-view`\n  - part `option` \"human\" [checked]\n  - part `option` \"agent\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "A view switch";
+        readonly description: "In agent view each option renders as its own control, so an agent driving the DOM can click one without WebMCP.";
+        readonly code: "<SegmentedControl\n  label=\"Page view\"\n  value={view}\n  onChange={setView}\n  options={[\n    { value: \"human\", label: \"human\" },\n    { value: \"agent\", label: \"agent\" },\n  ]}\n/>";
+    }, {
+        readonly title: "A disabled control";
+        readonly description: "Disabled unregisters the tool, so an agent cannot select an option a person could not.";
+        readonly code: "<SegmentedControl\n  label=\"Density\"\n  disabled\n  value=\"dense\"\n  onChange={setDensity}\n  options={[\n    { value: \"dense\", label: \"dense\" },\n    { value: \"roomy\", label: \"roomy\" },\n  ]}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "radiogroup";
+        readonly keyboard: readonly ["Arrow keys move to the next or previous option and select it", "Home selects the first option", "End selects the last option", "Tab enters and leaves the group once"];
+        readonly notes: "Roving tabindex: only the selected option is in the tab order. Selection follows focus, which is the expected behaviour for a radio group.";
+    };
+};
+
+export declare interface SegmentedControlProps extends Omit<ComponentPropsWithRef<"div">, "onChange"> {
+    label: string;
+    options: readonly SegmentedOption[];
+    value: string;
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare interface SegmentedOption {
+    value: string;
+    label: string;
+}
+
+export declare function Select(props: SelectProps): JSX.Element;
+
+export declare const SELECT_OPTION_TOOL: AgentToolSpec;
+
+export declare const SELECT_TOOL: AgentToolSpec;
+
+export declare const selectMeta: {
+    readonly name: "Select";
+    readonly category: "input";
+    readonly summary: "A dropdown of mutually exclusive options behind a native select, carrying its own label, hint, and error. It registers a single select tool whose schema enumerates the option labels currently on offer.";
+    readonly whenToUse: "Use it when one value is chosen from a list too long to lay out flat: a region, a squad, a category. Options are data ({ value, label }), the tool accepts the visible label, and in agent view every option renders as its own control, so an agent picks one without opening anything.";
+    readonly whenNotToUse: "Do not use it for two to four short options a person should compare at a glance; that is a SegmentedControl. Do not use it for an on/off state, which is a Checkbox or a Switch, and never for navigation.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What is being chosen. Names the control for a screen reader and derives the tool name, so prefer a noun phrase such as \"Region\".";
+            readonly required: true;
+        };
+        readonly options: {
+            readonly kind: "array";
+            readonly description: "The choices in display order: { value, label }. The label is what a person sees and what the select tool accepts, so an agent never has to know the value.";
+            readonly required: true;
+        };
+        readonly value: {
+            readonly kind: "string";
+            readonly description: "The value of the chosen option, or \"\" while nothing is chosen yet. The control is fully controlled.";
+            readonly required: true;
+        };
+        readonly onChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the newly chosen value. The select tool drives a real change event, so this runs for agent selections too.";
+            readonly required: true;
+        };
+        readonly placeholder: {
+            readonly kind: "string";
+            readonly description: "Shown while value is \"\". Rendered as a disabled option, so a person cannot choose it back.";
+        };
+        readonly hint: {
+            readonly kind: "string";
+            readonly description: "Guidance shown under the control and carried into the agent view. Replaced by error while one is set.";
+        };
+        readonly error: {
+            readonly kind: "string";
+            readonly description: "A validation message. Marks the control invalid for people, screen readers, and agents alike.";
+        };
+        readonly name: {
+            readonly kind: "string";
+            readonly description: "The native form name submitted with the surrounding form.";
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable the control and unregister its select tool.";
+            readonly default: false;
+        };
+        readonly required: {
+            readonly kind: "boolean";
+            readonly description: "Mark the control required, visually and in the agent view.";
+            readonly default: false;
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name, when two controls on a page would otherwise collide.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the control without registering a select tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly value: {
+            readonly description: "The value of the option currently chosen.";
+            readonly attribute: "data-sprint-value";
+        };
+        readonly empty: {
+            readonly description: "Present while no option is chosen.";
+            readonly attribute: "data-sprint-empty";
+        };
+        readonly disabled: {
+            readonly description: "Present when nothing can be chosen.";
+            readonly attribute: "data-sprint-disabled";
+        };
+        readonly required: {
+            readonly description: "Present when a choice must be made.";
+            readonly attribute: "data-sprint-required";
+        };
+        readonly invalid: {
+            readonly description: "Present while an error is set.";
+            readonly attribute: "data-sprint-invalid";
+        };
+    };
+    readonly tools: {
+        readonly select: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Select** \"Region\" [value=eu-1] → tool `select-region`\n  - part `option` \"North Atlantic\"\n  - part `option` \"Northern Europe\" [checked]\n  - part `option` \"East Asia\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "A dropdown";
+        readonly description: "In agent view each option renders as its own control, so a DOM-driving agent chooses one directly.";
+        readonly code: "<Select\n  label=\"Region\"\n  value={region}\n  onChange={setRegion}\n  placeholder=\"Choose a region\"\n  options={[\n    { value: \"na-1\", label: \"North Atlantic\" },\n    { value: \"eu-1\", label: \"Northern Europe\" },\n    { value: \"ap-1\", label: \"East Asia\" },\n  ]}\n/>";
+    }, {
+        readonly title: "A required choice with an error";
+        readonly description: "Empty plus required plus an error is how an unmade mandatory choice reads on every surface.";
+        readonly code: "<Select\n  label=\"Launch site\"\n  value={site}\n  onChange={setSite}\n  required\n  error=\"Choose a site before continuing.\"\n  options={[\n    { value: \"ksc\", label: \"Cape Canaveral\" },\n    { value: \"vsfb\", label: \"Vandenberg\" },\n  ]}\n/>";
+    }, {
+        readonly title: "A disabled dropdown";
+        readonly description: "Disabled unregisters the tool, so an agent cannot choose what a person could not.";
+        readonly code: "<Select\n  label=\"Relay\"\n  disabled\n  value=\"r-2\"\n  onChange={setRelay}\n  options={[\n    { value: \"r-1\", label: \"Relay one\" },\n    { value: \"r-2\", label: \"Relay two\" },\n  ]}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "combobox";
+        readonly keyboard: readonly ["Arrow keys move through the options", "Enter or Space opens the list", "Escape closes it"];
+        readonly notes: "A native select element, so the platform owns the listbox interaction. The label is associated via htmlFor; errors set aria-invalid and link with aria-describedby.";
+    };
+};
+
+export declare interface SelectOption {
+    value: string;
+    label: string;
+}
+
+export declare interface SelectProps extends Omit<ComponentPropsWithRef<"div">, "onChange"> {
+    label: string;
+    options: readonly SelectOption[];
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    hint?: string;
+    error?: string;
+    name?: string;
+    disabled?: boolean;
+    required?: boolean;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare function serializeElement(root: Element, options?: SerializeOptions): AgentNode | null;
+
+export declare interface SerializeOptions {
+    maxDepth?: number;
+    lookupMeta?: (name: string) => AgentComponentMeta | undefined;
+}
+
+export declare function serializeWithin(root: ParentNode, options?: SerializeOptions): AgentNode[];
+
+export declare const SET_CHECKBOX_TOOL: AgentToolSpec;
+
+export declare const SET_SWITCH_TOOL: AgentToolSpec;
+
+export declare function Shell(props: ShellProps): JSX.Element;
+
+export declare const shellMeta: {
+    readonly name: "Shell";
+    readonly category: "layout";
+    readonly summary: "The page-level frame: a sidebar and a main content region, with the landmark wiring done once. On a phone the sidebar becomes a drawer behind a menu button.";
+    readonly whenToUse: "Use it once, at the root of an app view. Put the brand in bar, a Nav in side, and the page in children. It renders the main and complementary landmarks, a skip-to-content control for keyboard users, and the mobile drawer behaviour, so none of that is rebuilt per app. Like Stack it is silent in agent view: its regions speak for themselves.";
+    readonly whenNotToUse: "Do not use it inside another Shell, or anywhere below the top of the page; a region within a page is a Panel. Do not use it just to put two columns next to each other; that is Stack.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The page content. Rendered inside the main landmark.";
+            readonly required: true;
+        };
+        readonly side: {
+            readonly kind: "node";
+            readonly description: "The sidebar content, usually a Nav. On narrow viewports it becomes the drawer behind the menu button, and the drawer closes itself when a link inside it is followed.";
+        };
+        readonly bar: {
+            readonly kind: "node";
+            readonly description: "What stays visible when the sidebar collapses to a top bar: typically the brand link. The menu button renders next to it automatically.";
+        };
+        readonly sideLabel: {
+            readonly kind: "string";
+            readonly description: "Accessible name for the sidebar landmark.";
+            readonly default: "Sidebar";
+        };
+        readonly skipLabel: {
+            readonly kind: "string";
+            readonly description: "Text of the skip control that moves focus to the main region. Visually hidden until focused.";
+            readonly default: "Skip to content";
+        };
+        readonly menuLabel: {
+            readonly kind: "string";
+            readonly description: "Label of the drawer button while the drawer is closed.";
+            readonly default: "Menu";
+        };
+        readonly closeLabel: {
+            readonly kind: "string";
+            readonly description: "Label of the drawer button while the drawer is open.";
+            readonly default: "Close";
+        };
+    };
+    readonly state: {
+        readonly open: {
+            readonly description: "Present while the mobile drawer is open. On wide viewports the sidebar is always visible and this state is inert.";
+            readonly attribute: "data-sprint-open";
+        };
+    };
+    readonly a11y: {
+        readonly notes: "Renders the only main element and an aside named by sideLabel, so the page has its landmarks without any consumer wiring. The first focusable element is a skip control that moves focus to main without touching the URL, which keeps it safe in hash-routed apps. The drawer button carries aria-expanded and aria-controls.";
+    };
+    readonly relatedComponents: readonly ["Nav", "Panel", "Stack"];
+    readonly examples: readonly [{
+        readonly title: "A sidebar app shell";
+        readonly description: "One Shell per view. The sidebar collapses to a top bar with a drawer on narrow screens, and an agent reading the page sees the nav and the content with no frame in between.";
+        readonly code: "<Shell\n  bar={<Link href=\"#/\">ACME</Link>}\n  side={\n    <Nav label=\"Main\">\n      <Link href=\"#/reports\" active>Reports</Link>\n      <Link href=\"#/settings\">Settings</Link>\n    </Nav>\n  }\n>\n  <Panel label=\"Reports\" headingLevel={2}>\n    <Text>Quarterly numbers land here.</Text>\n  </Panel>\n</Shell>";
+    }];
+};
+
+export declare interface ShellProps extends ComponentPropsWithRef<"div"> {
+    side?: ReactNode;
+    bar?: ReactNode;
+    sideLabel?: string;
+    skipLabel?: string;
+    menuLabel?: string;
+    closeLabel?: string;
+}
+
+export declare function slug(value: string): string;
+
+export declare type SprintAgentControls = "always" | "never";
+
+export declare function SprintProvider(props: SprintProviderProps): JSX.Element;
+
+export declare interface SprintProviderProps {
+    children: ReactNode;
+    label?: string;
+    format?: AgentFormatter;
+    pageTools?: boolean;
+    view?: SprintView;
+    defaultView?: SprintView;
+    onViewChange?: (view: SprintView) => void;
+    agentControls?: SprintAgentControls;
+    theme?: SprintTheme;
+}
+
+export declare type SprintTheme = "dark" | "light";
+
+export declare type SprintView = "human" | "agent";
+
+export declare interface SprintViewValue {
+    view: SprintView;
+    setView: (view: SprintView) => void;
+    controls: SprintAgentControls;
+    format: AgentFormatter;
+    owned: boolean;
+}
+
+export declare function Stack(props: StackProps): JSX.Element;
+
+export declare type StackAlign = "start" | "center" | "end" | "stretch" | "baseline";
+
+export declare type StackDirection = "row" | "column" | "grid";
+
+export declare type StackGap = "none" | "tight" | "normal" | "loose";
+
+export declare type StackJustify = "start" | "center" | "end" | "between";
+
+export declare const stackMeta: {
+    readonly name: "Stack";
+    readonly category: "layout";
+    readonly summary: "The one-dimensional layout primitive: a row, a column, or an auto-filling grid, with spacing drawn from the space scale. It renders a plain box and nothing else.";
+    readonly whenToUse: "Use it wherever two or more things sit next to each other. Prefer it over a bare div with inline styles so spacing stays on the scale. Stack is invisible in agent view: it emits no line, because an agent does not care how a region is arranged, only what is in it.";
+    readonly whenNotToUse: "Do not use it to draw a bordered region with a header; that is Panel. Do not nest three deep to fake a grid; use direction=\"grid\".";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The items to lay out.";
+            readonly required: true;
+        };
+        readonly direction: {
+            readonly kind: "enum";
+            readonly description: "Axis. \"grid\" fills as many equal columns as fit, each at least min wide.";
+            readonly values: readonly ["row", "column", "grid"];
+            readonly default: "column";
+        };
+        readonly gap: {
+            readonly kind: "enum";
+            readonly description: "Space between items, from the space scale.";
+            readonly values: readonly ["none", "tight", "normal", "loose"];
+            readonly default: "normal";
+        };
+        readonly align: {
+            readonly kind: "enum";
+            readonly description: "Cross-axis alignment.";
+            readonly values: readonly ["start", "center", "end", "stretch", "baseline"];
+        };
+        readonly justify: {
+            readonly kind: "enum";
+            readonly description: "Main-axis distribution.";
+            readonly values: readonly ["start", "center", "end", "between"];
+        };
+        readonly wrap: {
+            readonly kind: "boolean";
+            readonly description: "Let a row wrap onto more lines instead of overflowing.";
+            readonly default: false;
+        };
+        readonly collapse: {
+            readonly kind: "boolean";
+            readonly description: "Stack a row into a column on narrow viewports. This is how a toolbar survives a phone.";
+            readonly default: false;
+        };
+        readonly min: {
+            readonly kind: "string";
+            readonly description: "Minimum track width for direction=\"grid\", as a CSS length. Tracks never exceed the container.";
+            readonly default: "18rem";
+        };
+    };
+    readonly state: {
+        readonly direction: {
+            readonly description: "The axis in use.";
+            readonly attribute: "data-sprint-direction";
+            readonly values: readonly ["row", "column", "grid"];
+        };
+        readonly gap: {
+            readonly description: "The spacing step in use.";
+            readonly attribute: "data-sprint-gap";
+            readonly values: readonly ["none", "tight", "normal", "loose"];
+        };
+        readonly align: {
+            readonly description: "Cross-axis alignment, when one was asked for.";
+            readonly attribute: "data-sprint-align";
+            readonly values: readonly ["start", "center", "end", "stretch", "baseline"];
+        };
+        readonly justify: {
+            readonly description: "Main-axis distribution, when one was asked for.";
+            readonly attribute: "data-sprint-justify";
+            readonly values: readonly ["start", "center", "end", "between"];
+        };
+        readonly wrap: {
+            readonly description: "Present when a row is allowed to wrap.";
+            readonly attribute: "data-sprint-wrap";
+        };
+        readonly collapse: {
+            readonly description: "Present when the row stacks into a column on narrow viewports.";
+            readonly attribute: "data-sprint-collapse";
+        };
+    };
+    readonly examples: readonly [{
+        readonly title: "A row of actions";
+        readonly description: "Wrapping keeps a toolbar from overflowing on a narrow screen.";
+        readonly code: "<Stack direction=\"row\" gap=\"tight\" wrap>\n  <Button>Cancel</Button>\n  <Button tone=\"action\">Confirm</Button>\n</Stack>";
+    }, {
+        readonly title: "A responsive card grid";
+        readonly description: "Tracks fill the container and never go below min, so this is one column on a phone and three on a desktop with no media query of your own.";
+        readonly code: "<Stack direction=\"grid\" min=\"16rem\">\n  <Card label=\"Button\" href=\"#/Button\">One action.</Card>\n  <Card label=\"Table\" href=\"#/Table\">Rows and columns.</Card>\n</Stack>";
+    }, {
+        readonly title: "A header bar that stacks on a phone";
+        readonly code: "<Stack direction=\"row\" justify=\"between\" align=\"center\" collapse>\n  <Heading level={1}>Button</Heading>\n  <Tag tone=\"warning\">experimental</Tag>\n</Stack>";
+    }];
+};
+
+export declare interface StackProps extends ComponentPropsWithRef<"div"> {
+    direction?: StackDirection;
+    gap?: StackGap;
+    align?: StackAlign;
+    justify?: StackJustify;
+    wrap?: boolean;
+    collapse?: boolean;
+    min?: string;
+}
+
+export declare const STATE_ATTRIBUTE_PREFIX = "data-sprint-";
+
+export declare function Switch(props: SwitchProps): JSX.Element;
+
+export declare const switchMeta: {
+    readonly name: "Switch";
+    readonly category: "input";
+    readonly summary: "An on/off setting that takes effect the moment it changes. It registers one set tool that takes the end state rather than toggling.";
+    readonly whenToUse: "Use it for a live setting: enabling telemetry, muting alerts, switching a feed. The set tool takes on as true or false, so an agent states the end state and never has to read before writing.";
+    readonly whenNotToUse: "Do not use it for a boolean a form will submit later; that is a Checkbox, and the distinction is when the change takes effect. Do not use it to choose between two named modes a person should see side by side, which is a SegmentedControl.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What the setting controls. Names the switch for a screen reader and derives the tool name, so prefer a noun phrase such as \"Live telemetry\".";
+            readonly required: true;
+        };
+        readonly on: {
+            readonly kind: "boolean";
+            readonly description: "Whether the setting is on. The switch is fully controlled.";
+            readonly required: true;
+        };
+        readonly onChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the new state. The set tool drives a real click, so this runs for agent changes too.";
+            readonly required: true;
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable the switch and unregister its set tool.";
+            readonly default: false;
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name, when two switches on a page would otherwise collide.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the switch without registering a set tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly on: {
+            readonly description: "Present while the setting is on.";
+            readonly attribute: "data-sprint-on";
+        };
+        readonly disabled: {
+            readonly description: "Present when the switch cannot be changed.";
+            readonly attribute: "data-sprint-disabled";
+        };
+    };
+    readonly tools: {
+        readonly set: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Switch** \"Live telemetry\" [on] → tool `set-live-telemetry`";
+    };
+    readonly examples: readonly [{
+        readonly title: "A live setting";
+        readonly description: "In agent view the switch renders as one control; pressing it toggles, while the set tool states the end state.";
+        readonly code: "<Switch label=\"Live telemetry\" on={telemetry} onChange={setTelemetry} />";
+    }, {
+        readonly title: "A disabled switch";
+        readonly description: "Disabled unregisters the tool, so an agent cannot change what a person could not.";
+        readonly code: "<Switch label=\"Ground link\" on disabled onChange={setLink} />";
+    }];
+    readonly a11y: {
+        readonly role: "switch";
+        readonly keyboard: readonly ["Space toggles", "Enter toggles"];
+        readonly notes: "A button with role switch and aria-checked, so the label and state read together. The thumb moves by a single-axis stepped translation and respects prefers-reduced-motion.";
+    };
+};
+
+export declare interface SwitchProps extends Omit<ComponentPropsWithRef<"button">, "onChange" | "children"> {
+    label: string;
+    on: boolean;
+    onChange: (on: boolean) => void;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare function Table(props: TableProps): JSX.Element;
+
+export declare interface TableColumn {
+    key: string;
+    header: string;
+    align?: "start" | "end";
+    width?: string;
+}
+
+export declare const tableMeta: {
+    readonly name: "Table";
+    readonly category: "display";
+    readonly summary: "A data grid built from columns and rows rather than from markup. In the agent stream it reads as a compact Markdown table; in the DOM each cell is addressable as a part carrying its column and row. On a narrow screen every row restacks into a labelled block instead of scrolling sideways.";
+    readonly whenToUse: "Use it for any set of records with the same shape: props, attributes, conventions, results. Passing data instead of children is what lets the agent view carry the cells and the human view restack them on a phone.";
+    readonly whenNotToUse: "Do not use it for page layout; that is Stack. Do not put components in cells: cells are flattened to text for the agent view, so a Button inside one would lose its tool.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What this table is a table of. Used as its accessible name and read back by the agent view.";
+            readonly required: true;
+        };
+        readonly columns: {
+            readonly kind: "array";
+            readonly description: "Column definitions, in display order: { key, header, align?, width? }. The key addresses the cell in each row and appears on the cell as data-sprint-column.";
+            readonly required: true;
+        };
+        readonly rows: {
+            readonly kind: "array";
+            readonly description: "Rows in display order: { id?, cells }, where cells maps a column key to inline content. id names the row for an agent and defaults to its 1-based position.";
+            readonly required: true;
+        };
+        readonly emptyLabel: {
+            readonly kind: "string";
+            readonly description: "What the table says when it has no rows.";
+            readonly default: "No rows";
+        };
+    };
+    readonly state: {
+        readonly columns: {
+            readonly description: "How many columns the table has.";
+            readonly attribute: "data-sprint-columns";
+        };
+        readonly rows: {
+            readonly description: "How many rows the table currently has.";
+            readonly attribute: "data-sprint-rows";
+        };
+        readonly empty: {
+            readonly description: "Present when the table has no rows.";
+            readonly attribute: "data-sprint-empty";
+        };
+        readonly column: {
+            readonly description: "On a cell: which column it belongs to.";
+            readonly attribute: "data-sprint-column";
+        };
+        readonly row: {
+            readonly description: "On a cell: which row it belongs to.";
+            readonly attribute: "data-sprint-row";
+        };
+        readonly align: {
+            readonly description: "On a cell: the alignment its column asked for, if any.";
+            readonly attribute: "data-sprint-align";
+            readonly values: readonly ["start", "end"];
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Table** \"Props\" [columns=2, rows=1]\n  | row | prop | kind |\n  | --- | --- | --- |\n  | tone | tone | enum |";
+    };
+    readonly examples: readonly [{
+        readonly title: "A reference table";
+        readonly description: "Cells are addressable: [data-sprint-part=\"cell\"][data-sprint-column=\"kind\"] selects a column without knowing anything about the markup.";
+        readonly code: "<Table\n  label=\"Props\"\n  columns={[\n    { key: \"prop\", header: \"Prop\" },\n    { key: \"kind\", header: \"Kind\" },\n  ]}\n  rows={[{ id: \"tone\", cells: { prop: <code>tone</code>, kind: \"enum\" } }]}\n/>";
+    }, {
+        readonly title: "A table with no rows";
+        readonly description: "An empty table keeps its header and says so, rather than rendering a bare keyline.";
+        readonly code: "<Table\n  label=\"Registered tools\"\n  emptyLabel=\"No tools registered\"\n  columns={[{ key: \"name\", header: \"Name\" }]}\n  rows={[]}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "table";
+        readonly notes: "Column headers keep scope=col in every layout. On narrow screens each cell repeats its column header visually, marked aria-hidden so the real header association is not announced twice.";
+    };
+};
+
+export declare interface TableProps extends ComponentPropsWithRef<"table"> {
+    label: string;
+    columns: readonly TableColumn[];
+    rows: readonly TableRow[];
+    emptyLabel?: string;
+}
+
+export declare interface TableRow {
+    id?: string;
+    cells: Record<string, ReactNode>;
+}
+
+export declare function Tag(props: TagProps): JSX.Element;
+
+export declare const tagMeta: {
+    readonly name: "Tag";
+    readonly category: "display";
+    readonly summary: "A small chip that classifies the thing next to it: a status, a category, a count, a build string.";
+    readonly whenToUse: "Use it for a short classification a person scans and an agent reads off the tone attribute, such as a release status, a read-only or write marker on a tool, or a version chip.";
+    readonly whenNotToUse: "Do not use it for anything clickable; a Tag is inert, and a chip that acts is a Button. Do not put a sentence in one.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The chip text. One or two words.";
+            readonly required: true;
+        };
+        readonly tone: {
+            readonly kind: "enum";
+            readonly description: "What class of thing this is. Acid is rationed, so reach for info or inert before action.";
+            readonly values: readonly ["neutral", "action", "danger", "info", "warning", "inert"];
+            readonly default: "neutral";
+        };
+        readonly filled: {
+            readonly kind: "boolean";
+            readonly description: "Render as a solid field of the tone with inverted ink, instead of a keyline. Use for the one chip that must be read first.";
+            readonly default: false;
+        };
+    };
+    readonly state: {
+        readonly tone: {
+            readonly description: "The class of thing the chip marks.";
+            readonly attribute: "data-sprint-tone";
+            readonly values: readonly ["neutral", "action", "danger", "info", "warning", "inert"];
+        };
+        readonly filled: {
+            readonly description: "Present when the chip is a solid field rather than a keyline.";
+            readonly attribute: "data-sprint-filled";
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Tag** \"experimental\" [filled, tone=warning]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A release status";
+        readonly code: "<Tag tone=\"warning\" filled>experimental</Tag>";
+    }, {
+        readonly title: "A category chip";
+        readonly code: "<Tag>action</Tag>";
+    }, {
+        readonly title: "Read-only against changes-state";
+        readonly description: "Two tones doing the work a legend would otherwise have to do in prose.";
+        readonly code: "<Tag tone={tool.readOnly ? \"info\" : \"danger\"}>\n  {tool.readOnly ? \"read only\" : \"changes state\"}\n</Tag>";
+    }];
+};
+
+export declare interface TagProps extends ComponentPropsWithRef<"span"> {
+    tone?: TagTone;
+    filled?: boolean;
+}
+
+export declare type TagTone = "neutral" | "action" | "danger" | "info" | "warning" | "inert";
+
+declare function Text_2(props: TextProps): JSX.Element;
+export { Text_2 as Text }
+
+export declare function Textarea(props: TextareaProps): JSX.Element;
+
+export declare const textareaMeta: {
+    readonly name: "Textarea";
+    readonly category: "input";
+    readonly summary: "A multi-line text area carrying its own label, hint, and error. Fully controlled, and it registers one fill tool that replaces the whole content with an explicit value, line breaks included.";
+    readonly whenToUse: "Use it for free-form text that runs longer than a line: a description, a message body, a set of notes. In the agent view the current content is part of the component's state line, so an agent reads what is written without a separate query.";
+    readonly whenNotToUse: "Do not use it for a single-line value, which is a TextInput. Do not use it for code a person should read rather than write; that is a CodeBlock. Long values make long state lines, so keep it off surfaces where the agent view must stay terse.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What the area holds. Names it for a screen reader and derives the tool name, so prefer a noun phrase such as \"Mission notes\".";
+            readonly required: true;
+        };
+        readonly value: {
+            readonly kind: "string";
+            readonly description: "The area's current text. The area is fully controlled.";
+            readonly required: true;
+        };
+        readonly onChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the new text on every change. The fill tool drives a real input event, so this runs for agent fills too.";
+            readonly required: true;
+        };
+        readonly rows: {
+            readonly kind: "number";
+            readonly description: "The visible line count before scrolling.";
+            readonly default: 4;
+        };
+        readonly placeholder: {
+            readonly kind: "string";
+            readonly description: "Ghost text shown while the area is empty.";
+        };
+        readonly hint: {
+            readonly kind: "string";
+            readonly description: "Guidance shown under the area and carried into the agent view. Replaced by error while one is set.";
+        };
+        readonly error: {
+            readonly kind: "string";
+            readonly description: "A validation message. Marks the area invalid for people, screen readers, and agents alike.";
+        };
+        readonly name: {
+            readonly kind: "string";
+            readonly description: "The native form name submitted with the surrounding form.";
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable the area and unregister its fill tool.";
+            readonly default: false;
+        };
+        readonly required: {
+            readonly kind: "boolean";
+            readonly description: "Mark the area required, visually and in the agent view.";
+            readonly default: false;
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name, when two areas on a page would otherwise collide.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the area without registering a fill tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly value: {
+            readonly description: "The area's current text.";
+            readonly attribute: "data-sprint-value";
+        };
+        readonly empty: {
+            readonly description: "Present while the area holds no text.";
+            readonly attribute: "data-sprint-empty";
+        };
+        readonly disabled: {
+            readonly description: "Present when the area cannot be edited.";
+            readonly attribute: "data-sprint-disabled";
+        };
+        readonly required: {
+            readonly description: "Present when the area must be filled.";
+            readonly attribute: "data-sprint-required";
+        };
+        readonly invalid: {
+            readonly description: "Present while an error is set.";
+            readonly attribute: "data-sprint-invalid";
+        };
+    };
+    readonly tools: {
+        readonly fill: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Textarea** \"Mission notes\" [empty] → tool `fill-mission-notes`\n  - part `hint` \"What the relief crew needs to know\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "A notes area";
+        readonly description: "Label, hint, and control are one component. In agent view it renders a live textarea an agent can type into.";
+        readonly code: "<Textarea\n  label=\"Mission notes\"\n  value={notes}\n  onChange={setNotes}\n  hint=\"What the relief crew needs to know\"\n/>";
+    }, {
+        readonly title: "A required area with an error";
+        readonly description: "The error replaces the hint and marks the area invalid on every surface.";
+        readonly code: "<Textarea\n  label=\"Abort reason\"\n  value={reason}\n  onChange={setReason}\n  required\n  rows={3}\n  error=\"State the reason before aborting.\"\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "textbox";
+        readonly keyboard: readonly ["Standard text editing", "Enter inserts a line break"];
+        readonly notes: "The label element is associated via htmlFor. An error sets aria-invalid and is linked with aria-describedby, as is the hint.";
+    };
+};
+
+export declare interface TextareaProps extends Omit<ComponentPropsWithRef<"div">, "onChange"> {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    rows?: number;
+    placeholder?: string;
+    hint?: string;
+    error?: string;
+    name?: string;
+    disabled?: boolean;
+    required?: boolean;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare function TextInput(props: TextInputProps): JSX.Element;
+
+export declare const textInputMeta: {
+    readonly name: "TextInput";
+    readonly category: "input";
+    readonly summary: "A single-line text field carrying its own label, hint, and error. Fully controlled, and it registers one fill tool that replaces the field's text with an explicit value.";
+    readonly whenToUse: "Use it for any free-form single-line value: a name, an email address, a search term. The label is part of the component, so a form never needs a separate label element, and the error prop is how validation reaches both a person and an agent.";
+    readonly whenNotToUse: "Do not use it for multi-line text, which is a Textarea. Do not use it to pick from a known set of values; that is a Select or a SegmentedControl. Do not use it for an on/off state, which is a Checkbox or a Switch.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What the field holds. Names the field for a screen reader and derives the tool name, so prefer a noun phrase such as \"Callsign\".";
+            readonly required: true;
+        };
+        readonly value: {
+            readonly kind: "string";
+            readonly description: "The field's current text. The field is fully controlled.";
+            readonly required: true;
+        };
+        readonly onChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the new text on every change. The fill tool drives a real input event, so this runs for agent fills too.";
+            readonly required: true;
+        };
+        readonly type: {
+            readonly kind: "enum";
+            readonly description: "The input type. \"password\" masks the field everywhere: the value never appears in agent attributes, the agent view, or tool results.";
+            readonly values: readonly ["text", "email", "url", "search", "password"];
+            readonly default: "text";
+        };
+        readonly placeholder: {
+            readonly kind: "string";
+            readonly description: "Ghost text shown while the field is empty.";
+        };
+        readonly hint: {
+            readonly kind: "string";
+            readonly description: "Guidance shown under the field and carried into the agent view. Replaced by error while one is set.";
+        };
+        readonly error: {
+            readonly kind: "string";
+            readonly description: "A validation message. Marks the field invalid for people, screen readers, and agents alike.";
+        };
+        readonly name: {
+            readonly kind: "string";
+            readonly description: "The native form name submitted with the surrounding form.";
+        };
+        readonly autoComplete: {
+            readonly kind: "string";
+            readonly description: "The native autocomplete hint, forwarded to the input.";
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable the field and unregister its fill tool.";
+            readonly default: false;
+        };
+        readonly required: {
+            readonly kind: "boolean";
+            readonly description: "Mark the field required, visually and in the agent view.";
+            readonly default: false;
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name, when two fields on a page would otherwise collide.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the field without registering a fill tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly value: {
+            readonly description: "The field's current text. Never present on a password field, which reflects filled instead.";
+            readonly attribute: "data-sprint-value";
+        };
+        readonly filled: {
+            readonly description: "Present when a password field holds text.";
+            readonly attribute: "data-sprint-filled";
+        };
+        readonly empty: {
+            readonly description: "Present while the field holds no text.";
+            readonly attribute: "data-sprint-empty";
+        };
+        readonly disabled: {
+            readonly description: "Present when the field cannot be edited.";
+            readonly attribute: "data-sprint-disabled";
+        };
+        readonly required: {
+            readonly description: "Present when the field must be filled.";
+            readonly attribute: "data-sprint-required";
+        };
+        readonly invalid: {
+            readonly description: "Present while an error is set.";
+            readonly attribute: "data-sprint-invalid";
+        };
+    };
+    readonly tools: {
+        readonly fill: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **TextInput** \"Callsign\" [empty, required] → tool `fill-callsign`\n  - part `hint` \"Uppercase, three to eight letters\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "A labelled field";
+        readonly description: "Label, hint, and control are one component. In agent view the hint becomes a part line and the field renders a live input an agent can type into.";
+        readonly code: "<TextInput\n  label=\"Callsign\"\n  value={callsign}\n  onChange={setCallsign}\n  hint=\"Uppercase, three to eight letters\"\n  placeholder=\"NOMAD\"\n/>";
+    }, {
+        readonly title: "A validation error";
+        readonly description: "The error replaces the hint, marks the field invalid on every surface, and reads back through the fill tool's result.";
+        readonly code: "<TextInput\n  label=\"Frequency\"\n  value={frequency}\n  onChange={setFrequency}\n  required\n  error=\"Out of band. Use 118.000 to 136.975.\"\n/>";
+    }, {
+        readonly title: "A password";
+        readonly description: "The value stays off every agent surface: state reflects filled or empty, and tool results never echo the text.";
+        readonly code: "<TextInput\n  label=\"Access code\"\n  type=\"password\"\n  value={code}\n  onChange={setCode}\n  autoComplete=\"current-password\"\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "textbox";
+        readonly keyboard: readonly ["Standard text editing", "Tab moves through the field"];
+        readonly notes: "The label element is associated via htmlFor. An error sets aria-invalid and is linked with aria-describedby, as is the hint. Focus is an offset keyline, never a rounded ring.";
+    };
+};
+
+export declare interface TextInputProps extends Omit<ComponentPropsWithRef<"div">, "onChange"> {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    type?: TextInputType;
+    placeholder?: string;
+    hint?: string;
+    error?: string;
+    name?: string;
+    autoComplete?: string;
+    disabled?: boolean;
+    required?: boolean;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare type TextInputType = "text" | "email" | "url" | "search" | "password";
+
+export declare const textMeta: {
+    readonly name: "Text";
+    readonly category: "typography";
+    readonly summary: "A run of prose, sized and toned from the semantic scale. In agent view it renders as its own text content, so an agent reads the words rather than inferring them from styling.";
+    readonly whenToUse: "Use it for every paragraph, caption, note, and inline status line, so tone carries meaning instead of an ad-hoc colour. tone=\"muted\" is the small print under a heading, tone=\"warning\" and tone=\"danger\" state that something is wrong, and tone=\"action\" confirms something is live.";
+    readonly whenNotToUse: "Do not use it for a section title; that is Heading. Do not put components inside it: it flattens its children to a single string for the agent view, so a nested Button would lose its tool.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The prose. Inline markup such as code or strong is fine; components are not.";
+            readonly required: true;
+        };
+        readonly tone: {
+            readonly kind: "enum";
+            readonly description: "What the text means, not just how it looks. Agents read this off the attribute.";
+            readonly values: readonly ["default", "muted", "action", "info", "warning", "danger"];
+            readonly default: "default";
+        };
+        readonly size: {
+            readonly kind: "enum";
+            readonly description: "Type size. \"small\" is the annotation size used for notes and captions.";
+            readonly values: readonly ["small", "normal"];
+            readonly default: "normal";
+        };
+        readonly as: {
+            readonly kind: "enum";
+            readonly description: "The element to render. Use span when the text sits inside another line of text.";
+            readonly values: readonly ["p", "span", "div"];
+            readonly default: "p";
+        };
+    };
+    readonly state: {
+        readonly tone: {
+            readonly description: "What the text is saying about the thing it describes.";
+            readonly attribute: "data-sprint-tone";
+            readonly values: readonly ["default", "muted", "action", "info", "warning", "danger"];
+        };
+        readonly size: {
+            readonly description: "The type size in use.";
+            readonly attribute: "data-sprint-size";
+            readonly values: readonly ["small", "normal"];
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Text** \"Tools stay registered across a view switch.\" [tone=muted]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A lede";
+        readonly code: "<Text>Every component renders normally for people and as text for agents.</Text>";
+    }, {
+        readonly title: "A note under a heading";
+        readonly description: "The small print that would otherwise be an untyped grey span.";
+        readonly code: "<Text tone=\"muted\" size=\"small\">Registered while the button is enabled.</Text>";
+    }, {
+        readonly title: "A live status line";
+        readonly description: "Tone is the whole message here, so an agent reading the attribute learns the same thing a person learns from the colour.";
+        readonly code: "<Text tone={ready ? \"action\" : \"warning\"} size=\"small\">\n  {ready ? \"WebMCP is available in this browser.\" : \"WebMCP is unavailable here.\"}\n</Text>";
+    }];
+};
+
+export declare interface TextProps extends Omit<ComponentPropsWithRef<"p">, "ref"> {
+    tone?: TextTone;
+    size?: TextSize;
+    as?: "p" | "span" | "div";
+    ref?: Ref<HTMLParagraphElement> | Ref<HTMLSpanElement> | Ref<HTMLDivElement>;
+}
+
+export declare type TextSize = "small" | "normal";
+
+export declare type TextTone = "default" | "muted" | "action" | "info" | "warning" | "danger";
+
+export declare const THEME_ATTRIBUTE = "data-sprint-theme";
+
+export declare interface Token {
+    kind: TokenKind;
+    text: string;
+}
+
+export declare function tokenize(code: string): Token[];
+
+export declare type TokenKind = "plain" | "tag" | "attr" | "string" | "keyword" | "number" | "punct" | "comment";
+
+export declare function toMarkdown(input: AgentNode | readonly AgentNode[], options?: MarkdownOptions): string;
+
+export declare const TOOL_ATTRIBUTE = "data-sprint-tool";
+
+export declare const TOOL_DESCRIPTION_LIMIT = 500;
+
+export declare const TOOL_NAMING_CONVENTION = "<scope>-<verb>-<label-slug>";
+
+export declare const TOOL_OUTPUT_LIMIT = 1500;
+
+export declare interface ToolAnnotations {
+    readOnlyHint?: boolean;
+    untrustedContentHint?: boolean;
+}
+
+export declare interface ToolDescriptor {
+    name: string;
+    description: string;
+    inputSchema: JsonSchemaObject;
+    execute: (inputs: Record<string, unknown>, context: ToolExecuteContext) => Promise<string | null> | string | null;
+    annotations?: ToolAnnotations;
+}
+
+export declare interface ToolExecuteContext {
+    signal: AbortSignal;
+}
+
+export declare function toolName(scope: readonly string[], verb: string, label: string): string | null;
+
+export declare function useAgentControls(): SprintAgentControls;
+
+export declare function useAgentFormat(): AgentFormatter;
+
+export declare function useAgentScope(): readonly string[];
+
+export declare function useAgentTool(options: UseAgentToolOptions): string | undefined;
+
+export declare interface UseAgentToolOptions {
+    spec: AgentToolSpec;
+    label: string | undefined;
+    nameOverride?: string | undefined;
+    inputSchema?: JsonSchemaObject | undefined;
+    enabled?: boolean;
+    execute: (inputs: Record<string, unknown>, context: ToolExecuteContext) => Promise<string | null> | string | null;
+}
+
+export declare function useSprintView(): SprintView;
+
+export declare function useSprintViewControl(): SprintViewValue;
+
+export declare function validateInputs(schema: JsonSchemaObject, inputs: Record<string, unknown>): string | null;
+
+export declare const version: string;
+
+export declare const VIEW_ATTRIBUTE = "data-sprint-view";
+
+export declare const VIEW_COPY_ATTRIBUTE = "data-sprint-view-copy";
+
+export { }