@westonkd/sprint 0.7.0 → 0.8.0

package/dist/index.d.ts

@@ -1,10 +1,14 @@
 import { ComponentPropsWithRef } from 'react';
+import { InputHTMLAttributes } from 'react';
 import { JSX } from 'react';
 import { MouseEvent as MouseEvent_2 } from 'react';
 import { MouseEventHandler } from 'react';
 import { Provider } from 'react';
+import { ReactElement } from 'react';
 import { ReactNode } from 'react';
 import { Ref } from 'react';
+import { RefObject } from 'react';
+import { TextareaHTMLAttributes } from 'react';
 
 export declare function accessibleText(element: Element): string | undefined;
 
@@ -180,6 +184,8 @@ export declare interface AgentToolSpec {
 
 export declare function Alert(props: AlertProps): JSX.Element;
 
+declare type AlertAnnouncement = "assertive" | "polite";
+
 export declare const alertMeta: {
     readonly name: "Alert";
     readonly category: "feedback";
@@ -203,6 +209,11 @@ export declare const alertMeta: {
             readonly values: readonly ["neutral", "info", "warning", "danger"];
             readonly default: "info";
         };
+        readonly announce: {
+            readonly kind: "enum";
+            readonly description: "Override how assistive technology announces the alert. assertive renders role=alert and interrupts; polite renders role=status and waits. Defaults to assertive for danger and warning and polite otherwise. Pass polite for a standing warning, such as an offline notice, that should not interrupt.";
+            readonly values: readonly ["assertive", "polite"];
+        };
         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.";
@@ -246,15 +257,20 @@ export declare const alertMeta: {
         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 title: "A standing warning";
+        readonly description: "A warning that stays on screen while a condition holds announces politely, so it does not interrupt whatever the person is reading.";
+        readonly code: "<Alert tone=\"warning\" announce=\"polite\" label=\"Offline\">Changes are saved on this device until the connection returns.</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.";
+        readonly notes: "Danger and warning render role=alert and announce assertively; info and neutral render role=status, unless announce overrides it. 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;
+    announce?: AlertAnnouncement;
     label?: string;
     onDismiss?: () => void;
     agentName?: string;
@@ -263,6 +279,78 @@ export declare interface AlertProps extends ComponentPropsWithRef<"div"> {
 
 export declare type AlertTone = "neutral" | "info" | "warning" | "danger";
 
+export declare function Avatar(props: AvatarProps): JSX.Element | null;
+
+export declare const avatarMeta: {
+    readonly name: "Avatar";
+    readonly category: "display";
+    readonly summary: "A person's photo in a circle, falling back to their initials when there is no photo or it fails to load.";
+    readonly whenToUse: "Use beside a person's name in a row, a card, or an account menu trigger. Pass the full name; it is the accessible name and the source of the initials. Set decorative when the name is already printed right beside it, so it is not read twice.";
+    readonly whenNotToUse: "Do not use for a logo or an illustration; that is an Image. Do not use as a button on its own; put it inside a Button or a Menu trigger that carries the label.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly name: {
+            readonly kind: "string";
+            readonly description: "The person's name. Names the avatar and supplies the initials.";
+            readonly required: true;
+        };
+        readonly src: {
+            readonly kind: "string";
+            readonly description: "The photo's URL. Without it, or if it fails to load, the initials show instead.";
+        };
+        readonly size: {
+            readonly kind: "enum";
+            readonly description: "small for dense rows, medium beside body text, large in a profile header.";
+            readonly values: readonly ["small", "medium", "large"];
+            readonly default: "medium";
+        };
+        readonly decorative: {
+            readonly kind: "boolean";
+            readonly description: "Hide the avatar from assistive technology and the agent view, for when the name is printed beside it.";
+            readonly default: false;
+        };
+    };
+    readonly state: {
+        readonly photo: {
+            readonly description: "Present while a photo is showing rather than initials.";
+            readonly attribute: "data-sprint-photo";
+        };
+        readonly size: {
+            readonly description: "The size, when it is not medium.";
+            readonly attribute: "data-sprint-size";
+            readonly values: readonly ["small", "large"];
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Avatar** \"Ada Okafor\" [photo]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A photo";
+        readonly code: "<Avatar name=\"Ada Okafor\" src=\"media/portrait.svg\" />";
+    }, {
+        readonly title: "Initials when there is no photo";
+        readonly description: "The first and last initials, on the inset surface.";
+        readonly code: "<Avatar name=\"Brother Lind\" size=\"large\" />";
+    }, {
+        readonly title: "Beside a printed name";
+        readonly description: "decorative keeps a screen reader and an agent from hearing the name twice.";
+        readonly code: "<Stack direction=\"row\" gap=\"snug\" align=\"center\">\n  <Avatar name=\"Sister Amaral\" size=\"small\" decorative />\n  <Text as=\"span\">Sister Amaral</Text>\n</Stack>";
+    }];
+    readonly a11y: {
+        readonly role: "img";
+        readonly notes: "A role=img element named by the person's name, with the photo's own alt left empty so the name is read once. decorative switches it to aria-hidden.";
+    };
+};
+
+export declare interface AvatarProps extends Omit<ComponentPropsWithRef<"span">, "children"> {
+    name: string;
+    src?: string;
+    size?: AvatarSize;
+    decorative?: boolean;
+}
+
+export declare type AvatarSize = "small" | "medium" | "large";
+
 export declare function Breadcrumb(props: BreadcrumbProps): JSX.Element;
 
 export declare interface BreadcrumbAction {
@@ -475,6 +563,25 @@ export declare const buttonMeta: {
             readonly values: readonly ["neutral", "action", "danger"];
             readonly default: "neutral";
         };
+        readonly size: {
+            readonly kind: "enum";
+            readonly description: "medium for ordinary forms and toolbars; small for dense surfaces such as table rows, cards and toasts.";
+            readonly values: readonly ["medium", "small"];
+            readonly default: "medium";
+        };
+        readonly icon: {
+            readonly kind: "node";
+            readonly description: "An icon drawn before the label, sized to the text. It is decorative and hidden from assistive technology; the label still names the button.";
+        };
+        readonly iconEnd: {
+            readonly kind: "node";
+            readonly description: "An icon drawn after the label, such as a chevron on a button that opens something. Ignored when hideLabel is set.";
+        };
+        readonly hideLabel: {
+            readonly kind: "boolean";
+            readonly description: "Show only the icon, as a square button. The label stays in the page for screen readers and agents, names the press tool, and appears as a tooltip on hover and focus. Requires icon.";
+            readonly default: false;
+        };
         readonly block: {
             readonly kind: "boolean";
             readonly description: "Render as a full-width bar. Combine with tone=\"action\" for the primary action of a region.";
@@ -510,6 +617,11 @@ export declare const buttonMeta: {
             readonly attribute: "data-sprint-tone";
             readonly values: readonly ["neutral", "action", "danger"];
         };
+        readonly size: {
+            readonly description: "Present as small on a compact button.";
+            readonly attribute: "data-sprint-size";
+            readonly values: readonly ["small"];
+        };
         readonly block: {
             readonly description: "Present when the button renders as a full-width bar.";
             readonly attribute: "data-sprint-block";
@@ -530,6 +642,14 @@ export declare const buttonMeta: {
         readonly example: "- **Button** \"Prepare launch\" [tone=action] → tool `press-prepare-launch`";
     };
     readonly examples: readonly [{
+        readonly title: "An icon-only button";
+        readonly description: "hideLabel draws only the icon. The label still names the button and its tool, and shows as a tooltip, so the control is never a mystery.";
+        readonly code: "<Button icon={<SidebarIcon />} hideLabel onClick={collapse}>\n  Hide sidebar\n</Button>";
+    }, {
+        readonly title: "A compact button with an icon";
+        readonly description: "size=\"small\" for a dense row; the icon sits before the label.";
+        readonly code: "<Button size=\"small\" icon={<PlusIcon />} onClick={addSpeaker}>\n  Add speaker\n</Button>";
+    }, {
         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>";
@@ -558,12 +678,18 @@ export declare const buttonMeta: {
 
 export declare interface ButtonProps extends ComponentPropsWithRef<"button"> {
     tone?: ButtonTone;
+    size?: ButtonSize;
+    icon?: ReactNode;
+    iconEnd?: ReactNode;
+    hideLabel?: boolean;
     block?: boolean;
     loading?: boolean;
     agentName?: string;
     agentTool?: boolean;
 }
 
+export declare type ButtonSize = "medium" | "small";
+
 export declare type ButtonTone = "neutral" | "action" | "danger";
 
 export declare function Card(props: CardProps): JSX.Element;
@@ -768,6 +894,11 @@ export declare const checkboxMeta: {
             readonly description: "Whether the box is checked. The box is fully controlled.";
             readonly required: true;
         };
+        readonly indeterminate: {
+            readonly kind: "boolean";
+            readonly description: "Show the box as partly checked, for a parent box whose children are some checked and some not. It overrides checked visually and reads as checked=mixed to agents and assistive technology. Pressing a mixed box calls onChange(true); the page then clears indeterminate.";
+            readonly default: false;
+        };
         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.";
@@ -807,7 +938,7 @@ export declare const checkboxMeta: {
     };
     readonly state: {
         readonly checked: {
-            readonly description: "Present while the box is checked.";
+            readonly description: "Present while the box is checked, and \"mixed\" while it is indeterminate.";
             readonly attribute: "data-sprint-checked";
         };
         readonly disabled: {
@@ -841,6 +972,10 @@ export declare const checkboxMeta: {
         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 title: "A partly picked group";
+        readonly description: "A parent box over a group shows mixed while only some of the group is picked. Pressing it picks everything.";
+        readonly code: "<Checkbox\n  label=\"Whole crew\"\n  checked={picked.length === crew.length}\n  indeterminate={picked.length > 0 && picked.length < crew.length}\n  onChange={(next) => setPicked(next ? crew : [])}\n/>";
     }];
     readonly a11y: {
         readonly role: "checkbox";
@@ -852,6 +987,7 @@ export declare const checkboxMeta: {
 export declare interface CheckboxProps extends Omit<ComponentPropsWithRef<"div">, "onChange"> {
     label: string;
     checked: boolean;
+    indeterminate?: boolean;
     onChange: (checked: boolean) => void;
     hint?: string;
     error?: string;
@@ -982,6 +1118,10 @@ export declare interface ChoiceOption {
     glyph?: string;
 }
 
+export declare const CHOOSE_COMBOBOX_TOOL: AgentToolSpec;
+
+export declare const CHOOSE_MENU_TOOL: AgentToolSpec;
+
 export declare const CHOOSE_TOOL: AgentToolSpec;
 
 export declare function clamp(text: string, max: number): string;
@@ -1064,6 +1204,214 @@ export declare interface CodeBlockProps extends ComponentPropsWithRef<"figure">
 
 export declare type CodeLanguage = "tsx" | "json" | "bash" | "text";
 
+export declare function Combobox(props: ComboboxProps): JSX.Element;
+
+export declare type ComboboxFilter = (option: ComboboxOption, query: string) => boolean;
+
+export declare const comboboxMeta: {
+    readonly name: "Combobox";
+    readonly category: "input";
+    readonly summary: "A searchable single-choice field for long lists: type to filter, arrow to an option, Enter to pick. Options can be grouped, described, limited per group and rendered your own way. Registers one choose tool that takes a label or a search.";
+    readonly whenToUse: "Use when there are too many options to scan: a member picker over hundreds of people, a calling picker grouped by organization, a board filter. Options hold data: { value, label, group?, description?, keywords?, disabled? }. The default filter matches every word of the query against the label, description and keywords, ignoring case and accents. For a server-side search, pass filter={false}, update options from onQueryChange, and set loading while results arrive.";
+    readonly whenNotToUse: "Do not use for a short list a person can scan at once; that is a Select, or a SegmentedControl for two to four options. Do not use for free text that only suggests; this field only accepts its options. Do not use for choosing several values.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What is being chosen, such as \"Member\". Names the field and derives the tool name.";
+            readonly required: true;
+        };
+        readonly options: {
+            readonly kind: "array";
+            readonly description: "The options: { value, label, group?, description?, keywords?, disabled? }. Consecutive and non-consecutive options sharing a group are gathered under one heading, in the order groups first appear. keywords are extra search terms that are never shown.";
+            readonly required: true;
+        };
+        readonly value: {
+            readonly kind: "string";
+            readonly description: "The chosen option's value, or an empty string for none. Fully controlled.";
+            readonly required: true;
+        };
+        readonly onChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the chosen value, or an empty string when cleared.";
+            readonly required: true;
+        };
+        readonly placeholder: {
+            readonly kind: "string";
+            readonly description: "Ghost text while nothing is chosen or while searching.";
+        };
+        readonly hint: {
+            readonly kind: "string";
+            readonly description: "Guidance under the field. Replaced by error while one is set.";
+        };
+        readonly error: {
+            readonly kind: "string";
+            readonly description: "A validation message that marks the field invalid.";
+        };
+        readonly name: {
+            readonly kind: "string";
+            readonly description: "The native form name the chosen value submits under.";
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable the field and unregister the choose tool.";
+            readonly default: false;
+        };
+        readonly required: {
+            readonly kind: "boolean";
+            readonly description: "Mark the field required. A required field is not clearable by default.";
+            readonly default: false;
+        };
+        readonly hideLabel: {
+            readonly kind: "boolean";
+            readonly description: "Hide the label visually while keeping it for screen readers and agents. Pair it with a placeholder.";
+            readonly default: false;
+        };
+        readonly clearable: {
+            readonly kind: "boolean";
+            readonly description: "Show a clear control while something is chosen. Defaults to not required.";
+        };
+        readonly clearLabel: {
+            readonly kind: "string";
+            readonly description: "Accessible name of the clear control.";
+            readonly default: "Clear";
+        };
+        readonly loading: {
+            readonly kind: "boolean";
+            readonly description: "Show a small spinner in the field while options are being fetched.";
+            readonly default: false;
+        };
+        readonly filter: {
+            readonly kind: "handler";
+            readonly description: "(option, query) => boolean, replacing the built-in word match. Pass false when the options are already the results of a search the page ran.";
+        };
+        readonly onQueryChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the search text as it changes, and with an empty string on close.";
+        };
+        readonly groupLimit: {
+            readonly kind: "number";
+            readonly description: "Show at most this many options per group, with a \"more; keep typing\" note for the rest, so one large group cannot bury the others.";
+        };
+        readonly limit: {
+            readonly kind: "number";
+            readonly description: "Show at most this many options in total.";
+            readonly default: 200;
+        };
+        readonly emptyLabel: {
+            readonly kind: "string";
+            readonly description: "What the list says when nothing matches.";
+            readonly default: "No matches";
+        };
+        readonly renderOption: {
+            readonly kind: "handler";
+            readonly description: "(option) => ReactNode, drawing an option your own way, such as with an Avatar. It is the human rendering only: the label is still what is searched, announced and offered to agents.";
+        };
+        readonly inputRef: {
+            readonly kind: "object";
+            readonly description: "A ref to the underlying input, for focusing it.";
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the field without registering the choose tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly value: {
+            readonly description: "The chosen option's label.";
+            readonly attribute: "data-sprint-value";
+        };
+        readonly empty: {
+            readonly description: "Present while nothing is chosen.";
+            readonly attribute: "data-sprint-empty";
+        };
+        readonly options: {
+            readonly description: "How many options the field holds.";
+            readonly attribute: "data-sprint-options";
+        };
+        readonly loading: {
+            readonly description: "Present while options are being fetched.";
+            readonly attribute: "data-sprint-loading";
+        };
+        readonly disabled: {
+            readonly description: "Present when the field cannot be changed.";
+            readonly attribute: "data-sprint-disabled";
+        };
+        readonly required: {
+            readonly description: "Present when a choice is needed.";
+            readonly attribute: "data-sprint-required";
+        };
+        readonly invalid: {
+            readonly description: "Present while an error is set.";
+            readonly attribute: "data-sprint-invalid";
+        };
+    };
+    readonly tools: {
+        readonly choose: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Combobox** \"Member\" [empty, options=312, listed=50] → tool `choose-member`\n  - part `option` \"Ada Okafor\" [group=Elders quorum]";
+    };
+    readonly examples: readonly [{
+        readonly title: "A grouped member picker";
+        readonly description: "Hundreds of members grouped by organization, at most five per group until the person types. An agent passes a name, or part of one, to the choose tool.";
+        readonly code: "<Combobox\n  label=\"Member\"\n  placeholder=\"Search members\"\n  value={memberId}\n  onChange={setMemberId}\n  groupLimit={5}\n  options={members.map((member) => ({\n    value: member.id,\n    label: member.name,\n    group: member.organization,\n    keywords: [member.preferredName],\n  }))}\n/>";
+    }, {
+        readonly title: "Options drawn your own way";
+        readonly description: "renderOption draws each option with an avatar; the label still drives search, announcement and the agent view.";
+        readonly code: "<Combobox\n  label=\"Speaker\"\n  value={speaker}\n  onChange={setSpeaker}\n  options={members}\n  renderOption={(option) => (\n    <Stack direction=\"row\" gap=\"snug\" align=\"center\">\n      <Avatar name={option.label} size=\"small\" decorative />\n      <Text as=\"span\">{option.label}</Text>\n    </Stack>\n  )}\n/>";
+    }, {
+        readonly title: "A server-side search";
+        readonly description: "filter={false} trusts the options as given; the page searches on each onQueryChange and shows the spinner meanwhile.";
+        readonly code: "<Combobox\n  label=\"Calling\"\n  value={calling}\n  onChange={setCalling}\n  filter={false}\n  onQueryChange={search}\n  loading={searching}\n  options={results}\n  error={calling === \"\" ? \"Choose a calling.\" : undefined}\n  required\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "combobox";
+        readonly keyboard: readonly ["Typing filters and opens the list", "Down and Up Arrow open the list and move between enabled options", "Ctrl+Home and Ctrl+End jump to the first and last option", "Enter chooses the highlighted option", "Escape closes the list and restores the chosen label"];
+        readonly notes: "An editable combobox with list autocomplete. Focus stays in the input and aria-activedescendant follows the highlighted option. Groups are labelled role=group sections. The list is a popover in the top layer, rendered in place, so it opens above a modal Dialog and flips above the field when there is no room below.";
+    };
+};
+
+export declare interface ComboboxOption {
+    value: string;
+    label: string;
+    group?: string | undefined;
+    description?: string | undefined;
+    keywords?: readonly string[] | undefined;
+    disabled?: boolean | undefined;
+}
+
+export declare interface ComboboxProps extends Omit<ComponentPropsWithRef<"div">, "onChange"> {
+    label: string;
+    options: readonly ComboboxOption[];
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    hint?: string | undefined;
+    error?: string | undefined;
+    name?: string;
+    disabled?: boolean;
+    required?: boolean;
+    hideLabel?: boolean;
+    clearable?: boolean;
+    clearLabel?: string;
+    loading?: boolean;
+    filter?: ComboboxFilter | false;
+    onQueryChange?: (query: string) => void;
+    groupLimit?: number;
+    limit?: number;
+    emptyLabel?: string;
+    renderOption?: (option: ComboboxOption) => ReactNode;
+    inputRef?: Ref<HTMLInputElement>;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
 export declare const COMPONENT_ATTRIBUTE = "data-sprint";
 
 export declare function CopyField(props: CopyFieldProps): JSX.Element;
@@ -1260,6 +1608,16 @@ export declare const dialogMeta: {
             readonly description: "Render the title as a real heading at this level, joining the page outline.";
             readonly values: readonly ["2", "3", "4"];
         };
+        readonly size: {
+            readonly kind: "enum";
+            readonly description: "The dialog's width: small (26rem) for a confirmation, medium (36rem) for a short form, large (52rem) for a table or a two-column form. Every size shrinks to fit a phone.";
+            readonly values: readonly ["small", "medium", "large"];
+            readonly default: "small";
+        };
+        readonly initialFocus: {
+            readonly kind: "object";
+            readonly description: "A ref to the element that takes focus when the dialog opens, such as the first field of a form or the safe choice in a destructive confirmation. Without it the browser focuses the first focusable element, which is the close control.";
+        };
         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.";
@@ -1279,6 +1637,11 @@ export declare const dialogMeta: {
             readonly description: "Present while the dialog is shown. A closed dialog is absent from the DOM entirely.";
             readonly attribute: "data-sprint-open";
         };
+        readonly size: {
+            readonly description: "The width the dialog was given, when it is not the default small.";
+            readonly attribute: "data-sprint-size";
+            readonly values: readonly ["medium", "large"];
+        };
     };
     readonly tools: {
         readonly close: AgentToolSpec;
@@ -1294,6 +1657,10 @@ export declare const dialogMeta: {
         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 title: "A form that focuses its first field";
+        readonly description: "A medium dialog for a short form. initialFocus puts the cursor in the field instead of on the close control, so the person can type straight away.";
+        readonly code: "<Dialog\n  label=\"Rename station\"\n  size=\"medium\"\n  open={renaming}\n  initialFocus={nameField}\n  onClose={() => setRenaming(false)}\n>\n  <Stack gap=\"tight\">\n    <TextInput label=\"Station name\" value={name} onChange={setName} inputRef={nameField} />\n    <Button tone=\"action\" onClick={save}>Save name</Button>\n  </Stack>\n</Dialog>";
     }];
     readonly a11y: {
         readonly role: "dialog";
@@ -1307,11 +1674,15 @@ export declare interface DialogProps extends Omit<ComponentPropsWithRef<"dialog"
     open: boolean;
     onClose: () => void;
     headingLevel?: DialogHeadingLevel;
+    size?: DialogSize;
+    initialFocus?: RefObject<HTMLElement | null>;
     owner?: string;
     agentName?: string;
     agentTool?: boolean;
 }
 
+declare type DialogSize = "small" | "medium" | "large";
+
 export declare function Disclosure(props: DisclosureProps): JSX.Element;
 
 export declare const disclosureMeta: {
@@ -1663,13 +2034,17 @@ export declare const FILL_TEXTAREA_TOOL: AgentToolSpec;
 
 export declare const FILL_TOOL: AgentToolSpec;
 
+export declare type FloatingAlign = "start" | "center" | "end";
+
+export declare type FloatingSide = "below" | "above";
+
 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 type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
 
 export declare const headingMeta: {
     readonly name: "Heading";
@@ -1686,15 +2061,25 @@ export declare const headingMeta: {
         };
         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 description: "Outline depth, rendered as the matching h element. 1 is the page title and there should be one per page. 5 and 6 take the level-4 voice unless size says otherwise.";
+            readonly values: readonly ["1", "2", "3", "4", "5", "6"];
             readonly default: "2";
         };
+        readonly size: {
+            readonly kind: "enum";
+            readonly description: "The type voice, from 1 (display) to 4 (smallest), when it should differ from the level. Use it when a heading's place in the outline and its visual weight disagree, such as a level-2 title inside a dense card that should read small.";
+            readonly values: readonly ["1", "2", "3", "4"];
+        };
     };
     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", "5", "6"];
+        };
+        readonly size: {
+            readonly description: "The type voice, present only when it differs from the level.";
+            readonly attribute: "data-sprint-size";
             readonly values: readonly ["1", "2", "3", "4"];
         };
     };
@@ -1708,13 +2093,22 @@ export declare const headingMeta: {
         readonly title: "A section title";
         readonly description: "The default level, for a region inside a page.";
         readonly code: "<Heading>Every variant</Heading>";
+    }, {
+        readonly title: "A deep heading in a small voice";
+        readonly description: "The outline needs a level-3 heading, but inside a compact card it should read at the smallest size.";
+        readonly code: "<Heading level={3} size={4}>Sunday speakers</Heading>";
     }];
 };
 
 export declare interface HeadingProps extends ComponentPropsWithRef<"h2"> {
     level?: HeadingLevel;
+    size?: HeadingSize;
 }
 
+declare type HeadingSize = 1 | 2 | 3 | 4;
+
+export declare function hideFloating(element: HTMLElement): void;
+
 declare function Image_2(props: ImageProps): JSX.Element | null;
 export { Image_2 as Image }
 
@@ -1814,6 +2208,8 @@ export declare type ImageRatio = "1:1" | "4:3" | "3:2" | "16:9" | "auto";
 
 export declare type ImageStatus = "loading" | "ready" | "error";
 
+export declare function initialsOf(name: string): string;
+
 export declare function isModelContextAvailable(): boolean;
 
 export declare interface JsonSchemaObject {
@@ -1833,6 +2229,42 @@ export declare interface JsonSchemaProperty {
 
 export declare type JsonSchemaType = "string" | "number" | "integer" | "boolean";
 
+export declare function Kbd(props: KbdProps): JSX.Element;
+
+export declare const kbdMeta: {
+    readonly name: "Kbd";
+    readonly category: "typography";
+    readonly summary: "A keyboard key or shortcut, drawn as key caps. Pass the combination as text joined with plus signs.";
+    readonly whenToUse: "Use to tell a person which keys do something: an undo hint in a toast, a shortcut beside a menu item's description, a search field's focus key. Write the combination as one string, such as \"Ctrl+Z\" or \"Shift+Enter\"; each part becomes its own cap.";
+    readonly whenNotToUse: "Do not use for code or for a value someone types into a field; that is code or a CodeBlock. Do not use it as a control; it does not press anything.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "string";
+            readonly description: "The keys, joined with \"+\", such as \"Ctrl+Z\". A lone \"+\" is a key in its own right.";
+            readonly required: true;
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Kbd** \"Ctrl+Z\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "An undo shortcut";
+        readonly code: "<Kbd>Ctrl+Z</Kbd>";
+    }, {
+        readonly title: "A single key";
+        readonly description: "One key is one cap.";
+        readonly code: "<Kbd>/</Kbd>";
+    }];
+    readonly a11y: {
+        readonly notes: "A kbd element nesting one kbd per key, which is the HTML pattern for a key combination. The plus signs between caps are hidden from assistive technology, which reads the keys in order.";
+    };
+};
+
+export declare interface KbdProps extends Omit<ComponentPropsWithRef<"kbd">, "children"> {
+    children: string;
+}
+
 export declare function Link(props: LinkProps): JSX.Element;
 
 export declare const linkMeta: {
@@ -2035,17 +2467,149 @@ export declare interface MarkdownOptions {
     includeSummary?: boolean;
 }
 
-export declare function MetaLine(props: MetaLineProps): JSX.Element | null;
+export declare const matchesQuery: ComboboxFilter;
 
-export declare interface MetaLineEntry {
-    term: string;
-    detail: string;
+export declare function Menu(props: MenuProps): JSX.Element;
+
+export declare interface MenuItem {
+    label: string;
+    onSelect?: () => void;
+    href?: string;
+    external?: boolean;
+    tone?: MenuItemTone;
+    disabled?: boolean;
+    checked?: boolean;
+    group?: string;
+    icon?: ReactNode;
 }
 
-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.";
+export declare type MenuItemTone = "neutral" | "danger";
+
+export declare const menuMeta: {
+    readonly name: "Menu";
+    readonly category: "action";
+    readonly summary: "A button that opens a short list of actions, links, or one-of-several choices. Registers one choose tool enumerating the items an agent can run.";
+    readonly whenToUse: "Use to gather secondary actions behind one control: a card's edit, duplicate and delete; an account menu; a share menu; a switcher between a few named views. Items hold data, not elements: each is { label, onSelect?, href?, checked?, tone?, disabled?, group?, icon? }. An item with checked becomes a radio choice with a visible mark, so a menu can also pick one value from a short list.";
+    readonly whenNotToUse: "Do not use for the primary action of a view; that is a Button. Do not use to pick a form value that is submitted with other fields; that is a Select or a SegmentedControl. Do not use for navigation that should stay visible; that is a Nav or a Breadcrumb. Items take plain text labels and an optional icon, never components.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What the menu holds, such as \"Card actions\" or \"Share\". It is the trigger's text, names the menu for assistive technology, and derives the choose tool name.";
+            readonly required: true;
+        };
+        readonly items: {
+            readonly kind: "array";
+            readonly description: "The items in order: { label, onSelect?, href?, external?, checked?, tone?, disabled?, group?, icon? }. onSelect runs the item; href makes it a link, which agents reach by URL rather than the tool. checked, true or false, makes the item a radio choice. tone=\"danger\" marks a destructive item. Consecutive items sharing a group string are gathered under that heading.";
+            readonly required: true;
+        };
+        readonly icon: {
+            readonly kind: "node";
+            readonly description: "An icon drawn on the trigger before its label.";
+        };
+        readonly hideLabel: {
+            readonly kind: "boolean";
+            readonly description: "Show only the icon on a square trigger, such as a three-dot card menu. The label stays the accessible name and the tool name, and shows as a tooltip. Requires icon.";
+            readonly default: false;
+        };
+        readonly size: {
+            readonly kind: "enum";
+            readonly description: "The trigger's size, matching Button.";
+            readonly values: readonly ["medium", "small"];
+            readonly default: "medium";
+        };
+        readonly align: {
+            readonly kind: "enum";
+            readonly description: "Which edge of the trigger the list lines up with. Use end for a menu at the right of a card or a toolbar.";
+            readonly values: readonly ["start", "center", "end"];
+            readonly default: "start";
+        };
+        readonly side: {
+            readonly kind: "enum";
+            readonly description: "Where the list prefers to open. It flips to the other side when there is no room, so a menu low on the screen still opens fully in view.";
+            readonly values: readonly ["below", "above"];
+            readonly default: "below";
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable the trigger and unregister the choose tool.";
+            readonly default: false;
+        };
+        readonly onOpenChange: {
+            readonly kind: "handler";
+            readonly description: "Called with true when the list opens and false when it closes.";
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name, such as when every card on a page has a menu called Actions.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the menu without registering the choose tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly open: {
+            readonly description: "Present while the list is open on screen.";
+            readonly attribute: "data-sprint-open";
+        };
+        readonly disabled: {
+            readonly description: "Present when the menu cannot be opened.";
+            readonly attribute: "data-sprint-disabled";
+        };
+    };
+    readonly tools: {
+        readonly choose: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Menu** \"Card actions\" → tool `choose-card-actions`\n  - part `item` \"Edit\"\n  - part `item` \"Delete\" [tone=danger]";
+    };
+    readonly examples: readonly [{
+        readonly title: "Card actions";
+        readonly description: "A three-dot trigger at the end of a card. The destructive item is marked, and an agent runs either item through the choose tool without opening anything.";
+        readonly code: "<Menu\n  label=\"Card actions\"\n  icon={<MoreIcon />}\n  hideLabel\n  size=\"small\"\n  align=\"end\"\n  items={[\n    { label: \"Edit\", onSelect: edit },\n    { label: \"Duplicate\", onSelect: duplicate },\n    { label: \"Delete\", tone: \"danger\", onSelect: remove },\n  ]}\n/>";
+    }, {
+        readonly title: "Links and actions together";
+        readonly description: "An item with href is a real link and is left out of the tool, because a URL already reaches it. Groups gather related items under a heading.";
+        readonly code: "<Menu\n  label=\"Account\"\n  items={[\n    { label: \"Profile\", href: \"#/profile\", group: \"Signed in as Nomad\" },\n    { label: \"Settings\", href: \"#/settings\", group: \"Signed in as Nomad\" },\n    { label: \"Sign out\", onSelect: signOut },\n  ]}\n/>";
+    }, {
+        readonly title: "Choosing one of several";
+        readonly description: "checked turns items into radio choices with a visible mark, so the menu doubles as a compact picker. It opens with focus on the checked item.";
+        readonly code: "<Menu\n  label={plannerLabel}\n  agentName=\"Planner\"\n  items={planners.map((name) => ({\n    label: name,\n    checked: name === planner,\n    onSelect: () => setPlanner(name),\n  }))}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "menu";
+        readonly keyboard: readonly ["Enter, Space or Down Arrow on the trigger opens the list on the first or checked item", "Up Arrow on the trigger opens it on the last item", "Arrow keys move between items and wrap", "Home and End move to the first and last item", "A letter moves to the next item starting with it", "Escape closes the list and returns focus to the trigger", "Tab closes the list and moves on"];
+        readonly notes: "The trigger has aria-haspopup=menu and aria-expanded. Items are menuitem buttons or links, or menuitemradio with aria-checked. The list is a popover in the top layer rendered inside the menu's own DOM, so it opens above a modal Dialog and is never clipped by an ancestor's overflow. Disabled items are skipped by the keyboard.";
+    };
+};
+
+export declare interface MenuProps extends Omit<ComponentPropsWithRef<"div">, "children"> {
+    label: string;
+    items: readonly MenuItem[];
+    icon?: ReactNode;
+    hideLabel?: boolean;
+    size?: ButtonSize;
+    align?: FloatingAlign;
+    side?: FloatingSide;
+    disabled?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    agentName?: string;
+    agentTool?: 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. By default the line truncates with an ellipsis rather than wrapping; set wrap where it sits in a narrow container and every entry has to stay visible.";
     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";
@@ -2556,6 +3120,8 @@ export declare interface PendingProps extends ComponentPropsWithRef<"div"> {
     label: string;
 }
 
+export declare function placeFloating(floating: HTMLElement, anchor: HTMLElement, side?: FloatingSide, align?: FloatingAlign, matchWidth?: boolean): FloatingSide;
+
 export declare const PRESS_TOOL: AgentToolSpec;
 
 export declare function Progress(props: ProgressProps): JSX.Element;
@@ -2582,6 +3148,17 @@ export declare const progressMeta: {
             readonly description: "The value at which the work is complete.";
             readonly default: 100;
         };
+        readonly tone: {
+            readonly kind: "enum";
+            readonly values: readonly ["info", "action", "warning", "danger"];
+            readonly description: "The fill colour. info is the default for ordinary loading; action suits a goal being worked towards; warning and danger mark a bar running out or over a limit.";
+            readonly default: "info";
+        };
+        readonly hideLabel: {
+            readonly kind: "boolean";
+            readonly description: "Hide the label and percentage visually while keeping the label as the bar's accessible name and agent label. Use when a nearby heading already says what the bar measures.";
+            readonly default: false;
+        };
     };
     readonly state: {
         readonly loading: {
@@ -2592,6 +3169,10 @@ export declare const progressMeta: {
             readonly description: "The fraction complete as a whole percentage, such as 40%. Absent while indeterminate.";
             readonly attribute: "data-sprint-value";
         };
+        readonly tone: {
+            readonly description: "The fill tone, when it is not the default info.";
+            readonly attribute: "data-sprint-tone";
+        };
     };
     readonly agentView: {
         readonly example: "- **Progress** \"Importing manifest\" [loading, value=40%]";
@@ -2608,6 +3189,10 @@ export declare const progressMeta: {
         readonly title: "Complete";
         readonly description: "At max the loading state clears, so the line reads as finished rather than stalled.";
         readonly code: "<Progress label=\"Importing manifest\" value={240} max={240} />";
+    }, {
+        readonly title: "A bare goal bar";
+        readonly description: "A heading beside the bar already names it, so the label is hidden and only the bar shows, in the action tone.";
+        readonly code: "<Progress label=\"Notes this week\" value={3} max={5} tone=\"action\" hideLabel />";
     }];
     readonly a11y: {
         readonly role: "progressbar";
@@ -2619,6 +3204,198 @@ export declare interface ProgressProps extends Omit<ComponentPropsWithRef<"div">
     label: string;
     value?: number;
     max?: number;
+    tone?: ProgressTone;
+    hideLabel?: boolean;
+}
+
+declare type ProgressTone = "info" | "action" | "warning" | "danger";
+
+export declare function Prose(props: ProseProps): JSX.Element;
+
+export declare const proseMeta: {
+    readonly name: "Prose";
+    readonly category: "typography";
+    readonly summary: "Typography for long-form rendered content such as Markdown: headings, paragraphs, lists, links, code, tables and quotes, in the theme's voice.";
+    readonly whenToUse: "Wrap HTML you did not lay out yourself: member notes rendered from Markdown, an agenda's program details, a help article. Pass the original Markdown as source and the agent view carries it verbatim, which is better for an agent than flattened text. Sprint does not parse Markdown; render it with the library of your choice and pass the result as children.";
+    readonly whenNotToUse: "Do not use for interface copy you write yourself; that is Text and Heading. Do not put interactive Sprint components inside it; Prose styles plain elements.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The rendered content: plain HTML elements such as p, ul, a, code and table.";
+            readonly required: true;
+        };
+        readonly source: {
+            readonly kind: "string";
+            readonly description: "The Markdown the children were rendered from. The agent view shows this instead of the flattened text, keeping lists, links and emphasis intact.";
+        };
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What the content is, such as \"Member notes\". Makes the block a labelled region and names it in the agent view.";
+        };
+        readonly size: {
+            readonly kind: "enum";
+            readonly description: "small for notes inside a card or a side panel.";
+            readonly values: readonly ["small", "normal"];
+            readonly default: "normal";
+        };
+    };
+    readonly state: {
+        readonly size: {
+            readonly description: "Present as small for the compact size.";
+            readonly attribute: "data-sprint-size";
+            readonly values: readonly ["small"];
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Prose** \"Member notes\"\n  - part `content` \"Moved in **March**. Plays the organ.\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "Rendered Markdown";
+        readonly description: "The page renders Markdown however it likes and passes the original as source, which the agent view carries unchanged.";
+        readonly code: "<Prose label=\"Member notes\" source={notes}>\n  <Markdown>{notes}</Markdown>\n</Prose>";
+    }, {
+        readonly title: "Compact notes";
+        readonly code: "<Prose size=\"small\">\n  <p>Prefers <strong>text</strong> after six.</p>\n  <ul>\n    <li>Organ</li>\n    <li>Youth program</li>\n  </ul>\n</Prose>";
+    }];
+    readonly a11y: {
+        readonly role: "region";
+        readonly notes: "With a label the block is a named region; without one it adds no semantics of its own. The content keeps its own elements, so headings join the page outline.";
+    };
+};
+
+export declare interface ProseProps extends ComponentPropsWithRef<"div"> {
+    label?: string;
+    source?: string;
+    size?: ProseSize;
+}
+
+export declare type ProseSize = "small" | "normal";
+
+export declare function RadioGroup(props: RadioGroupProps): JSX.Element;
+
+export declare const radioGroupMeta: {
+    readonly name: "RadioGroup";
+    readonly category: "input";
+    readonly summary: "One choice from a short list of options, each a native radio button with a label and an optional line of description. Registers one select tool enumerating the options.";
+    readonly whenToUse: "Use when the options need explaining: a role with what it can do, a plan with what it includes, a delivery speed with its cost. Options hold data: { value, label, description?, disabled? }. The group is a fieldset whose legend is the label, so it submits under one name inside a form.";
+    readonly whenNotToUse: "Do not use for two to four short labels that need no description; that is a SegmentedControl. Do not use for a long list; that is a Select. Do not use for choosing several; that is a set of Checkboxes. Descriptions are plain strings, not components.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "The question the options answer, such as \"Role\". Rendered as the legend and used to derive the tool name.";
+            readonly required: true;
+        };
+        readonly options: {
+            readonly kind: "array";
+            readonly description: "The options in order: { value, label, description?, disabled? }. label is what a person reads and what the select tool accepts. description is a sentence under the label, linked to its radio with aria-describedby and carried into the agent view as part state.";
+            readonly required: true;
+        };
+        readonly value: {
+            readonly kind: "string";
+            readonly description: "The selected option's value, or an empty string for none. Fully controlled.";
+            readonly required: true;
+        };
+        readonly onChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the value a person or an agent selects.";
+            readonly required: true;
+        };
+        readonly hint: {
+            readonly kind: "string";
+            readonly description: "Guidance under the group. Replaced by error while one is set.";
+        };
+        readonly error: {
+            readonly kind: "string";
+            readonly description: "A validation message that marks the group invalid.";
+        };
+        readonly name: {
+            readonly kind: "string";
+            readonly description: "The native form name the selected value submits under.";
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Disable every option and unregister the select tool.";
+            readonly default: false;
+        };
+        readonly required: {
+            readonly kind: "boolean";
+            readonly description: "Mark the group as needing an answer.";
+            readonly default: false;
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the group without registering the select tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly value: {
+            readonly description: "The selected option's label.";
+            readonly attribute: "data-sprint-value";
+        };
+        readonly empty: {
+            readonly description: "Present while nothing is selected.";
+            readonly attribute: "data-sprint-empty";
+        };
+        readonly disabled: {
+            readonly description: "Present when the group cannot be changed.";
+            readonly attribute: "data-sprint-disabled";
+        };
+        readonly required: {
+            readonly description: "Present when an answer is needed.";
+            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: "- **RadioGroup** \"Role\" [value=Viewer] → tool `select-role`\n  - part `option` \"Viewer\" [checked, description=Sees the board]\n  - part `option` \"Editor\" [description=Changes callings]";
+    };
+    readonly examples: readonly [{
+        readonly title: "Options that need explaining";
+        readonly description: "Each role says what it allows. The descriptions reach screen readers through aria-describedby and agents through part state.";
+        readonly code: "<RadioGroup\n  label=\"Role\"\n  value={role}\n  onChange={setRole}\n  options={[\n    { value: \"viewer\", label: \"Viewer\", description: \"Sees the board and the agenda.\" },\n    { value: \"editor\", label: \"Editor\", description: \"Moves people between callings.\" },\n    { value: \"admin\", label: \"Admin\", description: \"Also invites and removes people.\" },\n  ]}\n/>";
+    }, {
+        readonly title: "A required choice with an unavailable option";
+        readonly code: "<RadioGroup\n  label=\"Delivery\"\n  required\n  value={delivery}\n  onChange={setDelivery}\n  error={delivery === \"\" ? \"Choose how to send the invite.\" : undefined}\n  options={[\n    { value: \"email\", label: \"Email\" },\n    { value: \"text\", label: \"Text message\", disabled: true, description: \"No phone number on file.\" },\n  ]}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "radiogroup";
+        readonly keyboard: readonly ["Arrow keys move between options and select", "Tab enters and leaves the group"];
+        readonly notes: "A fieldset of native radio inputs sharing one name, so the browser supplies arrow-key movement and form submission. The legend names the group; a description is linked to its own radio.";
+    };
+};
+
+export declare interface RadioGroupProps extends Omit<ComponentPropsWithRef<"fieldset">, "onChange"> {
+    label: string;
+    options: readonly RadioOption[];
+    value: string;
+    onChange: (value: string) => void;
+    hint?: string | undefined;
+    error?: string | undefined;
+    name?: string;
+    disabled?: boolean;
+    required?: boolean;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
+export declare interface RadioOption {
+    value: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
 }
 
 export declare function reactText(node: ReactNode): string | undefined;
@@ -2836,7 +3613,7 @@ export declare const segmentedControlMeta: {
         };
         readonly options: {
             readonly kind: "array";
-            readonly description: "The choices in display order: { value, label, count? }. The label is what a person sees and what the select tool accepts, so an agent never has to know the value. count renders as a muted chip beside the label and reaches the agent view as part state, so never fold a count into the label.";
+            readonly description: "The choices in display order: { value, label, count?, disabled? }. The label is what a person sees and what the select tool accepts, so an agent never has to know the value. count renders as a muted chip beside the label and reaches the agent view as part state, so never fold a count into the label. disabled keeps one option visible but unselectable: it is skipped by the arrow keys, left out of the tool's enum, and marked disabled in the agent view.";
             readonly required: true;
         };
         readonly value: {
@@ -2921,10 +3698,14 @@ export declare const segmentedControlMeta: {
         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 title: "One option unavailable";
+        readonly description: "A disabled option stays in place so the set of choices reads the same, but nobody can pick it: arrow keys skip it and the select tool does not offer it.";
+        readonly code: "<SegmentedControl\n  label=\"Interview\"\n  value={status}\n  onChange={setStatus}\n  options={[\n    { value: \"pending\", label: \"Pending\" },\n    { value: \"accepted\", label: \"Accepted\", disabled: !interviewed },\n    { value: \"declined\", label: \"Declined\", disabled: !interviewed },\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 keyboard: readonly ["Arrow keys move to the next or previous enabled option and select it", "Home selects the first enabled option", "End selects the last enabled 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. An option with a count is named by its label and its count together; the hint is linked to the group with aria-describedby.";
     };
 };
@@ -2946,12 +3727,17 @@ export declare interface SegmentedOption {
     value: string;
     label: string;
     count?: number;
+    disabled?: boolean;
 }
 
 export declare function Select(props: SelectProps): JSX.Element;
 
 export declare const SELECT_OPTION_TOOL: AgentToolSpec;
 
+export declare const SELECT_RADIO_TOOL: AgentToolSpec;
+
+export declare const SELECT_TAB_TOOL: AgentToolSpec;
+
 export declare const SELECT_TOOL: AgentToolSpec;
 
 export declare const selectMeta: {
@@ -2959,7 +3745,7 @@ export declare const selectMeta: {
     readonly category: "input";
     readonly summary: "A dropdown of mutually exclusive options: a select-only combobox that opens a listbox on click or keyboard, 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 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 a list long enough to need searching, grouping or custom option rendering; that is a Combobox. 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: {
@@ -3169,6 +3955,14 @@ export declare const shellMeta: {
             readonly kind: "handler";
             readonly description: "Called with the collapsed state the Shell wants. Use it to remember the choice across visits.";
         };
+        readonly drawerOpen: {
+            readonly kind: "boolean";
+            readonly description: "Whether the narrow-viewport drawer is open, when the owner keeps that state: a guided tour that steps into the sidebar, or a page that closes the drawer after an action. Pair it with onDrawerOpenChange.";
+        };
+        readonly onDrawerOpenChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the drawer state the Shell wants: true from the menu toggle, false from the close toggle or a link followed inside the drawer.";
+        };
         readonly hideLabel: {
             readonly kind: "string";
             readonly description: "Label of the wide-viewport toggle while the sidebar is shown.";
@@ -3202,6 +3996,10 @@ export declare const shellMeta: {
         readonly title: "A sidebar that can be hidden";
         readonly description: "With collapsible, a person can put the sidebar away on a wide screen as well as a narrow one, and get the full width for the page.";
         readonly code: "<Shell\n  collapsible\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  <Text>Quarterly numbers land here.</Text>\n</Shell>";
+    }, {
+        readonly title: "A drawer the page controls";
+        readonly description: "drawerOpen and onDrawerOpenChange hand the phone drawer to the page, so a guided tour can open it to point at a link and close it again.";
+        readonly code: "<Shell\n  drawerOpen={drawerOpen}\n  onDrawerOpenChange={setDrawerOpen}\n  bar={<Link href=\"#/\">ACME</Link>}\n  side={\n    <Nav label=\"Main\">\n      <Link href=\"#/reports\" active>Reports</Link>\n    </Nav>\n  }\n>\n  <Button onClick={() => setDrawerOpen(true)}>Show me the menu</Button>\n</Shell>";
     }];
 };
 
@@ -3216,31 +4014,99 @@ export declare interface ShellProps extends ComponentPropsWithRef<"div"> {
     collapsed?: boolean;
     defaultCollapsed?: boolean;
     onCollapsedChange?: (collapsed: boolean) => void;
+    drawerOpen?: boolean;
+    onDrawerOpenChange?: (open: boolean) => void;
     hideLabel?: string;
     showLabel?: string;
 }
 
-export declare function slug(value: string): string;
-
-export declare type SprintAgentControls = "always" | "never";
-
-export declare function SprintProvider(props: SprintProviderProps): JSX.Element;
+export declare function showFloating(element: HTMLElement): void;
 
-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 function slug(value: string): string;
 
-export declare type SprintTheme = "dark" | "light" | "calorie" | "calorie-dark" | "trax" | "trax-dark" | "ambient" | "ambient-dark";
+export declare function Spinner(props: SpinnerProps): JSX.Element;
 
-export declare type SprintView = "human" | "agent";
+export declare const spinnerMeta: {
+    readonly name: "Spinner";
+    readonly category: "feedback";
+    readonly summary: "A small inline busy mark for work with no measurable progress, sized to sit inside a field or beside a line of text.";
+    readonly whenToUse: "Use where a whole bar or region would be too much: beside a field that is checking a value, at the end of a line that is saving, inside a combobox while results load. The label says what is happening and is announced politely; showLabel prints it beside the mark.";
+    readonly whenNotToUse: "Do not use for a region whose data is loading; that is Pending or a component's loading prop. Do not use when the work can be counted; that is Progress. Do not use for a busy button; Button's loading prop marks the button itself.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What is happening, such as \"Checking availability\".";
+            readonly required: true;
+        };
+        readonly size: {
+            readonly kind: "enum";
+            readonly description: "medium matches body text; small fits inside a dense row or a field.";
+            readonly values: readonly ["small", "medium"];
+            readonly default: "medium";
+        };
+        readonly showLabel: {
+            readonly kind: "boolean";
+            readonly description: "Print the label beside the mark instead of keeping it for assistive technology only.";
+            readonly default: false;
+        };
+    };
+    readonly state: {
+        readonly loading: {
+            readonly description: "Always present: a spinner is only rendered while work is running.";
+            readonly attribute: "data-sprint-loading";
+        };
+        readonly size: {
+            readonly description: "Present as small on the compact mark.";
+            readonly attribute: "data-sprint-size";
+            readonly values: readonly ["small"];
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Spinner** \"Saving note\" [loading]";
+    };
+    readonly examples: readonly [{
+        readonly title: "Saving beside a line";
+        readonly description: "The mark sits in the line, and the label is printed beside it.";
+        readonly code: "<Spinner label=\"Saving note\" showLabel />";
+    }, {
+        readonly title: "A silent mark in a field";
+        readonly description: "A small mark with the label kept for assistive technology and agents.";
+        readonly code: "<Spinner label=\"Searching members\" size=\"small\" />";
+    }];
+    readonly a11y: {
+        readonly role: "status";
+        readonly notes: "A role=status element, so the label is announced politely when the spinner appears. Render it only while work runs, rather than toggling its visibility. The mark is a stepped four-cell pulse, still under reduced motion.";
+    };
+};
+
+export declare interface SpinnerProps extends Omit<ComponentPropsWithRef<"span">, "children"> {
+    label: string;
+    size?: SpinnerSize;
+    showLabel?: boolean;
+}
+
+export declare type SpinnerSize = "small" | "medium";
+
+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" | "calorie" | "calorie-dark" | "trax" | "trax-dark" | "ambient" | "ambient-dark";
+
+export declare type SprintView = "human" | "agent";
 
 export declare interface SprintViewValue {
     view: SprintView;
@@ -3258,7 +4124,7 @@ export declare type StackAlign = "start" | "center" | "end" | "stretch" | "basel
 
 export declare type StackDirection = "row" | "column" | "grid";
 
-export declare type StackGap = "none" | "tight" | "normal" | "loose";
+export declare type StackGap = "none" | "hairline" | "snug" | "tight" | "medium" | "normal" | "loose" | "wide" | "vast";
 
 export declare type StackJustify = "start" | "center" | "end" | "between";
 
@@ -3283,10 +4149,16 @@ export declare const stackMeta: {
         };
         readonly gap: {
             readonly kind: "enum";
-            readonly description: "Space between items, from the space scale.";
-            readonly values: readonly ["none", "tight", "normal", "loose"];
+            readonly description: "Space between items, from the space scale: none, hairline, snug, tight, medium, normal, loose, wide, vast, smallest to largest.";
+            readonly values: readonly ["none", "hairline", "snug", "tight", "medium", "normal", "loose", "wide", "vast"];
             readonly default: "normal";
         };
+        readonly padding: {
+            readonly kind: "enum";
+            readonly description: "Space inside the stack's edges, on the same scale as gap. Use it for a stack that is itself a bordered or filled region; between siblings, prefer the parent's gap.";
+            readonly values: readonly ["none", "hairline", "snug", "tight", "medium", "normal", "loose", "wide", "vast"];
+            readonly default: "none";
+        };
         readonly align: {
             readonly kind: "enum";
             readonly description: "Cross-axis alignment.";
@@ -3323,7 +4195,12 @@ export declare const stackMeta: {
         readonly gap: {
             readonly description: "The spacing step in use.";
             readonly attribute: "data-sprint-gap";
-            readonly values: readonly ["none", "tight", "normal", "loose"];
+            readonly values: readonly ["none", "hairline", "snug", "tight", "medium", "normal", "loose", "wide", "vast"];
+        };
+        readonly padding: {
+            readonly description: "The inner spacing step, when there is one.";
+            readonly attribute: "data-sprint-padding";
+            readonly values: readonly ["hairline", "snug", "tight", "medium", "normal", "loose", "wide", "vast"];
         };
         readonly align: {
             readonly description: "Cross-axis alignment, when one was asked for.";
@@ -3359,6 +4236,10 @@ export declare const stackMeta: {
     }, {
         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>";
+    }, {
+        readonly title: "A padded, dense list";
+        readonly description: "padding insets the stack's own content, and a small gap packs rows closely, without a wrapper element or a class.";
+        readonly code: "<Stack gap=\"snug\" padding=\"medium\">\n  <Text>Opening hymn</Text>\n  <Text>Invocation</Text>\n  <Text>Sacrament hymn</Text>\n</Stack>";
     }];
 };
 
@@ -3367,6 +4248,7 @@ export declare type StackMin = (typeof STACK_MINS)[number];
 export declare interface StackProps extends ComponentPropsWithRef<"div"> {
     direction?: StackDirection;
     gap?: StackGap;
+    padding?: StackGap;
     align?: StackAlign;
     justify?: StackJustify;
     wrap?: boolean;
@@ -3551,6 +4433,14 @@ export declare interface SwitchProps extends Omit<ComponentPropsWithRef<"button"
     agentTool?: boolean;
 }
 
+export declare interface TabItem {
+    value: string;
+    label: string;
+    panel: ReactNode;
+    count?: number;
+    disabled?: boolean;
+}
+
 export declare function Table(props: TableProps): JSX.Element;
 
 export declare const TABLE_WIDTHS: readonly ["4rem", "5rem", "6rem", "7rem", "8rem", "9rem", "10rem", "12rem", "14rem", "16rem", "20rem", "24rem"];
@@ -3674,6 +4564,91 @@ export declare interface TableRow {
 
 export declare type TableWidth = (typeof TABLE_WIDTHS)[number];
 
+export declare function Tabs(props: TabsProps): JSX.Element;
+
+export declare const tabsMeta: {
+    readonly name: "Tabs";
+    readonly category: "navigation";
+    readonly summary: "Sibling views of one subject, one shown at a time, with real tablist, tab and tabpanel semantics. Registers one select tool enumerating the tabs.";
+    readonly whenToUse: "Use to switch between a few views of the same thing without leaving the page: coming up, past and by member for one set of speakers; details and history for one record. Tabs hold data: each is { value, label, panel, count?, disabled? }, and only the selected tab's panel is mounted. An optional actions slot sits at the end of the tab row.";
+    readonly whenNotToUse: "Do not use to pick a value that filters or changes something else on the page; that is a SegmentedControl, a radio group. Do not use for navigation between pages with their own URLs; that is a Nav. Do not use when a person needs to compare the views side by side.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "What the tabs switch between, such as \"Speakers\". Names the tablist and derives the select tool name.";
+            readonly required: true;
+        };
+        readonly tabs: {
+            readonly kind: "array";
+            readonly description: "The tabs in order: { value, label, panel, count?, disabled? }. panel is the content shown while the tab is selected and may hold any components. count renders as a chip beside the label and reaches the agent view as part state.";
+            readonly required: true;
+        };
+        readonly value: {
+            readonly kind: "string";
+            readonly description: "The selected tab's value, when the page owns that state. Pair it with onChange. A disabled or unknown value falls back to the first enabled tab.";
+        };
+        readonly defaultValue: {
+            readonly kind: "string";
+            readonly description: "The tab selected first when the Tabs keep their own state.";
+        };
+        readonly onChange: {
+            readonly kind: "handler";
+            readonly description: "Called with the value of the tab a person or an agent selects.";
+        };
+        readonly actions: {
+            readonly kind: "node";
+            readonly description: "Controls at the end of the tab row, such as an add Button that applies to every tab.";
+        };
+        readonly agentName: {
+            readonly kind: "string";
+            readonly description: "Override the label used to derive the tool name.";
+        };
+        readonly agentTool: {
+            readonly kind: "boolean";
+            readonly description: "Set false to render the tabs without registering the select tool.";
+            readonly default: true;
+        };
+    };
+    readonly state: {
+        readonly value: {
+            readonly description: "The selected tab's label.";
+            readonly attribute: "data-sprint-value";
+        };
+    };
+    readonly tools: {
+        readonly select: AgentToolSpec;
+    };
+    readonly agentView: {
+        readonly example: "- **Tabs** \"Speakers\" [value=Coming up] → tool `select-speakers`\n  - part `tab` \"Coming up\" [count=4, selected]\n  - part `tab` \"Past\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "Views of one subject";
+        readonly description: "Only the selected panel is on the page. An agent switches with the select tool or the tab controls in the agent view, then reads the new panel.";
+        readonly code: "<Tabs\n  label=\"Speakers\"\n  tabs={[\n    { value: \"upcoming\", label: \"Coming up\", count: 4, panel: <UpcomingSpeakers /> },\n    { value: \"past\", label: \"Past\", panel: <PastSpeakers /> },\n    { value: \"member\", label: \"By member\", panel: <SpeakersByMember /> },\n  ]}\n/>";
+    }, {
+        readonly title: "Tabs with an action";
+        readonly description: "actions sits at the end of the tab row and stays put while the panels change. A disabled tab is visible but cannot be selected.";
+        readonly code: "<Tabs\n  label=\"Record\"\n  value={view}\n  onChange={setView}\n  actions={<Button size=\"small\">Export</Button>}\n  tabs={[\n    { value: \"details\", label: \"Details\", panel: <Details /> },\n    { value: \"history\", label: \"History\", panel: <History /> },\n    { value: \"audit\", label: \"Audit\", disabled: true, panel: null },\n  ]}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "tablist";
+        readonly keyboard: readonly ["Left and Right Arrow move to the previous or next enabled tab and show it", "Home and End show the first and last enabled tab", "Tab moves from the selected tab into its panel"];
+        readonly notes: "Roving tabindex across the tabs, with selection following focus. The panel is a focusable tabpanel labelled by its tab. A count chip is hidden from assistive technology, so the tab is named by its label alone.";
+    };
+};
+
+export declare interface TabsProps extends Omit<ComponentPropsWithRef<"div">, "onChange"> {
+    label: string;
+    tabs: readonly TabItem[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    actions?: ReactNode;
+    agentName?: string;
+    agentTool?: boolean;
+}
+
 export declare function Tag(props: TagProps): JSX.Element;
 
 export declare const tagMeta: {
@@ -3700,6 +4675,11 @@ export declare const tagMeta: {
             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 provisional: {
+            readonly kind: "boolean";
+            readonly description: "Draw a dashed keyline for something that is not real yet: a draft, a scenario, a proposed change. It reads as provisional to agents too.";
+            readonly default: false;
+        };
     };
     readonly state: {
         readonly tone: {
@@ -3711,11 +4691,19 @@ export declare const tagMeta: {
             readonly description: "Present when the chip is a solid field rather than a keyline.";
             readonly attribute: "data-sprint-filled";
         };
+        readonly provisional: {
+            readonly description: "Present on a chip for something that is not real yet.";
+            readonly attribute: "data-sprint-provisional";
+        };
     };
     readonly agentView: {
         readonly example: "- **Tag** \"experimental\" [filled, tone=warning]";
     };
     readonly examples: readonly [{
+        readonly title: "A provisional chip";
+        readonly description: "A dashed keyline separates a scenario from the live roster without spending a colour.";
+        readonly code: "<Tag tone=\"info\" provisional>Scenario: fall reshuffle</Tag>";
+    }, {
         readonly title: "A release status";
         readonly code: "<Tag tone=\"warning\" filled>experimental</Tag>";
     }, {
@@ -3731,6 +4719,7 @@ export declare const tagMeta: {
 export declare interface TagProps extends ComponentPropsWithRef<"span"> {
     tone?: TagTone;
     filled?: boolean;
+    provisional?: boolean;
 }
 
 export declare type TagTone = "neutral" | "action" | "danger" | "info" | "warning" | "inert";
@@ -3738,8 +4727,12 @@ export declare type TagTone = "neutral" | "action" | "danger" | "info" | "warnin
 declare function Text_2(props: TextProps): JSX.Element;
 export { Text_2 as Text }
 
+declare type TextAlign = "start" | "center" | "end";
+
 export declare function Textarea(props: TextareaProps): JSX.Element;
 
+declare type TextareaFieldProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "id" | "rows" | "value" | "defaultValue" | "onChange" | "placeholder" | "name" | "disabled" | "required" | "aria-invalid" | "aria-describedby">;
+
 export declare const textareaMeta: {
     readonly name: "Textarea";
     readonly category: "input";
@@ -3765,9 +4758,14 @@ export declare const textareaMeta: {
         };
         readonly rows: {
             readonly kind: "number";
-            readonly description: "The visible line count before scrolling.";
+            readonly description: "The visible line count before scrolling. With autoGrow it is the minimum height.";
             readonly default: 4;
         };
+        readonly autoGrow: {
+            readonly kind: "boolean";
+            readonly description: "Grow the area with its content instead of scrolling, never shorter than rows.";
+            readonly default: false;
+        };
         readonly placeholder: {
             readonly kind: "string";
             readonly description: "Ghost text shown while the area is empty.";
@@ -3794,6 +4792,19 @@ export declare const textareaMeta: {
             readonly description: "Mark the area required, visually and in the agent view.";
             readonly default: false;
         };
+        readonly hideLabel: {
+            readonly kind: "boolean";
+            readonly description: "Hide the label visually while keeping it as the field's accessible name and agent label. Pair it with a placeholder or a nearby heading so sighted people still know what the field is for.";
+            readonly default: false;
+        };
+        readonly inputRef: {
+            readonly kind: "object";
+            readonly description: "A ref to the underlying <textarea>, for focusing or measuring it. The component's own ref points at the wrapper.";
+        };
+        readonly inputProps: {
+            readonly kind: "object";
+            readonly description: "Extra native attributes and handlers for the <textarea> itself, such as autoFocus, maxLength, inputMode, onKeyDown, or onBlur. Props spread on the component land on the wrapper; these land on the area. Anything the component manages (value, onChange, disabled, the error wiring) cannot be overridden here.";
+        };
         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.";
@@ -3840,6 +4851,10 @@ export declare const textareaMeta: {
         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 title: "An area that grows";
+        readonly description: "autoGrow drops the scrollbar: the area starts at rows lines and grows with what is typed. The label is hidden because a heading above already names it, and inputProps puts a length cap and a key handler on the textarea itself.";
+        readonly code: "<Textarea\n  label=\"Log entry\"\n  hideLabel\n  autoGrow\n  rows={2}\n  value={entry}\n  onChange={setEntry}\n  placeholder=\"What happened on this pass\"\n  inputProps={{ maxLength: 500, onKeyDown: submitOnModEnter }}\n/>";
     }];
     readonly a11y: {
         readonly role: "textbox";
@@ -3859,12 +4874,18 @@ export declare interface TextareaProps extends Omit<ComponentPropsWithRef<"div">
     name?: string;
     disabled?: boolean;
     required?: boolean;
+    autoGrow?: boolean;
+    hideLabel?: boolean;
+    inputRef?: Ref<HTMLTextAreaElement>;
+    inputProps?: TextareaFieldProps;
     agentName?: string;
     agentTool?: boolean;
 }
 
 export declare function TextInput(props: TextInputProps): JSX.Element;
 
+declare type TextInputFieldProps = Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "type" | "value" | "defaultValue" | "onChange" | "placeholder" | "name" | "autoComplete" | "disabled" | "readOnly" | "required" | "aria-invalid" | "aria-describedby">;
+
 export declare const textInputMeta: {
     readonly name: "TextInput";
     readonly category: "input";
@@ -3890,8 +4911,8 @@ export declare const textInputMeta: {
         };
         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 description: "The input type. \"password\" masks the field everywhere: the value never appears in agent attributes, the agent view, or tool results. \"number\" keeps value a string, so the page parses it; pass min, max and step through inputProps.";
+            readonly values: readonly ["text", "email", "url", "search", "password", "number", "tel"];
             readonly default: "text";
         };
         readonly placeholder: {
@@ -3929,6 +4950,27 @@ export declare const textInputMeta: {
             readonly description: "Mark the field required, visually and in the agent view.";
             readonly default: false;
         };
+        readonly hideLabel: {
+            readonly kind: "boolean";
+            readonly description: "Hide the label visually while keeping it as the field's accessible name and agent label. Pair it with a placeholder or a nearby heading so sighted people still know what the field is for.";
+            readonly default: false;
+        };
+        readonly icon: {
+            readonly kind: "node";
+            readonly description: "A decorative icon drawn inside the start of the field, such as a magnifier on a search box. Hidden from assistive technology.";
+        };
+        readonly trailing: {
+            readonly kind: "node";
+            readonly description: "Controls drawn inside the end of the field, such as a clear Button with hideLabel and size=\"small\". It renders only in the human view; give an agent the same action some other way, or rely on the fill tool, which can set the field to empty.";
+        };
+        readonly inputRef: {
+            readonly kind: "object";
+            readonly description: "A ref to the underlying <input>, for focusing or measuring it. The component's own ref points at the wrapper.";
+        };
+        readonly inputProps: {
+            readonly kind: "object";
+            readonly description: "Extra native attributes and handlers for the <input> itself, such as autoFocus, maxLength, inputMode, onKeyDown, or onBlur. Props spread on the component land on the wrapper; these land on the field. Anything the component manages (value, onChange, disabled, the error wiring) cannot be overridden here.";
+        };
         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.";
@@ -3991,6 +5033,14 @@ export declare const textInputMeta: {
         readonly title: "A read-only value";
         readonly description: "A value shown in the shape of a form field that nobody may edit. It stays focusable and selectable, reads as text in the agent view, and registers no fill tool. To hand someone a value to paste elsewhere, a CopyField adds the copy control.";
         readonly code: "<TextInput\n  label=\"Station ID\"\n  value=\"KX-2209-ALPHA\"\n  onChange={() => {}}\n  readOnly\n  hint=\"Assigned at registration\"\n/>";
+    }, {
+        readonly title: "A number with field attributes";
+        readonly description: "type=\"number\" keeps value a string. Native attributes for the input itself, such as min, max and autoFocus, go through inputProps, and inputRef reaches the input for focusing it later.";
+        readonly code: "<TextInput\n  label=\"Link expiry in days\"\n  type=\"number\"\n  value={days}\n  onChange={setDays}\n  inputRef={daysField}\n  inputProps={{ min: 1, max: 90, step: 1 }}\n/>";
+    }, {
+        readonly title: "A search field with a clear control";
+        readonly description: "The icon sits inside the start of the field and a small icon-only Button clears it from the end. An agent clears it by filling an empty string.";
+        readonly code: "<TextInput\n  label=\"Filter the board\"\n  hideLabel\n  placeholder=\"Filter by name or calling\"\n  icon={<SearchIcon />}\n  value={query}\n  onChange={setQuery}\n  trailing={\n    query === \"\" ? null : (\n      <Button size=\"small\" icon={<CloseIcon />} hideLabel onClick={() => setQuery(\"\")}>\n        Clear filter\n      </Button>\n    )\n  }\n/>";
     }];
     readonly a11y: {
         readonly role: "textbox";
@@ -4012,11 +5062,18 @@ export declare interface TextInputProps extends Omit<ComponentPropsWithRef<"div"
     disabled?: boolean;
     readOnly?: boolean;
     required?: boolean;
+    hideLabel?: boolean;
+    icon?: ReactNode;
+    trailing?: ReactNode;
+    inputRef?: Ref<HTMLInputElement>;
+    inputProps?: TextInputFieldProps;
     agentName?: string;
     agentTool?: boolean;
 }
 
-export declare type TextInputType = "text" | "email" | "url" | "search" | "password";
+export declare type TextInputType = "text" | "email" | "url" | "search" | "password" | "number" | "tel";
+
+declare type TextLines = 1 | 2 | 3 | 4 | 5 | 6;
 
 export declare const textMeta: {
     readonly name: "Text";
@@ -4043,6 +5100,27 @@ export declare const textMeta: {
             readonly values: readonly ["small", "normal"];
             readonly default: "normal";
         };
+        readonly weight: {
+            readonly kind: "enum";
+            readonly description: "bold for a line that needs to stand out among its neighbours, such as a name in a list row. Prefer a Heading for a title.";
+            readonly values: readonly ["normal", "bold"];
+            readonly default: "normal";
+        };
+        readonly align: {
+            readonly kind: "enum";
+            readonly description: "Horizontal alignment, in the writing direction.";
+            readonly values: readonly ["start", "center", "end"];
+            readonly default: "start";
+        };
+        readonly lines: {
+            readonly kind: "number";
+            readonly description: "Clamp the text to this many lines, 1 to 6, ending in an ellipsis. Only the screen is clamped: assistive technology and the agent view still get the whole text. Pair it with a Tooltip when a sighted person needs the rest.";
+        };
+        readonly italic: {
+            readonly kind: "boolean";
+            readonly description: "Set in italic, for a quotation, a title of a work, or a scripture reference.";
+            readonly default: false;
+        };
         readonly as: {
             readonly kind: "enum";
             readonly description: "The element to render. Use span when the text sits inside another line of text.";
@@ -4061,6 +5139,24 @@ export declare const textMeta: {
             readonly attribute: "data-sprint-size";
             readonly values: readonly ["small", "normal"];
         };
+        readonly weight: {
+            readonly description: "Present as bold on emphasised text.";
+            readonly attribute: "data-sprint-weight";
+            readonly values: readonly ["bold"];
+        };
+        readonly align: {
+            readonly description: "The alignment, when it is not start.";
+            readonly attribute: "data-sprint-align";
+            readonly values: readonly ["center", "end"];
+        };
+        readonly lines: {
+            readonly description: "The line clamp, when one is set. The text itself is never shortened.";
+            readonly attribute: "data-sprint-lines";
+        };
+        readonly italic: {
+            readonly description: "Present on italic text.";
+            readonly attribute: "data-sprint-italic";
+        };
     };
     readonly agentView: {
         readonly example: "- **Text** \"Tools stay registered across a view switch.\" [tone=muted]";
@@ -4076,12 +5172,23 @@ export declare const textMeta: {
         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>";
+    }, {
+        readonly title: "A clamped line";
+        readonly description: "lines clamps the screen to two lines with an ellipsis. The agent view and screen readers still get every word.";
+        readonly code: "<Text lines={2}>{member.notes}</Text>";
+    }, {
+        readonly title: "Emphasis and alignment";
+        readonly code: "<Text weight=\"bold\" align=\"center\" italic>Come, follow me.</Text>";
     }];
 };
 
 export declare interface TextProps extends Omit<ComponentPropsWithRef<"p">, "ref"> {
     tone?: TextTone;
     size?: TextSize;
+    weight?: TextWeight;
+    align?: TextAlign;
+    lines?: TextLines;
+    italic?: boolean;
     as?: "p" | "span" | "div";
     ref?: Ref<HTMLParagraphElement> | Ref<HTMLSpanElement> | Ref<HTMLDivElement>;
 }
@@ -4090,8 +5197,104 @@ export declare type TextSize = "small" | "normal";
 
 export declare type TextTone = "default" | "muted" | "action" | "info" | "warning" | "danger";
 
+declare type TextWeight = "normal" | "bold";
+
 export declare const THEME_ATTRIBUTE = "data-sprint-theme";
 
+export declare function Toast(props: ToastProps): JSX.Element | null;
+
+export declare interface ToastAction {
+    label: string;
+    onSelect: () => void;
+    shortcut?: string;
+}
+
+export declare const toastMeta: {
+    readonly name: "Toast";
+    readonly category: "feedback";
+    readonly summary: "A brief message that floats at the bottom of the screen after something happened, with an optional single action such as Undo, and dismisses itself.";
+    readonly whenToUse: "Use to confirm an action that already took effect and can still be reversed or followed up: a person moved, a note saved, a share link copied. Render one Toast with open, message and onDismiss; the page owns which toast is showing. The action is data, { label, onSelect, shortcut? }, rendered as a Button that registers its own press tool, and the shortcut is shown as key caps.";
+    readonly whenNotToUse: "Do not use for an error the person must act on, or anything that must stay visible; that is an Alert in the page. Do not use for a decision; that is a Dialog. Do not show several at once: replace the message instead. Inside an open modal Dialog, render the Toast inside the Dialog, because the page behind it is inert.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly open: {
+            readonly kind: "boolean";
+            readonly description: "Whether the toast is showing. A closed toast renders nothing.";
+            readonly required: true;
+        };
+        readonly message: {
+            readonly kind: "string";
+            readonly description: "What happened, in a sentence, such as \"Moved Sister Amaral to Primary.\"";
+            readonly required: true;
+        };
+        readonly onDismiss: {
+            readonly kind: "handler";
+            readonly description: "Called when the toast should go: after duration, or when the dismiss control is pressed. Set open to false in response.";
+            readonly required: true;
+        };
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "A short title above the message, and the toast's accessible name.";
+        };
+        readonly tone: {
+            readonly kind: "enum";
+            readonly description: "neutral and info announce politely; warning too. danger announces assertively, but prefer an Alert for errors.";
+            readonly values: readonly ["neutral", "info", "warning", "danger"];
+            readonly default: "neutral";
+        };
+        readonly action: {
+            readonly kind: "object";
+            readonly description: "One follow-up action: { label, onSelect, shortcut? }. It is a Button with its own press tool, named from the label. shortcut is shown as key caps and published as aria-keyshortcuts; the page binds the key itself.";
+        };
+        readonly duration: {
+            readonly kind: "number";
+            readonly description: "Milliseconds before onDismiss is called. The timer pauses while the pointer or focus is on the toast. Pass null to keep it until dismissed.";
+            readonly default: 6000;
+        };
+        readonly dismissLabel: {
+            readonly kind: "string";
+            readonly description: "Accessible name of the dismiss control.";
+            readonly default: "Dismiss";
+        };
+    };
+    readonly state: {
+        readonly tone: {
+            readonly description: "The toast's tone.";
+            readonly attribute: "data-sprint-tone";
+            readonly values: readonly ["neutral", "info", "warning", "danger"];
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **Toast** [tone=neutral]\n  - part `message` \"Moved Sister Amaral to Primary.\"\n  - part `dismiss` \"Dismiss\"\n  - **Button** \"Undo\" [size=small, tone=action]";
+    };
+    readonly examples: readonly [{
+        readonly title: "An undo toast";
+        readonly description: "The action is a real Button, so an agent can press Undo through its tool while the toast is up.";
+        readonly code: "<Toast\n  open={moved !== null}\n  message={movedMessage}\n  action={{ label: \"Undo\", onSelect: undo, shortcut: \"Ctrl+Z\" }}\n  onDismiss={() => setMoved(null)}\n/>";
+    }, {
+        readonly title: "A toast that stays";
+        readonly description: "duration={null} keeps it until dismissed.";
+        readonly code: "<Toast\n  open={offline}\n  label=\"Offline\"\n  tone=\"warning\"\n  duration={null}\n  message=\"Changes are saved on this device until the connection returns.\"\n  onDismiss={() => setOffline(false)}\n/>";
+    }];
+    readonly a11y: {
+        readonly role: "status";
+        readonly notes: "A role=status region, or role=alert for danger, so the message is announced when the toast appears. Render it when the event happens rather than toggling visibility. It opens as a popover in the top layer, at the bottom edge on a phone and the bottom corner on a wide screen. The timer pauses while the pointer or keyboard focus is on it, so nobody loses the action mid-reach.";
+    };
+};
+
+export declare interface ToastProps extends Omit<ComponentPropsWithRef<"div">, "children"> {
+    open: boolean;
+    message: string;
+    onDismiss: () => void;
+    label?: string;
+    tone?: ToastTone;
+    action?: ToastAction;
+    duration?: number | null;
+    dismissLabel?: string;
+}
+
+export declare type ToastTone = "neutral" | "info" | "warning" | "danger";
+
 export declare interface Token {
     kind: TokenKind;
     text: string;
@@ -4130,6 +5333,69 @@ export declare interface ToolExecuteContext {
 
 export declare function toolName(scope: readonly string[], verb: string, label: string): string | null;
 
+export declare function Tooltip(props: TooltipProps): JSX.Element;
+
+export declare const TOOLTIP_ATTRIBUTE = "data-sprint-tooltip";
+
+export declare const tooltipMeta: {
+    readonly name: "Tooltip";
+    readonly category: "overlay";
+    readonly summary: "A short hint that appears beside one control on hover or keyboard focus. A human affordance only: it adds nothing to the agent view.";
+    readonly whenToUse: "Use to name an icon-only control for sighted mouse users, or to show the whole of a line that is truncated on screen. Wrap exactly one focusable element. The hint appears after a short hover or at once on keyboard focus, and Escape dismisses it.";
+    readonly whenNotToUse: "Never put information only in a tooltip: touch users never see it and agents never read it, so the text must repeat something the wrapped element already says through its label or its own content. Do not use it for anything interactive; that is a Menu or a Dialog. For an icon-only Button, pass hideLabel instead, which adds the tooltip itself.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly label: {
+            readonly kind: "string";
+            readonly description: "The hint text. Keep it to a few words.";
+            readonly required: true;
+        };
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "Exactly one focusable element, such as a Button or a link. The tooltip is anchored to it and, unless describe is false, linked to it with aria-describedby.";
+            readonly required: true;
+        };
+        readonly side: {
+            readonly kind: "enum";
+            readonly description: "Where the hint prefers to appear. It flips to the other side when there is no room.";
+            readonly values: readonly ["above", "below"];
+            readonly default: "above";
+        };
+        readonly describe: {
+            readonly kind: "boolean";
+            readonly description: "Link the hint to the element with aria-describedby. Set false when the hint repeats the element's accessible name, so a screen reader does not read it twice.";
+            readonly default: true;
+        };
+        readonly disabled: {
+            readonly kind: "boolean";
+            readonly description: "Stop the hint from appearing.";
+            readonly default: false;
+        };
+    };
+    readonly examples: readonly [{
+        readonly title: "Naming a truncated line";
+        readonly description: "The line is cut short on screen, so the tooltip shows it whole. The element's own text already carries the full value for assistive technology and agents.";
+        readonly code: "<Tooltip label=\"Elder Kestrel, second counselor in the elders quorum presidency\">\n  <Link href=\"/callings/42\">Elder Kestrel, second counselor…</Link>\n</Tooltip>";
+    }, {
+        readonly title: "A hint below its control";
+        readonly description: "side moves the hint below the control; it still flips when the control sits at the bottom of the screen.";
+        readonly code: "<Tooltip label=\"Opens in the planner\" side=\"below\">\n  <Button>Plan Sunday</Button>\n</Tooltip>";
+    }];
+    readonly a11y: {
+        readonly role: "tooltip";
+        readonly keyboard: readonly ["Focus shows the hint", "Escape hides it"];
+        readonly notes: "The hint is a role=tooltip element linked to the wrapped element with aria-describedby. It appears after a hover delay or immediately on keyboard focus, never on touch, and is dismissed by Escape, blur, or moving the pointer away. It is a popover in the top layer, rendered inside the wrapped element's DOM, so it shows above a modal Dialog.";
+    };
+};
+
+export declare interface TooltipProps extends Omit<ComponentPropsWithRef<"span">, "children"> {
+    label: string;
+    children: ReactElement;
+    side?: FloatingSide;
+    describe?: boolean;
+    disabled?: boolean;
+}
+
 export declare const TURN_PAGE_TOOL: AgentToolSpec;
 
 export declare function useAgentControls(): SprintAgentControls;
@@ -4149,6 +5415,19 @@ export declare interface UseAgentToolOptions {
     execute: (inputs: Record<string, unknown>, context: ToolExecuteContext) => Promise<string | null> | string | null;
 }
 
+export declare function useFloating(options: UseFloatingOptions): void;
+
+export declare interface UseFloatingOptions {
+    open: boolean;
+    anchor: RefObject<HTMLElement | null>;
+    floating: RefObject<HTMLElement | null>;
+    side?: FloatingSide;
+    align?: FloatingAlign;
+    matchWidth?: boolean;
+    boundary?: RefObject<HTMLElement | null>;
+    onDismiss?: () => void;
+}
+
 export declare function useSprintView(): SprintView;
 
 export declare function useSprintViewControl(): SprintViewValue;
@@ -4161,4 +5440,52 @@ export declare const VIEW_ATTRIBUTE = "data-sprint-view";
 
 export declare const VIEW_COPY_ATTRIBUTE = "data-sprint-view-copy";
 
+export declare function VisuallyHidden(props: VisuallyHiddenProps): JSX.Element;
+
+export declare const visuallyHiddenMeta: {
+    readonly name: "VisuallyHidden";
+    readonly category: "typography";
+    readonly summary: "Text that is off screen but still read by screen readers and agents. For context a sighted person gets from the layout.";
+    readonly whenToUse: "Use to say in words what the layout says visually: \"(opens in a new tab)\" after a link, a count's unit, a heading for a region whose purpose is obvious on screen. With focusable, it wraps a skip link that appears only while it has focus.";
+    readonly whenNotToUse: "Do not use to hide a field's label; TextInput, Textarea, SearchField and Progress take hideLabel, and an icon-only Button takes hideLabel too. Do not hide content that a sighted person also needs.";
+    readonly status: "experimental";
+    readonly props: {
+        readonly children: {
+            readonly kind: "node";
+            readonly description: "The hidden text, or a skip link when focusable is set.";
+            readonly required: true;
+        };
+        readonly focusable: {
+            readonly kind: "boolean";
+            readonly description: "Show the content while something inside it has keyboard focus, for a skip link.";
+            readonly default: false;
+        };
+    };
+    readonly state: {
+        readonly focusable: {
+            readonly description: "Present when the content appears while focused.";
+            readonly attribute: "data-sprint-focusable";
+        };
+    };
+    readonly agentView: {
+        readonly example: "- **VisuallyHidden** \"opens in a new tab\"";
+    };
+    readonly examples: readonly [{
+        readonly title: "Extra words for a screen reader";
+        readonly description: "The arrow says it to a sighted person; the hidden text says it to everyone else.";
+        readonly code: "<Link href=\"https://churchofjesuschrist.org\" external>\n  Gospel Library ↗<VisuallyHidden> (opens in a new tab)</VisuallyHidden>\n</Link>";
+    }, {
+        readonly title: "A skip link";
+        readonly description: "Off screen until a keyboard user tabs to it.";
+        readonly code: "<VisuallyHidden focusable>\n  <Link href=\"#main\">Skip to the board</Link>\n</VisuallyHidden>";
+    }];
+    readonly a11y: {
+        readonly notes: "Hidden with a one-pixel clip rather than display or visibility, so screen readers still read it. The agent view renders its text as an ordinary line.";
+    };
+};
+
+export declare interface VisuallyHiddenProps extends ComponentPropsWithRef<"span"> {
+    focusable?: boolean;
+}
+
 export { }