@cssints/headless 0.0.0-stage → 0.5.0

package/dist/index.d.mts

@@ -0,0 +1,3068 @@
+import { Accessor } from "solid-js";
+//#region src/canvas-math.d.ts
+/**
+ * The fixed-point math of the canvas, copied from the Quint specs. Integers only, power-of-two
+ * denominators, every intermediate below 2^53, so doubles are exact and the DOM implementation can
+ * be compared with the generated model bit for bit.
+ *
+ *   zoom   z  = zoom * ZONE          (ZMIN 1/16 .. ZMAX 8)
+ *   camera t  = world units * TONE   (sub-unit offsets keep zoom smooth)
+ *   screen = (world + t) * zoom      (world-offset form)
+ *   every division is round half up (`rdiv`); `fdiv` is floor.
+ */
+export declare const ZONE = 4096;
+export declare const TONE = 256;
+export declare const ZMIN = 256;
+export declare const ZMAX = 32768;
+/** Viewport origin bound, world units. */
+export declare const WORLD_BOUND = 1000000;
+/** Screen px a press must travel before it becomes a gesture (squared distance > DRAG_PX^2). */
+export declare const DRAG_PX = 4;
+/** Screen px within which a dragged node snaps to the grid. */
+export declare const SNAP_PX = 8;
+/** The default snap candidates: every GRID world units (`gridCandidates`). */
+export declare const GRID = 50;
+/** Ticks of a tween; the last one lands exactly on the target. */
+export declare const TWEEN_TICKS = 4;
+type MarqueeMode = "contain" | "overlap";
+type SnapAxis = "x" | "y";
+/** The dragged node a snap policy is asked about: its id and its size, whole world units. */
+interface SnapNode {
+  readonly id: string;
+  readonly width: number;
+  readonly height: number;
+}
+/**
+ * What the host's snap policy is asked: `value` is the origin (left / top edge) of `id` on `axis`
+ * while it is dragged, `width` / `height` its size. Edge alignment is `target - width` (right) or
+ * `target - height` (bottom). One object, so a field can be added without breaking a policy.
+ */
+interface SnapContext extends SnapNode {
+  readonly axis: SnapAxis;
+  readonly value: number;
+}
+/**
+ * The host's snap policy: candidate origins on one axis for the dragged node described by the
+ * context. WHOLE world units (never 1/256 fixed point); a fractional candidate is ignored. The
+ * primitive keeps the mechanism (nearest candidate, the 8 screen px threshold, the guides).
+ */
+type SnapCandidates = (context: SnapContext) => readonly number[];
+/** The default policy and the one `specs/canvas/pointer.qnt` models: every `GRID` units. */
+export declare const gridCandidates: SnapCandidates;
+//#endregion
+//#region src/prefs.d.ts
+/**
+ * The user preferences a primitive honours. The host resolves them from
+ * wherever it keeps them and injects a `Partial<Prefs>` per primitive;
+ * `@cssints/headless` never imports atproto or a lexicon. An absent pref falls back
+ * to today's behaviour, so injection is additive.
+ *
+ * `motionDurationMs` has no consumer here: canvas tweens are tick-driven, not
+ * millisecond-driven, and the look layer owns durations (ADR 0002). It is part
+ * of the shape so a host's resolved prefs can be passed in unchanged.
+ */
+export interface Prefs {
+  readonly motion: "reduce" | "full";
+  readonly motionDurationMs: number;
+  readonly typeaheadDelayMs: number;
+  readonly tooltipShowDelayMs: number;
+  readonly tooltipHideDelayMs: number;
+  readonly announce: boolean;
+  readonly focusFollowsCamera: boolean;
+}
+/** Today's behaviour, used for every pref the host does not inject. */
+export declare const DEFAULT_PREFS: Prefs;
+/** Merge an injected partial with the defaults; never mutates the input. */
+export declare const withPrefs: (partial?: Partial<Prefs>) => Prefs;
+//#endregion
+//#region src/canvas.d.ts
+/**
+ * Headless infinite canvas: camera, selection and node-move state plus attribute / prop objects
+ * for a viewport, a camera layer, the nodes and a live region. No elements, no styling beyond the
+ * geometry the layout needs (positions, sizes, the camera transform, `content-visibility`).
+ * Behaviour is checked against `specs/canvas/{camera,pointer}.qnt` by the scenario bridge
+ * (`packages/apg-specs/src/canvas/canvas.bridge.ts`), not by running the generated machines here.
+ *
+ * ## What this module owns
+ * Conventions that mirror the specs exactly (so the bridge can compare bit for bit): integer
+ * fixed point, zoom `value * 4096`, translation `world units * 256`, `screen = (world + t) * z`,
+ * round half up, top-left-anchored resize, the viewport origin bounded to +-1e6 units, a clamp
+ * re-anchors the zoom, a 4 px SCREEN drag threshold, an 8 px SCREEN snap threshold on a 50-unit
+ * grid, reduced motion jumps to the same end state a tween reaches. Pointer positions are rounded
+ * to whole CSS px.
+ *
+ * Accessibility (effects-of-atmosphere-h9vk): every node is a real focusable element (`role`,
+ * `aria-roledescription`, `aria-label`, `tabindex=0`; never `role=application`); `nodeIds()` is the
+ * DOM order = the spatial order (rows by y, then x, then the paint order: the input order until
+ * `setOrder`) so Tab and the screen
+ * reader follow what is on screen; selected / focused / editing nodes are never culled
+ * (`content-visibility: visible`), the rest are `auto` with `contain-intrinsic-size`; focusing a
+ * node that is not fully in view pans it to the centre (no animation under reduced motion); a live
+ * region announces settled selections and keyboard moves; arrows move the focused node
+ * (`keyboardStep`, times `keyboardShiftMultiplier` with Shift) - the no-mouse path.
+ *
+ * ## What the adapter / host owns (NOT implemented here)
+ * - wheel / pinch normalisation: turn a gesture into `panBy` / `zoomBy` / `zoomTo` calls;
+ * - easing and durations: `requestFrame` drives the 4 linear ticks (default `requestAnimationFrame`);
+ * - fit-to-bounds: compute a goal and call `animateTo`;
+ * - the snap candidate policy (`snapCandidates`; a 50-unit grid by default) and hollow / rotated
+ *   shape hit rules (a node is its box);
+ * - node geometry, z-order and membership when they come from elsewhere (an auto-layout, a node
+ *   that grows to its text): push them with `setGeometry` / `setOrder` / `addNodes` /
+ *   `removeNodes`. Membership is not in `pointer.qnt` (its node set is fixed at three): it is
+ *   tested here, on the real DOM, not replayed against the model;
+ * - viewport measuring (call `resize` from a ResizeObserver), the reduced-motion preference (call
+ *   `setReducedMotion` from `matchMedia`), the visually-hidden style of the live region, edges.
+ *
+ * ## Divergences from the specs that are deliberate
+ * Keyboard (arrows, Enter, F2, Escape), focus auto-pan and the announcement text are not in the
+ * specs; they are tested directly. `role=group` does not list `aria-selected` in ARIA 1.2: pass
+ * `role: 'option' | 'treeitem' | 'gridcell'` per node when that matters, otherwise the live region
+ * carries the selection.
+ *
+ * ponytail: a node's label and role are fixed while its id exists (change them by removing and
+ * re-adding it after a flush); the row tie-break is the exact y; no window-blur reset of Shift / Space.
+ */
+type CanvasMode = "idle" | "pointing" | "panning" | "marquee" | "dragging";
+/** Roles that fit a focusable, nameable box; `option` / `treeitem` / `gridcell` accept `aria-selected`. */
+type CanvasNodeRole = "group" | "article" | "figure" | "listitem" | "option" | "treeitem" | "gridcell";
+interface CanvasNodeInput {
+  readonly id: string;
+  /** World units, whole numbers. */
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+  readonly label: string;
+  /** Default `group`. */
+  readonly role?: CanvasNodeRole;
+  /** Default `canvas node`. */
+  readonly roleDescription?: string;
+}
+/**
+ * A host-side change of one node (`Canvas.setGeometry`); omitted fields keep their value. World
+ * units; a fractional value rounds half up. A `CanvasNodeInput` is a valid patch.
+ */
+interface CanvasNodeGeometry {
+  readonly id: string;
+  readonly x?: number;
+  readonly y?: number;
+  readonly width?: number;
+  readonly height?: number;
+}
+interface CanvasMove {
+  readonly id: string;
+  readonly x: number;
+  readonly y: number;
+}
+interface CanvasMessages {
+  readonly selection: (labels: readonly string[]) => string;
+  readonly moved: (label: string, direction: "left" | "right" | "up" | "down", x: number, y: number) => string;
+}
+/** A camera goal: zoom to `zoom` (fixed point) about a screen point, or centre a world point. */
+type CanvasGoal = {
+  readonly kind: "zoom";
+  readonly zoom: number;
+  readonly anchor: readonly [x: number, y: number];
+} | {
+  readonly kind: "centre";
+  readonly x: number;
+  readonly y: number;
+};
+interface CanvasOptions {
+  /** The initial nodes, bottom of the z-order first. `addNodes` / `removeNodes` change the set later. */
+  readonly nodes: readonly CanvasNodeInput[];
+  /** Base for the generated DOM ids. */
+  readonly id?: string;
+  /** Accessible name of the viewport region. */
+  readonly label?: string;
+  /** Initial viewport size, screen px (default 800 x 600). */
+  readonly viewport?: {
+    readonly width: number;
+    readonly height: number;
+  };
+  readonly marquee?: MarqueeMode;
+  readonly snap?: boolean;
+  /**
+   * The snap policy while `snap` is on: candidate positions per axis for a dragged node's origin,
+   * WHOLE world units (a fractional one is ignored). Called on every pointer move of a drag, so it
+   * may read live host state. The context carries the dragged node's `id`, `width` and `height`,
+   * so edge alignment is `target - width`. With several nodes selected the pressed one is asked.
+   * Default `gridCandidates` (every 50 units, what `pointer.qnt` models).
+   */
+  readonly snapCandidates?: SnapCandidates;
+  readonly reducedMotion?: boolean;
+  /**
+   * Structural mirror of `ing.lexicon.ui.prefs` (`./prefs`). The host resolves
+   * the record and injects; honoured here: `motion`, `announce`,
+   * `focusFollowsCamera`. Absent prefs keep today's behaviour.
+   */
+  readonly prefs?: Partial<Prefs> | undefined;
+  /** World units per arrow key press (default 10). */
+  readonly keyboardStep?: number;
+  /** Shift multiplies the step (default 5, so Shift + arrow = one grid cell). */
+  readonly keyboardShiftMultiplier?: number;
+  /** Drives the tween ticks; default `requestAnimationFrame` when it exists. */
+  readonly requestFrame?: (callback: () => void) => void;
+  readonly messages?: CanvasMessages;
+  /** The settled selection (after a gesture or a key press), never mid-gesture. */
+  readonly onSelectionChange?: (ids: readonly string[]) => void;
+  /**
+   * Committed node positions (pointer up or a key press), changed nodes only. A host's own
+   * `setGeometry` echoes here too, with the position AFTER the world-bound clamp.
+   */
+  readonly onNodesMove?: (moves: readonly CanvasMove[]) => void;
+}
+interface CanvasSnapshot {
+  readonly viewport: {
+    readonly width: number;
+    readonly height: number;
+  };
+  /** Fixed point: `tx`, `ty` in world units * 256, `z` = zoom * 4096. */
+  readonly camera: {
+    readonly tx: number;
+    readonly ty: number;
+    readonly z: number;
+  };
+  readonly tweening: boolean;
+  readonly reducedMotion: boolean;
+  readonly mode: CanvasMode;
+  /** Pointer id holding the capture, or `null`. */
+  readonly owner: number | null;
+  readonly selection: readonly string[];
+  readonly cursor: string | null;
+  readonly editing: string | null;
+  readonly guides: {
+    readonly x: boolean;
+    readonly y: boolean;
+  };
+  readonly culled: readonly string[];
+  readonly announcements: number;
+  readonly announcement: string;
+}
+/**
+ * `overflow: clip`, not `hidden`: a `hidden` box is still a scroll container, and focusing a node
+ * that is off screen makes the browser scroll it natively (measured: scrollLeft/Top jump to the
+ * node) while the camera has not moved yet, which breaks every pointer coordinate. `clip` never
+ * scrolls.
+ */
+interface CanvasViewportStyle {
+  readonly position: "relative";
+  readonly overflow: "clip";
+  readonly "touch-action": "none";
+}
+/** Spread onto the labelled region that clips the canvas. */
+interface CanvasViewportProps {
+  readonly ref: (element: HTMLElement) => void;
+  readonly role: "region";
+  readonly "aria-label": string;
+  /** Focusable by click only, so Shift / Space keep reaching the canvas after a click on empty space. */
+  readonly tabindex: number;
+  readonly style: CanvasViewportStyle;
+  readonly onPointerDown: (event: PointerEvent) => void;
+  readonly onPointerMove: (event: PointerEvent) => void;
+  readonly onPointerUp: (event: PointerEvent) => void;
+  readonly onPointerCancel: (event: PointerEvent) => void;
+  readonly onLostPointerCapture: (event: PointerEvent) => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onKeyUp: (event: KeyboardEvent) => void;
+}
+/**
+ * Spread onto the single element that holds the nodes. The camera is one CSS transform
+ * (`scale(zoom) translate(t)`) driven by custom properties, so it is observable exactly.
+ * `style` is a getter returning a fresh object: Solid spreads read it inside the tracking scope.
+ */
+interface CanvasLayerProps {
+  readonly style: Readonly<Record<string, string>>;
+}
+interface CanvasNodeProps {
+  readonly id: string;
+  readonly role: CanvasNodeRole;
+  readonly "aria-roledescription": string;
+  readonly "aria-label": string;
+  readonly "aria-selected": "true" | "false";
+  readonly tabindex: number;
+  readonly style: Readonly<Record<string, string>>;
+  readonly onFocus: () => void;
+  readonly onFocusOut: (event: FocusEvent) => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+interface CanvasLiveRegionProps {
+  readonly role: "status";
+  readonly "aria-live": "polite";
+  readonly "aria-atomic": "true";
+}
+interface PointerInput {
+  /** `PointerEvent.pointerId`. */
+  readonly id: number;
+  /** Position relative to the viewport, screen px. */
+  readonly x: number;
+  readonly y: number;
+}
+interface Canvas {
+  /** Reactive snapshot of everything observable. */
+  readonly state: Accessor<CanvasSnapshot>;
+  /** Synchronous truth (Solid 2 applies signal writes on the microtask flush). */
+  readonly peek: () => CanvasSnapshot;
+  /** Node ids in DOM order: rows by y, then x, then input order. */
+  readonly nodeIds: Accessor<readonly string[]>;
+  readonly isSelected: (id: string) => boolean;
+  /** The spec's cull predicate (off screen and not selected / focused / editing). */
+  readonly isCulled: (id: string) => boolean;
+  /** Live position (whole units): the committed one plus the drag delta of a dragged node. */
+  readonly position: (id: string) => {
+    readonly x: number;
+    readonly y: number;
+  };
+  readonly viewportProps: CanvasViewportProps;
+  readonly layerProps: CanvasLayerProps;
+  readonly nodeProps: (id: string) => CanvasNodeProps;
+  readonly liveRegionProps: CanvasLiveRegionProps;
+  /** Pointer entry points (the viewport props call these; adapters may too). */
+  readonly pointerDown: (input: PointerInput) => void;
+  readonly pointerMove: (input: PointerInput) => void;
+  readonly pointerUp: (id: number) => void;
+  readonly pointerCancel: (id: number) => void;
+  /** Modifiers and parameters are sampled at pointerdown: ignored while a gesture runs. */
+  readonly setShift: (held: boolean) => void;
+  readonly setSpace: (held: boolean) => void;
+  readonly setMarqueeMode: (mode: MarqueeMode) => void;
+  readonly setSnap: (on: boolean) => void;
+  /** Host resize: the top-left stays fixed. */
+  readonly resize: (width: number, height: number) => void;
+  /** Turning it on settles a running tween on its target. */
+  readonly setReducedMotion: (reduced: boolean) => void;
+  /** Pan by a screen delta; cancels a tween. */
+  readonly panBy: (dx: number, dy: number) => void;
+  /** Zoom by `factor` (fixed point, 4096 = x1) about a screen point (default: the last pointer). */
+  readonly zoomBy: (factor: number, anchor?: readonly [number, number]) => void;
+  /** Zoom to `zoom` (fixed point), clamped and re-anchored. */
+  readonly zoomTo: (zoom: number, anchor?: readonly [number, number]) => void;
+  readonly animateTo: (goal: CanvasGoal) => void;
+  /** One animation frame of a running tween. */
+  readonly tick: () => void;
+  readonly cancelTween: () => void;
+  /** Enter / leave editing of the single selected node (idle only). */
+  readonly toggleEdit: () => void;
+  /**
+   * Host-controlled geometry (an auto-layout, a node that grew to its text): set the position
+   * and / or size of the named nodes, in any mode. Positions are clamped into the world bound
+   * (with the new size), a running drag or marquee is re-derived, the DOM order follows (focus is
+   * kept) and `onNodesMove` reports the nodes that moved. Throws on an unknown id or a non-finite
+   * number, before anything changes.
+   */
+  readonly setGeometry: (patches: readonly CanvasNodeGeometry[]) => void;
+  /**
+   * Host-controlled paint order: `ids` is EVERY node id exactly once, bottom of the z-order first
+   * (the `nodes` option's convention). Decides `z-index`, the topmost hit and the DOM order's
+   * tie-break. Throws if `ids` is not a permutation of the node ids.
+   */
+  readonly setOrder: (ids: readonly string[]) => void;
+  /**
+   * Host-controlled membership: insert nodes on top of the z-order, in input order (call
+   * `setOrder` to place them elsewhere). Positions are clamped into the world bound and an
+   * inserted node whose position was clamped is reported through `onNodesMove`. Existing nodes keep
+   * their position, selection, cursor and focus; a running marquee is re-derived. Throws on an id
+   * that exists already or repeats, or a non-finite number, before anything changes.
+   */
+  readonly addNodes: (nodes: readonly CanvasNodeInput[]) => void;
+  /**
+   * Remove nodes. They leave the selection (a settled selection that lost a member is announced
+   * and reported through `onSelectionChange`) and clear the cursor / editing when they held it;
+   * removing the node a pointer gesture started on cancels that gesture. Survivors keep their DOM
+   * ids and focus; the z-order closes up. Throws on an unknown or repeated id before anything
+   * changes.
+   */
+  readonly removeNodes: (ids: readonly string[]) => void;
+}
+export declare const createCanvas: (options: CanvasOptions) => Canvas;
+//#endregion
+//#region src/disclosure.d.ts
+/**
+ * Options are read lazily: pass a component's `props` (or an object with
+ * getters), never destructured values, so `disabled` stays reactive.
+ */
+interface DisclosureOptions {
+  /** Controlled: the host owns the state and this is the only thing that changes it. */
+  readonly value?: boolean | undefined;
+  /** Uncontrolled starting state; ignored while `value` is set. */
+  readonly defaultValue?: boolean;
+  readonly disabled?: boolean;
+  /** Base for the generated trigger/panel ids. */
+  readonly id?: string;
+  /**
+   * A request to change the state, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (expanded: boolean) => void;
+}
+/** Spread onto the element with `role=button` (a native `<button>`). */
+interface DisclosureTriggerProps {
+  readonly id: string;
+  readonly type: "button";
+  readonly "aria-expanded": "true" | "false";
+  readonly "aria-controls": string;
+  readonly disabled: boolean;
+  readonly onClick: () => void;
+}
+/** Spread onto the element holding the content that is shown or hidden. */
+interface DisclosurePanelProps {
+  readonly id: string;
+  readonly hidden: boolean;
+}
+interface Disclosure {
+  readonly expanded: Accessor<boolean>;
+  /** Requests; `expand`, `collapse` and `toggle` are requests too. */
+  readonly setExpanded: (expanded: boolean) => void;
+  readonly expand: () => void;
+  readonly collapse: () => void;
+  readonly toggle: () => void;
+  /** Getter-backed, so spreading it keeps every attribute reactive. */
+  readonly triggerProps: DisclosureTriggerProps;
+  readonly panelProps: DisclosurePanelProps;
+}
+/**
+ * APG Disclosure (https://www.w3.org/WAI/ARIA/apg/patterns/disclosure/):
+ * state plus attribute objects for a trigger and a panel. No styling, no
+ * elements. Behaviour is checked against `specs/apg/disclosure.qnt` by the
+ * scenario bridge, not by running the generated machine here.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the state.
+ */
+export declare const createDisclosure: (options?: DisclosureOptions) => Disclosure;
+//#endregion
+//#region src/player.d.ts
+/**
+ * A playback engine the primitive drives. Mediabunny is one; the primitive
+ * never imports a media library (`@cssints/headless` stays `solid-js`-only).
+ * Event names mirror `HTMLMediaElement`; the primitive mirrors the generated
+ * `specs/apg/player.qnt` machine.
+ */
+type PlaybackAdapterEvent = {
+  readonly type: "loadedmetadata";
+  readonly duration: number;
+} | {
+  readonly type: "canplay" | "playing" | "pause" | "waiting" | "seeking" | "seeked" | "ended";
+} | {
+  readonly type: "timeupdate";
+  readonly currentTime: number;
+} | {
+  readonly type: "ratechange";
+  readonly rate: number;
+} | {
+  readonly type: "error";
+  readonly cause: unknown;
+};
+interface PlaybackAdapter {
+  /** Open + decode; emits `loadedmetadata` once the duration is known. */
+  load(src: string): Promise<void>;
+  play(): Promise<void>;
+  pause(): void;
+  seek(seconds: number): Promise<void>;
+  /** 0..1, already muted-resolved by the primitive. */
+  setVolume(gain: number): void;
+  setPlaybackRate(rate: number): void;
+  dispose(): void;
+  subscribe(listener: (event: PlaybackAdapterEvent) => void): () => void;
+}
+type PlayerStage = "loading" | "ready" | "playing" | "paused" | "buffering" | "ended" | "error";
+interface PlayerOptions {
+  readonly adapter: PlaybackAdapter;
+  readonly src?: string;
+  /**
+   * The four preferences below follow the request/commit model (map ticket
+   * `rt1p`): `<name>` + `on<Name>Change` to own one as a host, `default<Name>`
+   * to start an uncontrolled one. A change callback is a request the host may
+   * ignore. Transport (play / pause / seek) and the stage stay adapter-driven.
+   */
+  /** 0..100; slider value, applied as a squared gain. */
+  readonly volume?: number | undefined;
+  readonly defaultVolume?: number;
+  readonly onVolumeChange?: (volume: number) => void;
+  readonly muted?: boolean | undefined;
+  readonly defaultMuted?: boolean;
+  readonly onMutedChange?: (muted: boolean) => void;
+  /** Percent: 50 | 100 | 150 | 200. */
+  readonly rate?: number | undefined;
+  readonly defaultRate?: number;
+  readonly onRateChange?: (percent: number) => void;
+  readonly fullscreen?: boolean | undefined;
+  readonly defaultFullscreen?: boolean;
+  readonly onFullscreenChange?: (fullscreen: boolean) => void;
+  readonly onPlay?: () => void;
+  readonly onPause?: () => void;
+  readonly onSeek?: (seconds: number) => void;
+  readonly onEnded?: () => void;
+}
+interface PlayerSurfaceProps {
+  readonly tabindex: number;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+interface PlayerButtonProps {
+  readonly type: "button";
+  readonly onClick: () => void;
+  /** Keep a pointer click from stealing focus, so the spec's `focus` scope holds. */
+  readonly onMouseDown: (event: MouseEvent) => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+interface PlayerPlayProps extends PlayerButtonProps {
+  readonly "aria-label": "Play" | "Pause";
+}
+interface PlayerToggleProps extends PlayerButtonProps {
+  readonly "aria-pressed": "true" | "false";
+}
+interface PlayerSeekProps {
+  readonly role: "slider";
+  readonly tabindex: number;
+  readonly "aria-valuemin": number;
+  readonly "aria-valuenow": number;
+  readonly "aria-valuemax": number;
+  readonly "aria-valuetext": string;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+interface Player {
+  readonly stage: () => PlayerStage;
+  readonly position: () => number;
+  readonly duration: () => number;
+  readonly muted: () => boolean;
+  readonly volume: () => number;
+  readonly rate: () => number;
+  readonly fullscreen: () => boolean;
+  readonly focus: () => "none" | "surface" | "seek" | "control";
+  readonly play: () => void;
+  readonly pause: () => void;
+  readonly togglePlay: () => void;
+  readonly seek: (seconds: number) => void;
+  readonly setVolume: (value: number) => void;
+  readonly toggleMute: () => void;
+  readonly setRate: (percent: number) => void;
+  readonly toggleFullscreen: () => void;
+  readonly surfaceProps: PlayerSurfaceProps;
+  readonly playProps: PlayerPlayProps;
+  readonly seekProps: PlayerSeekProps;
+  readonly muteProps: PlayerToggleProps;
+  readonly fullscreenProps: PlayerToggleProps;
+}
+/**
+ * APG media player primitive on Solid 2: playback state + attribute objects.
+ * The playback contract follows `specs/apg/player.qnt` (APG Slider seek +
+ * HTMLMediaElement playback); the adapter is injected, so no media library and
+ * no elements live here.
+ */
+export declare const createPlayer: (options: PlayerOptions) => Player;
+//#endregion
+//#region src/accordion.d.ts
+/**
+ * Options are read lazily (getters) so `multiple` / `disabled` stay reactive;
+ * pass a component's `props`, never destructured values.
+ */
+export interface AccordionOptions {
+  /** Number of panels (the docs' fixed three unless a page renders fewer). */
+  readonly items?: number;
+  /** Controlled: the host owns the expanded set and this is the only thing that changes it. */
+  readonly value?: ReadonlyArray<number> | undefined;
+  /** Uncontrolled starting expanded set; ignored while `value` is set. */
+  readonly defaultValue?: ReadonlyArray<number>;
+  /** Allow more than one panel expanded at once. */
+  readonly multiple?: boolean;
+  /** Allow the last expanded panel to collapse (default true). */
+  readonly collapsible?: boolean;
+  /** `aria-level` of the heading wrapping each trigger (default 3). */
+  readonly headingLevel?: number;
+  /** Disable every trigger. */
+  readonly disabled?: boolean;
+  /** Disable specific triggers by index. */
+  readonly disabledItems?: ReadonlyArray<number>;
+  /** Base for the generated ids. */
+  readonly id?: string;
+  /**
+   * A request to change the expanded set, called when the intent differs from
+   * the current value. Uncontrolled it is accepted; controlled the host may
+   * ignore it.
+   */
+  readonly onValueChange?: (expanded: ReadonlyArray<number>) => void;
+}
+/** Spread onto the element with `role=button` (a native `<button>`). */
+export interface AccordionTriggerProps {
+  readonly id: string;
+  readonly type: "button";
+  readonly "aria-expanded": "true" | "false";
+  readonly "aria-controls": string;
+  readonly "aria-disabled": "true" | undefined;
+  readonly disabled: boolean;
+  readonly onClick: () => void;
+}
+/** Spread onto the element with `role=region` holding the panel. */
+export interface AccordionPanelProps {
+  readonly id: string;
+  readonly role: "region";
+  readonly "aria-labelledby": string;
+  readonly tabindex: 0;
+  readonly hidden: boolean;
+}
+/** Spread onto the heading element wrapping a trigger. */
+export interface AccordionHeadingProps {
+  readonly id: string;
+  readonly role: "heading";
+  readonly "aria-level": number;
+}
+export interface Accordion {
+  readonly items: number;
+  readonly expanded: Accessor<ReadonlyArray<boolean>>;
+  readonly isExpanded: (index: number) => boolean;
+  /** Requests a toggle of one panel; refused panels leave state untouched. */
+  readonly toggle: (index: number) => void;
+  readonly setMultiple: (value: boolean) => void;
+  readonly setCollapsible: (value: boolean) => void;
+  readonly setHeadingLevel: (level: number) => void;
+  /** Getter-backed, so spreading keeps every attribute reactive. */
+  readonly triggerProps: (index: number) => AccordionTriggerProps;
+  readonly panelProps: (index: number) => AccordionPanelProps;
+  readonly headingProps: (index: number) => AccordionHeadingProps;
+}
+/**
+ * APG Accordion (https://www.w3.org/WAI/ARIA/apg/patterns/accordion/): state
+ * plus prop objects for headings, triggers and panels. No styling, no elements.
+ * Behaviour is checked against `specs/apg/accordion.qnt` by the scenario bridge,
+ * not by running the generated machine here.
+ *
+ * Platform: **native** (`<details name>` / `:open`, Baseline newly) — this
+ * primitive only wires the markup and ARIA; exclusivity is the platform's.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the expanded set. A controlled host
+ * owns the set verbatim, so `setMultiple` / `setCollapsible` only re-normalize
+ * while uncontrolled.
+ */
+export declare const createAccordion: (options?: AccordionOptions) => Accordion;
+//#endregion
+//#region src/alert.d.ts
+export interface AlertOptions {
+  /** Rendered at mount; `undefined` starts with no live region. */
+  readonly message?: string | undefined;
+  /** The user closed the alert; the host may unmount it. */
+  readonly onDismiss?: () => void;
+}
+/** Spread onto the `role=alert` live region. */
+export interface AlertProps {
+  readonly role: "alert" | undefined;
+  readonly "aria-atomic": "true" | undefined;
+  readonly hidden: boolean;
+}
+export interface AlertDismissProps {
+  readonly "aria-label": "Close";
+  readonly onClick: () => void;
+}
+export interface Alert {
+  readonly mounted: Accessor<boolean>;
+  readonly message: Accessor<string | undefined>;
+  /** Render or replace the message: a fresh message is announced after load. */
+  readonly show: (message: string) => void;
+  readonly dismiss: () => void;
+  readonly alertProps: AlertProps;
+  readonly dismissProps: AlertDismissProps;
+}
+/**
+ * APG Alert (https://www.w3.org/WAI/ARIA/apg/patterns/alert/): a brief message
+ * in a `role=alert` live region. Platform: native live-region markup
+ * (`ariaNotify` for imperative announcements). The machine only decides when the
+ * region is live; the primitive keeps the region mounted and unhides it.
+ */
+export declare const createAlert: (options?: AlertOptions) => Alert;
+//#endregion
+//#region src/alertdialog.d.ts
+export interface AlertDialogOptions {
+  /** Controlled: the host owns the open state and this is the only thing that changes it. */
+  readonly value?: boolean | undefined;
+  /** Uncontrolled starting state; ignored while `value` is set. */
+  readonly defaultOpen?: boolean;
+  /** Starting textarea revision (0 = empty). */
+  readonly defaultNotes?: number;
+  readonly id?: string;
+  /** A request to change the open state, called when the intent differs. */
+  readonly onOpenChange?: (open: boolean) => void;
+}
+export interface AlertDialogTriggerProps {
+  readonly id: string;
+  readonly "aria-haspopup": "dialog";
+  readonly "aria-expanded": "true" | "false";
+  readonly "aria-controls": string;
+  readonly "aria-disabled": "true" | undefined;
+  readonly onClick: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface AlertDialogDialogProps {
+  readonly id: string;
+  readonly role: "alertdialog";
+  readonly "aria-modal": "true" | undefined;
+  readonly "aria-labelledby": string;
+  readonly "aria-describedby": string;
+  readonly tabindex: -1;
+  readonly hidden: boolean;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface AlertDialogButtonProps {
+  readonly id: string;
+  readonly type: "button";
+  readonly "aria-disabled": "true" | undefined;
+  readonly onClick: () => void;
+}
+export interface AlertDialogBackdropProps {
+  readonly id: string;
+  readonly hidden: boolean;
+  readonly onClick: () => void;
+}
+export interface AlertDialog {
+  readonly open: Accessor<boolean>;
+  /** Encoded focus target: `layer * 100 + position` (0 = none). */
+  readonly focus: Accessor<number>;
+  /** The part currently holding focus, in scenario vocabulary. */
+  readonly focusPart: Accessor<string | null>;
+  readonly notes: Accessor<number>;
+  readonly stored: Accessor<number>;
+  readonly focusAt: (target: number) => void;
+  readonly activate: () => void;
+  readonly escape: () => void;
+  /**
+   * Call before the host writes the controlled `value` directly, so a close
+   * that is not the pending confirmation does not discard the notes.
+   */
+  readonly prepareHostWrite: () => void;
+  readonly tab: () => void;
+  readonly shiftTab: () => void;
+  readonly typeText: () => void;
+  readonly clearText: () => void;
+  readonly ctrlS: () => void;
+  readonly pointerOutside: () => void;
+  readonly triggerProps: AlertDialogTriggerProps;
+  readonly dialogProps: AlertDialogDialogProps;
+  readonly backdropProps: AlertDialogBackdropProps;
+  readonly cancelProps: AlertDialogButtonProps;
+  readonly confirmProps: AlertDialogButtonProps;
+  readonly saveProps: AlertDialogButtonProps;
+  readonly inputProps: {
+    readonly id: string;
+    readonly "aria-label": string;
+    readonly onFocus: () => void;
+  };
+}
+declare const NO_POS = 1;
+declare const YES_POS = 2;
+/**
+ * APG Alert Dialog on Solid 2: a Discard trigger, a notes textarea with Save,
+ * and an alertdialog with No / Yes. Mirrors `specs/apg/alertdialog.qnt` —
+ * `USE_ARIA_DISABLED` is on, so the emptied Discard stays focusable.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultOpen`);
+ * pass `value` + `onOpenChange` to own the open state. `activate` / `escape` are
+ * requests; the focus, return target and notes changes follow the committed
+ * open state through an effect, so a rejected request leaves them untouched.
+ */
+export declare const createAlertDialog: (options?: AlertDialogOptions) => AlertDialog;
+//#endregion
+//#region src/breadcrumb.d.ts
+export interface BreadcrumbItem {
+  readonly label: string;
+  readonly href?: string | undefined;
+}
+export interface BreadcrumbOptions {
+  readonly items: ReadonlyArray<BreadcrumbItem>;
+  /** 1-based index of the current page; defaults to the last item. */
+  readonly currentIndex?: number;
+  readonly disabled?: boolean;
+  /** The navigation landmark label; defaults to "Breadcrumbs". */
+  readonly label?: string | undefined;
+  readonly labelledby?: string | undefined;
+  readonly describedby?: string | undefined;
+  readonly onPress?: (index: number) => void;
+}
+export interface BreadcrumbNavProps {
+  readonly "aria-label": string | undefined;
+  readonly "aria-labelledby": string | undefined;
+  readonly "aria-describedby": string | undefined;
+}
+export interface BreadcrumbListProps {
+  readonly role: "list";
+}
+export interface BreadcrumbItemProps {
+  readonly role: "listitem";
+  readonly "aria-current": "page" | undefined;
+  readonly "aria-disabled": "true" | undefined;
+}
+export interface BreadcrumbLinkProps {
+  readonly href: string | undefined;
+  readonly "aria-current": "page" | undefined;
+  readonly onClick: () => void;
+}
+export interface Breadcrumb {
+  readonly navProps: BreadcrumbNavProps;
+  readonly listProps: BreadcrumbListProps;
+  readonly itemProps: (index: number) => BreadcrumbItemProps;
+  readonly linkProps: (index: number) => BreadcrumbLinkProps;
+}
+/**
+ * APG Breadcrumb (https://www.w3.org/WAI/ARIA/apg/patterns/breadcrumb/): a trail
+ * of links in hierarchical order, the current page LAST and marked
+ * `aria-current=page` (on both the item and its link). Platform: native (static
+ * markup; the navigation landmark is a UA/AT concern).
+ */
+export declare const createBreadcrumb: (options: BreadcrumbOptions) => Breadcrumb;
+//#endregion
+//#region src/button.d.ts
+export interface ButtonOptions {
+  /** A toggle button carries `aria-pressed`; a command button does not. */
+  readonly isToggle?: boolean;
+  /** Controlled: the host owns the pressed state and this is the only thing that changes it. */
+  readonly value?: boolean | undefined;
+  /** Uncontrolled starting state for a toggle. */
+  readonly defaultValue?: boolean;
+  /** aria-disabled: the button stays focusable but never activates. */
+  readonly disabled?: boolean;
+  /** The activation happened (Enter, Space or pointer). */
+  readonly onClick?: () => void;
+  /**
+   * A request to change the pressed state, called when a toggle activation
+   * differs from the current value. Uncontrolled it is accepted; controlled the
+   * host may ignore it.
+   */
+  readonly onValueChange?: (pressed: boolean) => void;
+}
+/** Spread onto a native `<button>`. */
+export interface ButtonProps {
+  readonly type: "button";
+  readonly role: "button";
+  readonly tabindex: number;
+  readonly "aria-pressed": "true" | "false" | undefined;
+  readonly "aria-disabled": "true" | undefined;
+  readonly onClick: () => void;
+}
+export interface Button {
+  readonly pressed: Accessor<boolean>;
+  /** Activate: a request the disabled guard may drop. */
+  readonly press: () => void;
+  /** Programmatic pressed change; a request the host may ignore. */
+  readonly setPressed: (pressed: boolean) => void;
+  /** Getter-backed, so spreading it keeps every attribute reactive. */
+  readonly buttonProps: ButtonProps;
+}
+/**
+ * APG Button (https://www.w3.org/WAI/ARIA/apg/patterns/button/): a command
+ * button and (with `isToggle`) a toggle button exposing `aria-pressed`.
+ * Platform: native (`<button>` handles Enter/Space, focus and pointer); the
+ * primitive only derives the ARIA contract and the toggle state.
+ *
+ * Request/commit (map ticket `rt1p`): a toggle activation is a request the host
+ * may ignore; `value` + `onValueChange` own the state, `defaultValue` is
+ * uncontrolled. A command button's activation never carries a value.
+ */
+export declare const createButton: (options?: ButtonOptions) => Button;
+//#endregion
+//#region src/carousel.d.ts
+export type CarouselRole = "region" | "group";
+/**
+ * Options are read lazily (getters); pass a component's `props`.
+ */
+export interface CarouselOptions {
+  /** Number of slides. */
+  readonly items?: number;
+  /** Controlled: the host owns the shown slide and this is the only thing that changes it. */
+  readonly value?: number | undefined;
+  /** Shown slide at mount (uncontrolled). */
+  readonly defaultIndex?: number;
+  /** Auto-rotation feature; false removes the rotation control. */
+  readonly autoRotate?: boolean;
+  /** Start rotating (ignored when `reducedMotion`). */
+  readonly playing?: boolean;
+  /** `prefers-reduced-motion` (or pause-on-load): start paused. */
+  readonly reducedMotion?: boolean;
+  /** Tabbed slide picker (tablist/tab/tabpanel) instead of plain groups. */
+  readonly tabbed?: boolean;
+  /** Pattern text: focus inside stops rotation until the control restarts it. */
+  readonly stickyFocusPause?: boolean;
+  /** Pointer starts over the carousel. */
+  readonly hovering?: boolean;
+  readonly role?: CarouselRole;
+  readonly labelledBy?: string | undefined;
+  /** Base for the generated ids. */
+  readonly id?: string;
+  /**
+   * A request to show a slide, called when the intent differs from the current
+   * index. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (index: number) => void;
+  readonly onRotatingChange?: (rotating: boolean) => void;
+}
+/** Spread onto the rotation (play/pause) control. */
+export interface CarouselRotationProps {
+  readonly type: "button";
+  readonly id: string;
+  readonly "aria-label": string;
+  readonly "aria-controls": string;
+  readonly hidden: boolean;
+  readonly onMouseDown: (event: MouseEvent) => void;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+/** Spread onto the previous / next controls. */
+export interface CarouselButtonProps {
+  readonly type: "button";
+  readonly id: string;
+  readonly "aria-controls": string;
+  readonly onMouseDown: (event: MouseEvent) => void;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+export interface CarouselProps {
+  readonly role: CarouselRole;
+  readonly "aria-roledescription": "carousel";
+  readonly "aria-live": "off" | "polite";
+  readonly "aria-labelledby": string | undefined;
+  readonly onMouseMove: () => void;
+  readonly onMouseLeave: () => void;
+}
+export interface CarouselSlideProps {
+  readonly id: string;
+  readonly role: "group" | "tabpanel";
+  readonly "aria-roledescription": "slide";
+  readonly "aria-label": string;
+  readonly tabindex: 0 | -1;
+  readonly hidden: boolean;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+export interface CarouselTablistProps {
+  readonly role: "tablist";
+}
+export interface CarouselTabProps {
+  readonly id: string;
+  readonly role: "tab";
+  readonly "aria-label": string;
+  readonly "aria-selected": "true" | "false";
+  readonly "aria-controls": string;
+  readonly tabindex: -1 | undefined;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface Carousel {
+  readonly items: number;
+  readonly current: Accessor<number>;
+  readonly rotating: Accessor<boolean>;
+  /** The part holding focus (`rotation`, `prev`, `tab:1`, `slide:0`), or null. */
+  readonly focused: Accessor<string | null>;
+  readonly next: () => void;
+  readonly prev: () => void;
+  readonly selectSlide: (index: number) => void;
+  readonly toggleRotation: () => void;
+  /** One auto-rotation interval. */
+  readonly tick: () => void;
+  readonly carouselProps: CarouselProps;
+  readonly rotationProps: CarouselRotationProps;
+  readonly prevProps: CarouselButtonProps;
+  readonly nextProps: CarouselButtonProps;
+  readonly slideProps: (index: number) => CarouselSlideProps;
+  readonly tablistProps: CarouselTablistProps;
+  readonly tabProps: (index: number) => CarouselTabProps;
+}
+/**
+ * APG Carousel (https://www.w3.org/WAI/ARIA/apg/patterns/carousel/): state plus
+ * prop objects for the rotation/prev/next controls, slides and the optional
+ * tabbed picker. Auto-rotation pauses while focus or hover is inside (unless the
+ * user explicitly started it); slides are `group` or `tabpanel`. No styling, no
+ * elements. Checked against `specs/apg/carousel.qnt` by the scenario bridge.
+ *
+ * Platform: **hybrid** — CSS scroll-snap (widely) scrolls slides; the library
+ * owns rotation control, pause-on-focus/hover, live region and slide semantics.
+ *
+ * The rotation/prev/next controls suppress the focus a mouse press would give
+ * them (APG: activating a control does not move focus); tabs and slides still
+ * take focus so the tab sequence can be walked.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default
+ * (`defaultIndex`); pass `value` + `onValueChange` to own the shown slide.
+ * `next`, `prev`, `selectSlide` and `tick` are requests too.
+ *
+ * ponytail: rotation advances only through the exposed `tick`; wire a real timer
+ * (and `prefers-reduced-motion`) in the consumer.
+ */
+export declare const createCarousel: (options?: CarouselOptions) => Carousel;
+//#endregion
+//#region src/checkbox.d.ts
+export type CheckboxState = "true" | "false" | "mixed";
+export interface CheckboxOptions {
+  /** Controlled: the host owns the value and this is the only thing that changes it. */
+  readonly value?: CheckboxState | undefined;
+  /** Uncontrolled starting value; ignored while `value` is set. */
+  readonly defaultValue?: CheckboxState;
+  /** Tri-state: the state may be `mixed`. */
+  readonly allowMixed?: boolean;
+  readonly disabled?: boolean;
+  readonly readOnly?: boolean;
+  readonly id?: string;
+  /**
+   * A request to change the value, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (state: CheckboxState) => void;
+}
+/** Spread onto the focusable element with `role=checkbox`. */
+export interface CheckboxProps {
+  readonly role: "checkbox";
+  readonly "aria-checked": CheckboxState;
+  readonly "aria-disabled": "true" | undefined;
+  readonly "aria-readonly": "true" | undefined;
+  readonly tabindex: 0;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onKeyUp: (event: KeyboardEvent) => void;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+export interface Checkbox {
+  /** `aria-checked` value; `mixed` only while `allowMixed`. */
+  readonly checked: Accessor<CheckboxState>;
+  readonly allowMixed: Accessor<boolean>;
+  readonly disabled: Accessor<boolean>;
+  readonly readOnly: Accessor<boolean>;
+  readonly focused: Accessor<boolean>;
+  /** Programmatic state change; a request the host may ignore. */
+  readonly setChecked: (state: CheckboxState) => void;
+  readonly setAllowMixed: (value: boolean) => void;
+  readonly setDisabled: (value: boolean) => void;
+  readonly toggle: () => void;
+  readonly checkboxProps: CheckboxProps;
+}
+/**
+ * APG Checkbox (https://www.w3.org/WAI/ARIA/apg/patterns/checkbox/): one
+ * dual-state, optionally tri-state, checkbox. Platform choice (docs/research/
+ * apg-platform-features.md): **native** `<input type=checkbox>` (+ the
+ * `indeterminate` JS property); this primitive exposes the polyfillable
+ * `role=checkbox` + `aria-checked` contract so the same state drives either
+ * element. Space arms on keydown and fires on keyup; Enter is a no-op.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the state.
+ */
+export declare const createCheckbox: (options?: CheckboxOptions) => Checkbox;
+//#endregion
+//#region src/checkbox-group.d.ts
+export type CheckboxGroupFocus = "none" | "parent" | "c0" | "c1" | "c2";
+export type ParentChecked = "true" | "false" | "mixed";
+export interface CheckboxGroupOptions<T = unknown> {
+  /** Exactly three child values; the observable value is the checked subset. */
+  readonly values: ReadonlyArray<T>;
+  /** Controlled: the host owns the checked subset and this is the only thing that changes it. */
+  readonly value?: ReadonlyArray<T> | undefined;
+  /** Uncontrolled starting checked subset; ignored while `value` is set. */
+  readonly defaultValue?: ReadonlyArray<T>;
+  /** Controller participates in focus order (its `aria-checked` is always derived). */
+  readonly parent?: boolean;
+  /** Remember the last mixed combination for the controller's third activation. */
+  readonly remember?: boolean;
+  /**
+   * A request to change the checked subset, called when the intent differs from
+   * the current value. Uncontrolled it is accepted; controlled the host may
+   * ignore it.
+   */
+  readonly onValueChange?: (checked: ReadonlyArray<T>) => void;
+  readonly onFocus?: (target: string) => void;
+  readonly onBlur?: () => void;
+}
+/** Spread onto the controller element with `role=checkbox`. */
+export interface CheckboxGroupParentProps {
+  readonly role: "checkbox";
+  readonly "aria-checked": ParentChecked;
+  readonly tabindex: 0;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+}
+/** Spread onto a child element with `role=checkbox`. */
+export interface CheckboxGroupChildProps {
+  readonly id: string;
+  readonly role: "checkbox";
+  readonly "aria-checked": "true" | "false";
+  readonly tabindex: 0;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+}
+export interface CheckboxGroupProps {
+  readonly role: "group";
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface CheckboxGroup<T = unknown> {
+  readonly children: Accessor<ReadonlyArray<boolean>>;
+  readonly memory: Accessor<ReadonlyArray<boolean>>;
+  readonly remember: Accessor<boolean>;
+  readonly focused: Accessor<CheckboxGroupFocus>;
+  readonly parentChecked: Accessor<ParentChecked>;
+  readonly checkedValues: () => ReadonlyArray<T>;
+  readonly click: (target: CheckboxGroupFocus) => void;
+  readonly keySpace: () => void;
+  readonly keyTab: () => void;
+  readonly focusOn: (target: CheckboxGroupFocus) => void;
+  readonly blur: () => void;
+  readonly setRemember: (value: boolean) => void;
+  readonly setChildren: (children: ReadonlyArray<boolean>) => void;
+  readonly groupProps: CheckboxGroupProps;
+  readonly parentProps: CheckboxGroupParentProps;
+  readonly childProps: (index: 0 | 1 | 2) => CheckboxGroupChildProps;
+}
+/**
+ * APG Checkbox pattern's tri-state group controller
+ * (https://www.w3.org/WAI/ARIA/apg/patterns/checkbox/): a controller whose
+ * `aria-checked` is derived from three children (all/none/mixed), plus the
+ * optional "remember the last mixed combination" cycle. Platform choice
+ * (docs/research/apg-platform-features.md): **native** checkboxes; the
+ * controller is a third checkbox with `aria-checked=mixed`.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the checked subset. The checked set is
+ * packed internally so it rides the scalar `createControllable`.
+ *
+ * Behaviour is checked against `specs/apg/checkbox-group.qnt` by the bridge.
+ */
+export declare const createCheckboxGroup: <T = unknown>(options: CheckboxGroupOptions<T>) => CheckboxGroup<T>;
+//#endregion
+//#region src/combobox.d.ts
+/**
+ * APG combobox (https://www.w3.org/WAI/ARIA/apg/patterns/combobox/): state plus
+ * getter-backed attribute objects for a listbox popup. No elements, no styling.
+ *
+ * The behaviour mirrors `specs/apg/combobox-select-only.qnt`: DOM focus never
+ * leaves the combobox, the popup's active option is exposed through
+ * `aria-activedescendant`, and navigating never commits — Enter / Space / Tab /
+ * blur / Alt+ArrowUp / an option click / `setValue` do. `filter: true` switches
+ * typing from typeahead to a prefix filter (the autocomplete variant).
+ *
+ * Request/commit (map ticket `rt1p`): both the selected value and the popup are
+ * controllable. Uncontrolled by default (`defaultSelectedValue` / `defaultOpen`);
+ * pass `value` / `open` (+ `onValueChange` / `onOpenChange`) to own them. Every
+ * user change is a request the host may ignore; `setValue` / `setOpen` are
+ * programmatic requests too.
+ *
+ * ponytail: `activeIndex` is an index into `options()` (the filtered list), not
+ * the full corpus.
+ */
+export type ComboboxAutoComplete = "none" | "list" | "both";
+export interface ComboboxOption {
+  readonly value: string;
+  readonly label: string;
+}
+export interface ComboboxOptionState {
+  readonly value: string;
+  readonly label: string;
+  readonly selected: boolean;
+  readonly id: string;
+  readonly props: {
+    readonly id: string;
+    readonly role: "option";
+    readonly "aria-selected": "true" | "false";
+    readonly onClick: () => void;
+    /** Keep a pointer click from stealing DOM focus away from the combobox. */
+    readonly onMouseDown: (event: MouseEvent) => void;
+  };
+}
+export interface ComboboxInputProps {
+  readonly id: string;
+  readonly role: "combobox";
+  readonly value: string;
+  readonly "aria-autocomplete": ComboboxAutoComplete;
+  readonly "aria-haspopup": "listbox";
+  readonly "aria-expanded": "true" | "false";
+  readonly "aria-controls": string | undefined;
+  readonly "aria-activedescendant": string | undefined;
+  readonly onInput: (event: InputEvent) => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+  readonly onClick: () => void;
+}
+export interface ComboboxTriggerProps {
+  readonly id: string;
+  readonly type: "button";
+  readonly tabindex: -1;
+  readonly "aria-haspopup": "listbox";
+  readonly "aria-expanded": "true" | "false";
+  readonly "aria-controls": string | undefined;
+  readonly onClick: () => void;
+  /** Keep a pointer click from stealing focus, so DOM focus stays on the combobox. */
+  readonly onMouseDown: (event: MouseEvent) => void;
+}
+export interface ComboboxListboxProps {
+  readonly id: string;
+  readonly role: "listbox";
+  readonly hidden: boolean;
+}
+export interface Combobox {
+  readonly open: Accessor<boolean>;
+  /** Index into `options()`; `-1` = visual focus on the combobox. */
+  readonly activeIndex: Accessor<number>;
+  readonly value: Accessor<string | null>;
+  readonly focused: Accessor<boolean>;
+  /** The typeahead / filter text (empty until the user types). */
+  readonly query: Accessor<string>;
+  readonly options: Accessor<ReadonlyArray<ComboboxOptionState>>;
+  readonly setOpen: (open: boolean) => void;
+  readonly setValue: (value: string | null) => void;
+  readonly comboboxProps: ComboboxInputProps;
+  readonly triggerProps: ComboboxTriggerProps;
+  readonly listboxProps: ComboboxListboxProps;
+}
+export interface ComboboxOptions {
+  readonly options: ReadonlyArray<ComboboxOption | string>;
+  /** Controlled: the host owns the selection and this is the only thing that changes it. */
+  readonly value?: string | null | undefined;
+  /** Uncontrolled starting selection; ignored while `value` is set. */
+  readonly defaultSelectedValue?: string | null;
+  /** Uncontrolled starting selection (alias for `defaultSelectedValue`). */
+  readonly defaultValue?: string | null;
+  /** Controlled: the host owns the popup and this is the only thing that opens/closes it. */
+  readonly open?: boolean | undefined;
+  /** Uncontrolled starting popup state; ignored while `open` is set. */
+  readonly defaultOpen?: boolean;
+  readonly autoComplete?: ComboboxAutoComplete;
+  /** `true` = prefix filtering while typing; `false` = single-letter typeahead. */
+  readonly filter?: boolean;
+  readonly placeholder?: string;
+  readonly id?: string;
+  /**
+   * A request to change the popup, called when the intent differs from the
+   * current value; uncontrolled it is accepted, controlled the host may ignore it.
+   */
+  readonly onOpenChange?: (open: boolean) => void;
+  /**
+   * A request to change the selection, called when the intent differs from the
+   * current value; uncontrolled it is accepted, controlled the host may ignore it.
+   */
+  readonly onValueChange?: (value: string | null) => void;
+  /**
+   * A host request to move focus off the widget. The primitive has already set
+   * its own `focused` false; this only lets a DOM host release native focus (the
+   * default host blurs `document.activeElement`). A non-DOM target needs nothing,
+   * so the primitive never reads the DOM itself.
+   */
+  readonly onFocusRelease?: () => void;
+}
+export declare const createCombobox: (options: ComboboxOptions) => Combobox;
+//#endregion
+//#region src/dialog-modal.d.ts
+export type DialogRole = "dialog" | "alertdialog";
+export interface DialogModalOptions {
+  /** Controlled: the host owns the open state and this is the only thing that changes it. */
+  readonly value?: boolean | undefined;
+  /** Uncontrolled starting state; ignored while `value` is set. */
+  readonly defaultOpen?: boolean;
+  readonly modal?: boolean;
+  readonly role?: DialogRole;
+  /** Id of the element naming the dialog. */
+  readonly labelledby?: string | undefined;
+  /** Id of the element describing the dialog (required for alertdialog). */
+  readonly describedby?: string | undefined;
+  /** A click on the backdrop / outside closes the dialog (`isDismissable`). */
+  readonly dismissable?: boolean;
+  /** Escape cannot close the dialog (`isKeyboardDismissDisabled`). */
+  readonly keyboardDismissDisabled?: boolean;
+  readonly id?: string;
+  /** A request to change the open state, called when the intent differs. */
+  readonly onOpenChange?: (open: boolean) => void;
+}
+export interface DialogTriggerProps {
+  readonly id: string;
+  readonly "aria-haspopup": "dialog";
+  readonly "aria-expanded": "true" | "false";
+  readonly "aria-controls": string;
+  readonly onClick: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface DialogContentProps {
+  readonly id: string;
+  readonly role: DialogRole;
+  readonly "aria-modal": "true" | undefined;
+  readonly "aria-labelledby": string | undefined;
+  readonly "aria-describedby": string | undefined;
+  readonly tabindex: -1;
+  readonly hidden: boolean;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface DialogBackdropProps {
+  readonly id: string;
+  readonly hidden: boolean;
+  readonly onClick: () => void;
+}
+export interface DialogModal {
+  readonly open: Accessor<boolean>;
+  readonly openDialog: () => void;
+  readonly close: () => void;
+  readonly triggerProps: DialogTriggerProps;
+  readonly dialogProps: DialogContentProps;
+  readonly backdropProps: DialogBackdropProps;
+  readonly dismissProps: {
+    readonly id: string;
+    readonly type: "button";
+    readonly onClick: () => void;
+  };
+}
+/**
+ * APG Dialog (Modal) on Solid 2. `modal` adds `aria-modal`. Focus moves into
+ * the dialog on open and is the host's to restore on close (the fixture does,
+ * for dismiss / Escape). The full stack/focus-trap machine lives in
+ * `specs/apg/dialog-modal.qnt`; the generated model is the oracle in tests, not
+ * loaded here.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultOpen`);
+ * pass `value` + `onOpenChange` to own the open state. `openDialog` / `close`
+ * are requests the host may ignore.
+ */
+export declare const createDialogModal: (options?: DialogModalOptions) => DialogModal;
+//#endregion
+//#region src/feed.d.ts
+/**
+ * Options are read lazily (getters); pass a component's `props`.
+ */
+export interface FeedOptions {
+  /** Article slots rendered in the DOM (loaded ones are shown). */
+  readonly items?: number;
+  /** Server total: a number, or null when undetermined. */
+  readonly totalArticles?: number | null;
+  /** Controlled: the host owns the loaded count and this is the only thing that changes it. */
+  readonly value?: number | undefined;
+  /** Uncontrolled starting count; ignored while `value` is set. */
+  readonly defaultValue?: number;
+  readonly sizeMode?: "loaded" | "total";
+  readonly totalKnown?: boolean;
+  readonly labelledBy?: string | undefined;
+  /** Base for the generated ids. */
+  readonly id?: string;
+  /**
+   * A request to change the loaded count, called when an arriving batch differs
+   * from the current value. Uncontrolled it is accepted; controlled the host
+   * may ignore it.
+   */
+  readonly onValueChange?: (loaded: number) => void;
+}
+export interface FeedProps {
+  readonly id: string;
+  readonly role: "feed";
+  readonly "aria-busy": "true" | undefined;
+  readonly "aria-labelledby": string | undefined;
+}
+export interface FeedArticleProps {
+  readonly id: string;
+  readonly role: "article";
+  readonly "aria-posinset": number;
+  readonly "aria-setsize": number;
+  readonly "aria-labelledby": string;
+  readonly "aria-describedby": string;
+  readonly tabindex: 0;
+  readonly hidden: boolean;
+  readonly onFocus: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+/** Spread onto the focusable element just before / after the feed. */
+export interface FeedSentinelProps {
+  readonly id: string;
+  readonly tabindex: 0;
+  readonly onFocus: () => void;
+}
+export type FeedActive = number | "before" | "after";
+export interface Feed {
+  readonly items: number;
+  readonly loaded: Accessor<number>;
+  readonly busy: Accessor<boolean>;
+  /** Focused article (1-based posinset) or the outside zone. */
+  readonly active: Accessor<FeedActive>;
+  readonly focusArticle: (posinset: number) => void;
+  readonly pageDown: () => void;
+  readonly pageUp: () => void;
+  readonly ctrlEnd: () => void;
+  readonly ctrlHome: () => void;
+  /** Scroll/position asked for more: `aria-busy` goes true while in flight. */
+  readonly loadStart: () => void;
+  /** A batch arrived; a request to grow the loaded count. */
+  readonly loadFinish: (count: number) => void;
+  readonly loadFail: () => void;
+  readonly setSizeMode: (mode: "loaded" | "total") => void;
+  readonly setTotalKnown: (known: boolean) => void;
+  readonly feedProps: FeedProps;
+  readonly articleProps: (posinset: number) => FeedArticleProps;
+  readonly beforeProps: FeedSentinelProps;
+  readonly afterProps: FeedSentinelProps;
+}
+/**
+ * APG Feed (https://www.w3.org/WAI/ARIA/apg/patterns/feed/): state plus prop
+ * objects for the feed container, its articles and the two outside focus
+ * sentinels. Focus reaching the last loaded article triggers a load; `aria-busy`
+ * brackets it; Page Up/Down move by article; Control+End/Home leave the feed.
+ * No styling, no elements. Checked against `specs/apg/feed.qnt`.
+ *
+ * Platform: **library** — focusgroup V2 `feed` is explainer-only, so the load
+ * trigger, busy bracketing and Page Up/Down / Control+End/Home keys are ours.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the loaded count. `loadFinish` is the
+ * request; `loadStart` / `loadFail` are adapter lifecycle events.
+ */
+export declare const createFeed: (options?: FeedOptions) => Feed;
+//#endregion
+//#region src/grid.d.ts
+/**
+ * APG grid primitive on Solid 2: roving focus, 2-D navigation, edit mode, a
+ * cell/row/column selection rectangle and sortable column headers. State plus
+ * getter-backed attribute objects; no elements, no styling.
+ *
+ * Behaviour mirrors `specs/apg/grid.qnt` (navigation/edit), `grid-selection.qnt`
+ * (selection) and `grid-sort.qnt` (sortable headers); the generated machines are
+ * the oracles in tests, not runtime dependencies.
+ *
+ * Request/commit (map ticket `rt1p`): navigation is internal and uncontrolled;
+ * the two user-changeable values are the selection and the sort. Both are
+ * uncontrolled by default (`defaultValue` / `defaultSortValue`) and can be owned
+ * by the host with `value` + `onValueChange` / `sortValue` + `onSortChange`.
+ * Programmatic methods (`clickCell`, `setSelectable`, `setSortEnabled` and the
+ * keyboard/pointer handlers) are requests; a controlled host may ignore them.
+ */
+export type GridKind = "data" | "layout";
+export type GridFocusTarget = "cell" | "widget";
+export type GridSortDirection = "none" | "ascending" | "descending";
+/** A mounted row range: rows `[start, start + count)` are rendered. */
+export interface GridWindow {
+  readonly start: number;
+  readonly count: number;
+}
+export interface GridOptions {
+  readonly rows?: number;
+  readonly cols?: number;
+  readonly gridKind?: GridKind;
+  readonly wrapCols?: boolean;
+  readonly wrapRows?: boolean;
+  readonly focusTarget?: GridFocusTarget;
+  readonly gridReadonly?: boolean;
+  /** Adds cell selection (`aria-selected`) and the selection keys. */
+  readonly selectable?: boolean;
+  /** Adds sortable `columnheader`s (`aria-sort`). */
+  readonly sortEnabled?: boolean;
+  /**
+   * Controlled: the host owns the selected rectangle, packed (`0` = nothing
+   * selected; see `packSelection`). This is the only thing that changes it.
+   */
+  readonly value?: number | undefined;
+  /** Uncontrolled starting packed selection; ignored while `value` is set. */
+  readonly defaultValue?: number;
+  /**
+   * A request to change the selection, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (value: number) => void;
+  /**
+   * Controlled: the host owns the sort, packed (`-1` = unsorted; see
+   * `packSort`). This is the only thing that changes it.
+   */
+  readonly sortValue?: number | undefined;
+  /** Uncontrolled starting packed sort; ignored while `sortValue` is set. */
+  readonly defaultSortValue?: number;
+  /**
+   * A request to change the sort, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onSortChange?: (value: number) => void;
+  /** PageUp/PageDown step, in rows (the spec's PAGE constant). */
+  readonly page?: number;
+  /** Base for generated ids. */
+  readonly id?: string;
+  /**
+   * ponytail: virtualization seam only — a windowed row range; add measurement /
+   * overscan when a real scroller drives it. Cell/row indices stay absolute.
+   */
+  readonly rowWindow?: GridWindow;
+}
+export interface GridProps {
+  readonly role: "grid";
+  readonly "aria-rowcount": number;
+  readonly "aria-colcount": number;
+  readonly "aria-readonly": "true" | "false";
+  readonly "aria-activedescendant": string | undefined;
+  readonly onFocusOut: (event: FocusEvent) => void;
+}
+export interface GridRowProps {
+  readonly role: "row";
+  readonly id: string;
+  readonly "aria-rowindex": number;
+}
+export interface GridCellProps {
+  readonly role: "gridcell";
+  readonly id: string;
+  readonly tabindex: number;
+  readonly "aria-rowindex": number;
+  readonly "aria-colindex": number;
+  readonly "aria-readonly": "true" | "false";
+  readonly "aria-selected": "true" | "false" | undefined;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+/** A focusable widget rendered inside a cell (focusTarget = "widget"). */
+export interface GridWidgetProps {
+  readonly tabindex: number;
+  readonly onFocus: () => void;
+}
+export interface GridHeaderProps {
+  readonly role: "columnheader";
+  readonly id: string;
+  readonly tabindex: number;
+  readonly "aria-sort": "none" | "ascending" | "descending" | undefined;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface Grid {
+  readonly rows: Accessor<number>;
+  readonly cols: Accessor<number>;
+  readonly row: Accessor<number>;
+  readonly col: Accessor<number>;
+  readonly hasFocus: Accessor<boolean>;
+  readonly mode: Accessor<"navigate" | "edit">;
+  readonly gridKind: Accessor<GridKind>;
+  readonly wrapCols: Accessor<boolean>;
+  readonly wrapRows: Accessor<boolean>;
+  readonly focusTarget: Accessor<GridFocusTarget>;
+  readonly gridReadonly: Accessor<boolean>;
+  readonly lastEdit: Accessor<"none" | "committed" | "cancelled">;
+  /** The row indices currently mounted (the virtualization window). */
+  readonly renderedRows: Accessor<ReadonlyArray<number>>;
+  readonly isSelected: (row: number, col: number) => boolean;
+  /** The controlled selection value (packed; `0` = nothing selected). */
+  readonly selection: Accessor<number>;
+  readonly sortColumn: Accessor<number>;
+  readonly sortDirection: Accessor<GridSortDirection>;
+  /** The controlled sort value (packed; `-1` = unsorted). */
+  readonly sort: Accessor<number>;
+  /** The `data-part` target the roving tab stop should focus, for fixtures. */
+  readonly focusTargetPart: Accessor<string | null>;
+  readonly gridProps: GridProps;
+  readonly rowProps: (row: number) => GridRowProps;
+  readonly cellProps: (row: number, col: number) => GridCellProps;
+  readonly widgetProps: (row: number, col: number) => GridWidgetProps;
+  readonly headerProps: (col: number) => GridHeaderProps;
+  /** Programmatic enter (spec `focus_in`); keeps the roving tab stop. */
+  readonly focus: () => void;
+  readonly blur: () => void;
+  readonly clickCell: (row: number, col: number) => void;
+  readonly setGridKind: (kind: GridKind) => void;
+  readonly setWrapCols: (flag: boolean) => void;
+  readonly setWrapRows: (flag: boolean) => void;
+  readonly setFocusTarget: (target: GridFocusTarget) => void;
+  readonly setGridReadonly: (flag: boolean) => void;
+  readonly setSelectable: (flag: boolean) => void;
+  readonly setSortEnabled: (flag: boolean) => void;
+}
+/** The `data-part` address of a cell/widget/header, shared with the bridge. */
+export declare const cellPart: (row: number, col: number) => string;
+export declare const rowPart: (row: number) => string;
+export declare const headerPart: (col: number) => string;
+/**
+ * The controlled selection value (map ticket `rt1p`): `0` = nothing selected,
+ * else `1 + r0 + rows*r1 + rows^2*c0 + rows^2*cols*c1` for the active rectangle.
+ * Injective over the ordered rectangles of the bounded grid.
+ */
+export declare const packSelection: (rows: number, cols: number, active: boolean, r0: number, r1: number, c0: number, c1: number) => number;
+/**
+ * The controlled sort value: `-1` = unsorted, else `2*column + (descending ?
+ * 1 : 0)`. Injective for the columns the sort spec encodes.
+ */
+export declare const packSort: (column: number, dir: GridSortDirection) => number;
+/**
+ * Every option is read lazily, so pass props/getters (never a destructured
+ * snapshot); `rows`/`cols`/`page` are captured once.
+ */
+export declare const createGrid: (options?: GridOptions) => Grid;
+//#endregion
+//#region src/link.d.ts
+export interface LinkOptions {
+  readonly href?: string | undefined;
+  /** Render a native `<a href>` (the default when `href` is set). */
+  readonly native?: boolean;
+  readonly disabled?: boolean;
+  /** aria-current="page" for the current page in a trail. */
+  readonly current?: boolean;
+  /** The link executed (Enter or pointer activation). */
+  readonly onActivate?: () => void;
+  /** Router integration: the href the activation would navigate to. */
+  readonly onNavigate?: (href: string) => void;
+}
+/** Spread onto the `<a>` or the custom `role=link` element. */
+export interface LinkProps {
+  readonly role: "link" | undefined;
+  readonly tabindex: number | undefined;
+  readonly href: string | undefined;
+  readonly "aria-disabled": "true" | undefined;
+  readonly "aria-current": "page" | undefined;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onClick: (event: MouseEvent) => void;
+}
+export interface Link {
+  readonly native: Accessor<boolean>;
+  readonly href: Accessor<string | undefined>;
+  readonly disabled: Accessor<boolean>;
+  /** Getter-backed, so spreading it keeps every attribute reactive. */
+  readonly linkProps: LinkProps;
+}
+/**
+ * APG Link (https://www.w3.org/WAI/ARIA/apg/patterns/link/): a native `<a href>`
+ * brings focus and activation for free; a custom element takes `role=link` and
+ * `tabindex=0` plus an Enter handler, because "applying the link role will not
+ * cause browsers to enhance the element". Platform: native.
+ */
+export declare const createLink: (options?: LinkOptions) => Link;
+//#endregion
+//#region src/listbox.d.ts
+export type ListboxSelectionMode = "single" | "multiple" | "none";
+export interface ListboxItem {
+  readonly id: string;
+  readonly label: string;
+  /** Text matched by type-ahead (defaults to the label). */
+  readonly textValue: string;
+  readonly disabled: boolean;
+}
+export type ListboxItemInput = string | {
+  readonly id?: string;
+  readonly label: string;
+  readonly textValue?: string;
+  readonly disabled?: boolean;
+};
+export interface ListboxModifiers {
+  readonly shift?: boolean;
+  readonly ctrl?: boolean;
+  readonly meta?: boolean;
+  readonly alt?: boolean;
+}
+export interface ListboxOptions {
+  readonly items: ReadonlyArray<ListboxItemInput>;
+  readonly selectionMode?: ListboxSelectionMode;
+  /** Single-select only: moving the active option moves the selection with it. */
+  readonly followsFocus?: boolean;
+  /** Controlled selection: the host owns it and `value` is the only thing that changes it. */
+  readonly value?: ReadonlyArray<number> | undefined;
+  /** Uncontrolled starting selection; ignored while `value` is set. */
+  readonly defaultValue?: ReadonlyArray<number>;
+  /** Alias for `defaultValue` (kept for the existing API). */
+  readonly defaultSelected?: ReadonlyArray<number>;
+  /** Uncontrolled active option at mount. */
+  readonly defaultActive?: number;
+  /** Controlled active option: the type-ahead focus move's value. */
+  readonly activeValue?: number | undefined;
+  /** Option indices that cannot be selected or reached by navigation. */
+  readonly disabled?: ReadonlyArray<number>;
+  readonly focusOnHover?: boolean;
+  /** Base for the generated option ids. */
+  readonly id?: string;
+  readonly label?: string | undefined;
+  /**
+   * A request to change the selection, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (selected: ReadonlyArray<number>) => void;
+  /** Alias for `onValueChange` (kept for the existing API). */
+  readonly onSelectionChange?: (selected: ReadonlyArray<number>) => void;
+  /** A request to move the active option (the type-ahead focus move). */
+  readonly onActiveChange?: (index: number) => void;
+}
+export interface ListboxProps {
+  readonly role: "listbox";
+  readonly "aria-multiselectable": "true" | "false" | undefined;
+  readonly "aria-activedescendant": string | undefined;
+  readonly "aria-label": string | undefined;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onFocusOut: (event: FocusEvent) => void;
+}
+/** Spread onto an element with `role=option`. */
+export interface ListboxOptionProps {
+  readonly id: string;
+  readonly role: "option";
+  readonly "aria-selected": "true" | "false";
+  readonly "aria-disabled": "true" | undefined;
+  readonly "aria-posinset": number;
+  readonly "aria-setsize": number;
+  readonly tabindex: 0 | -1;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onMouseEnter: () => void;
+}
+export interface Listbox {
+  readonly active: Accessor<number>;
+  readonly selected: Accessor<ReadonlyArray<number>>;
+  readonly focused: Accessor<boolean>;
+  readonly items: ReadonlyArray<ListboxItem>;
+  readonly selectionMode: ListboxSelectionMode;
+  /** Focus entry: the first selected option, else the first option. Returns the entry index. */
+  readonly focus: () => number;
+  readonly blur: () => void;
+  readonly keyDown: (key: string, modifiers?: ListboxModifiers) => void;
+  /** Type-ahead input (one printable char). */
+  readonly type: (text: string) => void;
+  readonly clearTypeahead: () => void;
+  readonly clickOption: (index: number) => void;
+  readonly hoverOption: (index: number) => void;
+  readonly setFollowsFocus: (value: boolean) => void;
+  readonly listboxProps: ListboxProps;
+  readonly optionProps: (index: number) => ListboxOptionProps;
+}
+/**
+ * APG Listbox on Solid 2: state plus attribute objects, no elements, no
+ * styling. One widget serves the three spec machines the scenarios use —
+ * single-select (with optional selection-follows-focus), multi-select
+ * (recommended model) and type-ahead — and is verified against each generated
+ * model by a differential walk in `test/listbox.browser.test.tsx`.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default
+ * (`defaultValue` / `defaultSelected`); pass `value` + `onValueChange` to own
+ * the selection, or `activeValue` + `onActiveChange` to own the active option
+ * (the type-ahead value). Every user-intent selection change and every focus
+ * move is a request the host may ignore.
+ */
+export declare const createListbox: (options: ListboxOptions) => Listbox;
+//#endregion
+//#region src/menu.d.ts
+/**
+ * APG menu family on Solid 2: `createMenu` (menu button + the checkable /
+ * menuitemcheckbox / menuitemradio capability) and `createMenubar` (roving
+ * focus, nested submenus, typeahead). Plain Solid signals, zero deps beyond
+ * `solid-js`; no elements, no styling.
+ *
+ * State is a faithful transcription of `specs/apg/menu-button.qnt`,
+ * `menu-checkable.qnt` and `menu-menubar.qnt` (the generated models are the
+ * differential-test oracle, see `test/menu-button.browser.test.tsx`).
+ *
+ * Platform: **hybrid** (map ticket `etfq`). `popover` gives top layer, light
+ * dismiss and Esc; `focusgroup` gives the menubar's roving tabindex. The
+ * library owns the menu keys, typeahead, submenus and checkable state.
+ *
+ * ponytail: uncontrolled; add a `value`/`onValueChange` host pair when a
+ * consumer owns open/checked state.
+ */
+export type MenuItemKind = "item" | "checkbox" | "radio";
+export interface MenuItemInput {
+  readonly label: string;
+  readonly kind?: MenuItemKind;
+  readonly checked?: boolean;
+  readonly disabled?: boolean;
+}
+export type MenuVariant = "plain" | "checkbox-items" | "radio-items" | "mixed";
+export interface MenuOptions {
+  readonly items: ReadonlyArray<string | MenuItemInput>;
+  readonly variant?: MenuVariant;
+  readonly defaultOpen?: boolean;
+  /**
+   * `outside` (menu button): focus can sit outside the widget, so keys are
+   * inert until the trigger is focused. `held` (checkable menu / menubar item
+   * owner): the trigger always holds focus while closed.
+   */
+  readonly triggerMode?: "outside" | "held";
+  /** Checkbox item indices checked at mount (`checkbox-items` / `mixed`). */
+  readonly defaultChecked?: ReadonlyArray<number>;
+  /** Radio item index selected at mount (`radio-items` / `mixed`). */
+  readonly defaultChoice?: number;
+  /**
+   * Controlled: the host owns the checked items. Packed as
+   * `checkboxItem0 * 5 + radioChoice` (1-based), matching `menu-checkable.qnt`'s
+   * `checked(wrap, choice)`; pass `undefined` for uncontrolled. The open state
+   * stays uncontrolled.
+   */
+  readonly value?: number | undefined;
+  /** The uncontrolled packed checked state at mount. */
+  readonly defaultValue?: number;
+  /** A request to change the checked items (a packed `value` the host may ignore). */
+  readonly onCheckedValueChange?: (value: number) => void;
+  /** Item indices disabled (focusable, not activatable). */
+  readonly disabled?: ReadonlyArray<number>;
+  readonly id?: string;
+  readonly onOpenChange?: (open: boolean) => void;
+  readonly onItemClick?: (index: number) => void;
+  readonly onCheckedChange?: (checked: boolean, index: number) => void;
+  readonly onValueChange?: (index: number) => void;
+  /**
+   * Structural mirror of `ing.lexicon.ui.prefs` (`./prefs`). Honoured here:
+   * `typeaheadDelayMs` (the buffer timeout). Absent prefs keep the default.
+   */
+  readonly prefs?: Partial<Prefs> | undefined;
+  /**
+   * While this returns `true`, a DOM `focus` on the trigger/items is ignored, so
+   * a fixture applying focus programmatically does not write back into the
+   * primitive (bean 209r — the differential walk's focus feedback loop).
+   */
+  readonly suppressFocusWrite?: (() => boolean) | undefined;
+}
+export interface MenuItem {
+  readonly id: string;
+  readonly label: string;
+  readonly kind: MenuItemKind;
+  readonly disabled: boolean;
+}
+export interface MenuTriggerProps {
+  readonly id: string;
+  readonly type: "button";
+  readonly "aria-haspopup": "menu";
+  readonly "aria-expanded": "true" | "false";
+  readonly "aria-controls": string;
+  readonly disabled: boolean;
+  readonly onClick: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onFocus: () => void;
+}
+export interface MenuProps {
+  readonly id: string;
+  readonly role: "menu";
+  readonly hidden: boolean;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface MenuItemProps {
+  readonly id: string;
+  readonly role: "menuitem" | "menuitemcheckbox" | "menuitemradio";
+  readonly "aria-checked": "true" | "false" | undefined;
+  readonly "aria-disabled": "true" | undefined;
+  readonly tabindex: 0 | -1;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onMouseEnter: () => void;
+}
+export interface Menu {
+  readonly open: Accessor<boolean>;
+  /** 0 outside, 1 on the trigger, 2 on a menu item. */
+  readonly focusLevel: Accessor<0 | 1 | 2>;
+  readonly focusIndex: Accessor<number>;
+  readonly items: ReadonlyArray<MenuItem>;
+  readonly checked: Accessor<ReadonlyArray<number>>;
+  readonly choice: Accessor<number>;
+  readonly focusTrigger: () => void;
+  readonly leave: () => void;
+  readonly clickTrigger: () => void;
+  readonly openMenu: () => void;
+  readonly closeMenu: () => void;
+  readonly keyDown: (key: string) => void;
+  readonly type: (text: string) => void;
+  /** Differential-test hook: typeahead by the spec's letter code. */
+  readonly typeaheadCode: (code: number) => void;
+  readonly setFocusItem: (index: number) => void;
+  readonly triggerProps: MenuTriggerProps;
+  readonly menuProps: MenuProps;
+  readonly itemProps: (index: number) => MenuItemProps;
+}
+export declare const createMenu: (options: MenuOptions) => Menu;
+export interface MenubarMenuItemInput {
+  readonly label: string;
+  readonly submenu?: ReadonlyArray<MenubarMenuItemInput>;
+  readonly disabled?: boolean;
+}
+export interface MenubarItemInput {
+  readonly label: string;
+  readonly menu?: ReadonlyArray<MenubarMenuItemInput>;
+  readonly disabled?: boolean;
+}
+export interface MenubarOptions {
+  readonly items: ReadonlyArray<string | MenubarItemInput>;
+  readonly orientation?: "horizontal" | "vertical";
+  readonly wrap?: boolean;
+  readonly id?: string;
+  /**
+   * Structural mirror of `ing.lexicon.ui.prefs` (`./prefs`). Honoured here:
+   * `typeaheadDelayMs` (the buffer timeout). Absent prefs keep the default.
+   */
+  readonly prefs?: Partial<Prefs> | undefined;
+  /**
+   * While this returns `true`, a DOM `focus` on the trigger/items is ignored, so
+   * a fixture applying focus programmatically does not write back into the
+   * primitive (bean 209r — the differential walk's focus feedback loop).
+   */
+  readonly suppressFocusWrite?: (() => boolean) | undefined;
+}
+export interface MenubarItem {
+  readonly id: string;
+  readonly label: string;
+  readonly menu: ReadonlyArray<MenubarMenuItem>;
+  readonly disabled: boolean;
+}
+export interface MenubarMenuItem {
+  readonly id: string;
+  readonly label: string;
+  readonly submenu: ReadonlyArray<MenubarMenuItem>;
+  readonly disabled: boolean;
+}
+export interface Menubar {
+  /** 0 outside, 1 menubar, 2 top-level menu, 3 submenu. */
+  readonly focusLevel: Accessor<0 | 1 | 2 | 3>;
+  readonly focusIndex: Accessor<number>;
+  readonly barStop: Accessor<number>;
+  readonly openTop: Accessor<number>;
+  readonly openSub: Accessor<number>;
+  readonly items: ReadonlyArray<MenubarItem>;
+  readonly focusIn: () => void;
+  readonly leave: () => void;
+  readonly keyDown: (key: string) => void;
+  readonly type: (text: string) => void;
+  /** Differential-test hook: typeahead by the spec's letter code. */
+  readonly typeaheadCode: (code: number) => void;
+  readonly menubarProps: {
+    readonly role: "menubar";
+    readonly "aria-orientation": "horizontal" | "vertical";
+    readonly onKeyDown: (event: KeyboardEvent) => void;
+  };
+  readonly barItemProps: (index: number) => {
+    readonly id: string;
+    readonly role: "menuitem";
+    readonly "aria-haspopup": "menu" | undefined;
+    readonly "aria-expanded": "true" | "false" | undefined;
+    readonly tabindex: 0 | -1;
+    readonly onClick: () => void;
+    readonly onFocus: () => void;
+  };
+  readonly menuProps: (index: number) => {
+    readonly id: string;
+    readonly role: "menu";
+    readonly hidden: boolean;
+  };
+  readonly menuItemProps: (bar: number, item: number) => {
+    readonly id: string;
+    readonly role: "menuitem";
+    readonly "aria-haspopup": "menu" | undefined;
+    readonly "aria-expanded": "true" | "false" | undefined;
+    readonly tabindex: 0 | -1;
+    readonly onClick: () => void;
+    readonly onMouseEnter: () => void;
+    readonly onFocus: () => void;
+  };
+  readonly submenuProps: (bar: number, item: number) => {
+    readonly id: string;
+    readonly role: "menu";
+    readonly hidden: boolean;
+  };
+  readonly submenuItemProps: (bar: number, item: number, sub: number) => {
+    readonly id: string;
+    readonly role: "menuitem";
+    readonly tabindex: 0 | -1;
+    readonly onClick: () => void;
+    readonly onMouseEnter: () => void;
+    readonly onFocus: () => void;
+  };
+}
+export declare const createMenubar: (options: MenubarOptions) => Menubar;
+//#endregion
+//#region src/meter.d.ts
+/**
+ * A controlled numeric display; the consumer feeds `value`/`min`/`max`.
+ * `valueText` overrides the default percentage `aria-valuetext`.
+ */
+export interface MeterOptions {
+  readonly value?: number;
+  readonly min?: number;
+  readonly max?: number;
+  readonly valueText?: string | undefined;
+  readonly label?: string | undefined;
+  readonly labelId?: string | undefined;
+}
+/** Spread onto the element with `role=meter`. */
+export interface MeterProps {
+  readonly role: "meter";
+  readonly "aria-valuemin": number;
+  readonly "aria-valuemax": number;
+  readonly "aria-valuenow": number;
+  readonly "aria-valuetext": string;
+  readonly "aria-label": string | undefined;
+  readonly "aria-labelledby": string | undefined;
+}
+export interface Meter {
+  readonly min: Accessor<number>;
+  readonly max: Accessor<number>;
+  /** The raw value clamped into `[min, max]`. */
+  readonly value: Accessor<number>;
+  readonly percent: Accessor<number>;
+  /** Getter-backed, so spreading it keeps every attribute reactive. */
+  readonly meterProps: MeterProps;
+}
+/**
+ * APG Meter (https://www.w3.org/WAI/ARIA/apg/patterns/meter/): a graphical
+ * display of a numeric value within a range. Platform: native (`<meter>`), so
+ * this primitive only derives the ARIA contract; no state machine runs here.
+ */
+export declare const createMeter: (options?: MeterOptions) => Meter;
+//#endregion
+//#region src/radio.d.ts
+export type RadioFlavor = "roving" | "activedescendant";
+export interface RadioGroupOptions<T = unknown> {
+  /** Radio values, one per radio; the observable `value` is the checked one. */
+  readonly values: ReadonlyArray<T>;
+  /** Controlled: the host owns the checked value and this is the only thing that changes it. */
+  readonly value?: T | undefined;
+  /** Uncontrolled starting checked value; ignored while `value` is set. */
+  readonly defaultValue?: T | undefined;
+  /** Roving tabindex (default) or `aria-activedescendant` on the group. */
+  readonly flavor?: RadioFlavor;
+  /** Indices that are never focused, checked or the tab stop. */
+  readonly disabled?: ReadonlyArray<number>;
+  readonly orientation?: "horizontal" | "vertical";
+  readonly dir?: "ltr" | "rtl";
+  readonly id?: string;
+  readonly describedby?: string | undefined;
+  /**
+   * A request to check a radio, called with its value when the intent differs
+   * from the current one. Uncontrolled it is accepted; controlled the host may
+   * ignore it.
+   */
+  readonly onValueChange?: (value: T) => void;
+  readonly onFocus?: (target: string) => void;
+  readonly onBlur?: (target: string) => void;
+}
+/** Spread onto the element with `role=radiogroup`. */
+export interface RadioGroupProps {
+  readonly role: "radiogroup";
+  readonly "aria-orientation": "horizontal" | "vertical" | undefined;
+  readonly "aria-activedescendant": string | undefined;
+  readonly tabindex: 0 | undefined;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onFocus: () => void;
+  readonly onBlur: (event: FocusEvent) => void;
+}
+/** Spread onto an element with `role=radio`. */
+export interface RadioProps {
+  readonly id: string;
+  readonly role: "radio";
+  readonly "aria-checked": "true" | "false";
+  readonly "aria-disabled": "true" | "false";
+  readonly "aria-describedby": string | undefined;
+  readonly tabindex: 0 | -1 | undefined;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+}
+export interface RadioGroup<T = unknown> {
+  readonly checked: Accessor<number | null>;
+  readonly focused: Accessor<number | null>;
+  readonly flavor: Accessor<RadioFlavor>;
+  readonly values: ReadonlyArray<T>;
+  readonly value: () => T | null;
+  readonly focus: () => void;
+  readonly blur: () => void;
+  readonly keyDown: (key: string) => void;
+  readonly click: (index: number) => void;
+  readonly setDisabled: (indices: ReadonlyArray<number>) => void;
+  readonly setFlavor: (flavor: RadioFlavor) => void;
+  readonly setPreselect: (index: number | null) => void;
+  readonly radiogroupProps: RadioGroupProps;
+  readonly radioProps: (index: number) => RadioProps;
+}
+/**
+ * APG Radio Group (https://www.w3.org/WAI/ARIA/apg/patterns/radio/): a
+ * `radiogroup` with `role=radio` items. Platform choice (docs/research/
+ * apg-platform-features.md): **native** `<input type=radio name>`; custom
+ * `role=radio` needs selection-follows-focus, which this primitive implements —
+ * arrows move focus AND check the next/previous enabled radio (wrapping), Space
+ * checks the focused radio, Tab enters on the checked radio.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the check. `click`, `keyDown` and Space
+ * are requests. Behaviour is checked against `specs/apg/radio.qnt` by the
+ * scenario bridge.
+ *
+ * ponytail: the request/commit split is inlined rather than using
+ * `createControllable`, because the config remounts (`setPreselect`,
+ * `setDisabled`) must write the uncontrolled local without firing the request
+ * callback, which `createControllable` does not expose.
+ */
+export declare const createRadioGroup: <T = unknown>(options: RadioGroupOptions<T>) => RadioGroup<T>;
+//#endregion
+//#region src/slider.d.ts
+export type SliderOrientation = "horizontal" | "vertical";
+export type SliderDirection = "ltr" | "rtl";
+export interface SliderOptions {
+  readonly min?: number;
+  readonly max?: number;
+  readonly step?: number;
+  /** The jump distance of PageUp / PageDown. */
+  readonly largeStep?: number;
+  /** Controlled: the host owns the value and this is the only thing that changes it. */
+  readonly value?: number | undefined;
+  /** Starting value when uncontrolled; ignored while `value` is set. */
+  readonly defaultValue?: number;
+  readonly orientation?: SliderOrientation;
+  readonly direction?: SliderDirection;
+  /** Base for the generated thumb id. */
+  readonly id?: string;
+  /**
+   * A request to change the value, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (value: number) => void;
+}
+export interface SliderThumbProps {
+  readonly id: string;
+  readonly role: "slider";
+  readonly "aria-valuenow": string;
+  readonly "aria-valuemin": string;
+  readonly "aria-valuemax": string;
+  readonly "aria-valuetext": string;
+  readonly "aria-orientation": SliderOrientation;
+  readonly tabindex: number;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface SliderTrackProps {
+  readonly onPointerDown: (event: PointerEvent) => void;
+}
+export interface Slider {
+  readonly value: Accessor<number>;
+  readonly focused: Accessor<boolean>;
+  /** Requests; `setValue` and a rail press are requests too. */
+  readonly setValue: (value: number) => void;
+  readonly focus: () => void;
+  readonly blur: () => void;
+  /** Returns whether the key moved the value (the caller preventDefaults it). */
+  readonly keyDown: (key: string) => boolean;
+  /** A rail press at `position` (a 0..1 fraction of the track length). */
+  readonly pointerDown: (position: number) => void;
+  readonly thumbProps: SliderThumbProps;
+  readonly trackProps: SliderTrackProps;
+}
+/**
+ * APG Slider (https://www.w3.org/WAI/ARIA/apg/patterns/slider/): a single
+ * `role=slider` thumb on a rail. Plain Solid signals, no elements, no styling;
+ * verified against `specs/apg/slider.qnt` by the differential walk in
+ * `test/slider.browser.test.tsx`.
+ *
+ * Native / polyfill / hybrid / library: **native** — the platform
+ * `<input type=range>` already owns this pattern; this primitive is the
+ * `role=slider` markup and keyboard contract for hosts that need the ARIA
+ * element (styling the native thumb is not shipped).
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the value. A key or rail press is a
+ * request the host may ignore.
+ *
+ * ponytail: dragging (pointer capture/move) is not modelled — the spec
+ * deliberately only fixes a discrete rail press.
+ */
+export declare const createSlider: (options?: SliderOptions) => Slider;
+//#endregion
+//#region src/slider-multithumb.d.ts
+export type SliderMultiThumbIndex = 0 | 1;
+export interface SliderMultiThumbOptions {
+  readonly min?: number;
+  readonly max?: number;
+  readonly step?: number;
+  /** The jump distance of PageUp / PageDown. */
+  readonly largeStep?: number;
+  /** Controlled: the host owns the pair and this is the only thing that changes it. */
+  readonly value?: readonly [number, number] | undefined;
+  /** Uncontrolled starting `[lo, hi]` values; ignored while `value` is set. */
+  readonly defaultValue?: readonly [number, number];
+  readonly orientation?: SliderOrientation;
+  readonly direction?: SliderDirection;
+  /** Base for the generated thumb ids. */
+  readonly id?: string;
+  /**
+   * A request to change the pair, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore
+   * it.
+   */
+  readonly onValueChange?: (values: readonly [number, number]) => void;
+}
+export interface SliderMultiThumbProps {
+  readonly id: string;
+  readonly role: "slider";
+  readonly "aria-valuenow": string;
+  readonly "aria-valuemin": string;
+  readonly "aria-valuemax": string;
+  readonly "aria-valuetext": string;
+  readonly "aria-orientation": SliderOrientation;
+  readonly tabindex: number;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface SliderMultiThumb {
+  readonly values: Accessor<readonly [number, number]>;
+  readonly focused: Accessor<SliderMultiThumbIndex | null>;
+  readonly setValues: (values: readonly [number, number]) => void;
+  /** Programmatic press on one thumb at `position` (a 0..1 track fraction). */
+  readonly pointerDown: (index: SliderMultiThumbIndex, position: number) => void;
+  readonly focusThumb: (index: SliderMultiThumbIndex) => void;
+  readonly blur: () => void;
+  /** Returns whether the key moved a value (the caller preventDefaults it). */
+  readonly keyDown: (key: string) => boolean;
+  readonly thumbProps: (index: SliderMultiThumbIndex) => SliderMultiThumbProps;
+}
+/**
+ * APG Slider (Multi-Thumb) (https://www.w3.org/WAI/ARIA/apg/patterns/slider-multithumb/):
+ * two `role=slider` thumbs sharing one rail, each bounded by its neighbour so
+ * they cannot cross. Verified against `specs/apg/slider-multithumb.qnt` by the
+ * differential walk in `test/slider-multithumb.browser.test.tsx`.
+ *
+ * Native / polyfill / hybrid / library: **library** — the Open UI
+ * `<rangegroup>` is an explainer only, so the library owns the behaviour
+ * (neighbour-bounded thumbs, constant tab order). The spec generalises the bound
+ * rule to N thumbs; Quint has no list state, so this primitive fixes two, like
+ * the spec.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the pair. The pair is packed into a
+ * string so it rides the scalar `createControllable`.
+ *
+ * ponytail: dragging and nearest-thumb rail presses are not modelled — the spec
+ * omits them (the event names the thumb).
+ */
+export declare const createSliderMultiThumb: (options?: SliderMultiThumbOptions) => SliderMultiThumb;
+//#endregion
+//#region src/spinbutton.d.ts
+export interface SpinbuttonOptions {
+  readonly min?: number;
+  readonly max?: number;
+  /** Small step: Up / Down Arrow and the buttons. */
+  readonly step?: number;
+  /** Large step: Page Up / Page Down. */
+  readonly largeStep?: number;
+  /** Controlled: the host owns the value and this is the only thing that changes it. */
+  readonly value?: number | undefined;
+  /** Starting value when uncontrolled; ignored while `value` is set. */
+  readonly defaultValue?: number;
+  /** Wrap around at the bounds instead of clamping. */
+  readonly wrap?: boolean;
+  /** Base for the generated input / button ids. */
+  readonly id?: string;
+  /**
+   * A request to change the value, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (value: number) => void;
+}
+export interface SpinbuttonInputProps {
+  readonly id: string;
+  readonly role: "spinbutton";
+  readonly "aria-valuenow": string;
+  readonly "aria-valuemin": string;
+  readonly "aria-valuemax": string;
+  readonly "aria-valuetext": string;
+  readonly "aria-invalid": "true" | undefined;
+  readonly tabindex: number;
+  readonly value: string;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onInput: (event: InputEvent) => void;
+}
+export interface SpinbuttonButtonProps {
+  readonly role: "button";
+  readonly tabindex: number;
+  readonly "aria-label": string;
+  readonly "aria-disabled": "true" | undefined;
+  readonly onMouseDown: (event: MouseEvent) => void;
+  readonly onClick: () => void;
+}
+export interface Spinbutton {
+  readonly value: Accessor<number>;
+  readonly focused: Accessor<boolean>;
+  readonly editing: Accessor<boolean>;
+  readonly draft: Accessor<string>;
+  /** What the text field shows: the draft while editing, else the value. */
+  readonly displayed: Accessor<string>;
+  readonly setValue: (value: number) => void;
+  readonly focus: () => void;
+  readonly blur: () => void;
+  /** Returns whether the key was consumed (the caller preventDefaults it). */
+  readonly keyDown: (key: string) => boolean;
+  /** Replaces the uncommitted draft (Base UI's "change"); needs focus. */
+  readonly typeInput: (text: string) => void;
+  readonly commit: () => void;
+  readonly revert: () => void;
+  readonly increment: () => void;
+  readonly decrement: () => void;
+  readonly setWrap: (wrap: boolean) => void;
+  readonly inputProps: SpinbuttonInputProps;
+  readonly incrementProps: SpinbuttonButtonProps;
+  readonly decrementProps: SpinbuttonButtonProps;
+}
+/**
+ * APG Spinbutton (https://www.w3.org/WAI/ARIA/apg/patterns/spinbutton/): a text
+ * field plus increase / decrease buttons. Plain Solid signals, no elements, no
+ * styling; verified against `specs/apg/spinbutton.qnt` by the differential walk
+ * in `test/spinbutton.browser.test.tsx`.
+ *
+ * Native / polyfill / hybrid / library: **native** (`<input type=number>`) for
+ * the clamping model; this primitive is the **hybrid** `role=spinbutton` text
+ * field for the APG extras the native control lacks — Home/End jump to the
+ * bounds, Page Up/Down use the large step, and a typed draft commits on
+ * Enter/blur or reverts on Escape.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the committed value. Spin keys, the
+ * stepper buttons, Enter and blur are requests the host may ignore; typing and
+ * Escape change no committed value.
+ *
+ * ponytail: commit/revert on Enter/blur/Escape is the common convention, not
+ * APG text.
+ */
+export declare const createSpinbutton: (options?: SpinbuttonOptions) => Spinbutton;
+//#endregion
+//#region src/switch.d.ts
+export interface SwitchOptions {
+  /** Controlled: the host owns the state and this is the only thing that changes it. */
+  readonly value?: boolean | undefined;
+  /** Uncontrolled starting state; ignored while `value` is set. */
+  readonly defaultValue?: boolean;
+  readonly disabled?: boolean;
+  readonly readOnly?: boolean;
+  /** The APG's optional Enter key also flips the switch. */
+  readonly enterToggles?: boolean;
+  readonly id?: string;
+  /**
+   * A request to change the state, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (checked: boolean) => void;
+}
+/** Spread onto the focusable element with `role=switch`. */
+export interface SwitchProps {
+  readonly role: "switch";
+  readonly "aria-checked": "true" | "false";
+  readonly "aria-disabled": "true" | undefined;
+  readonly "aria-readonly": "true" | undefined;
+  readonly tabindex: 0;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onKeyUp: (event: KeyboardEvent) => void;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+export interface Switch {
+  readonly checked: Accessor<boolean>;
+  readonly disabled: Accessor<boolean>;
+  readonly readOnly: Accessor<boolean>;
+  readonly enterToggles: Accessor<boolean>;
+  readonly focused: Accessor<boolean>;
+  /** Programmatic state change; a request the host may ignore. */
+  readonly setChecked: (checked: boolean) => void;
+  readonly setDisabled: (value: boolean) => void;
+  readonly setEnterToggles: (value: boolean) => void;
+  readonly toggle: () => void;
+  readonly switchProps: SwitchProps;
+}
+/**
+ * APG Switch (https://www.w3.org/WAI/ARIA/apg/patterns/switch/): a binary on/off
+ * input. Platform choice (docs/research/apg-platform-features.md): **native
+ * `<input type=checkbox switch>`** as progressive enhancement (Safari only),
+ * with checkbox + `role=switch` as the safe baseline; this primitive exposes
+ * the `role=switch` + `aria-checked` contract. Space arms on keydown and fires
+ * on keyup; Enter flips only when `enterToggles`.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default (`defaultValue`);
+ * pass `value` + `onValueChange` to own the state.
+ */
+export declare const createSwitch: (options?: SwitchOptions) => Switch;
+//#endregion
+//#region src/tabs.d.ts
+export type TabsOrientation = "horizontal" | "vertical";
+export type TabsActivation = "automatic" | "manual";
+/**
+ * Options are read lazily (getters) so `orientation` / `activation` /
+ * `disabled` stay reactive; pass a component's `props`.
+ */
+export interface TabsOptions {
+  /** Number of tabs (needed for wrapping). */
+  readonly items?: number;
+  /** Controlled: the host owns the selection and this is the only thing that changes it. */
+  readonly value?: number | undefined;
+  /** Uncontrolled starting selection; ignored while `value` is set. */
+  readonly defaultSelected?: number;
+  readonly orientation?: TabsOrientation;
+  readonly activation?: TabsActivation;
+  /** Tab indices that cannot be selected. */
+  readonly disabled?: ReadonlyArray<number>;
+  /** Panels that already hold focusable content (no `tabindex` needed). */
+  readonly focusablePanels?: ReadonlyArray<number>;
+  /** Base for the generated ids. */
+  readonly id?: string;
+  /**
+   * A request to change the selection, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (index: number) => void;
+}
+/** Spread onto the element with `role=tab` (a native `<button>`). */
+export interface TabProps {
+  readonly id: string;
+  readonly role: "tab";
+  readonly "aria-selected": "true" | "false";
+  readonly "aria-controls": string;
+  readonly "aria-disabled": "true" | undefined;
+  readonly tabindex: 0 | -1;
+  readonly onClick: () => void;
+  readonly onMouseDown: (event: MouseEvent) => void;
+  readonly onFocus: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+/** Spread onto the element with `role=tablist`. */
+export interface TablistProps {
+  readonly role: "tablist";
+  readonly "aria-orientation": "vertical" | undefined;
+}
+/** Spread onto the element with `role=tabpanel`. */
+export interface TabpanelProps {
+  readonly id: string;
+  readonly role: "tabpanel";
+  readonly "aria-labelledby": string;
+  readonly tabindex: 0 | undefined;
+  readonly hidden: boolean;
+}
+export interface Tabs {
+  readonly items: number;
+  readonly selected: Accessor<number>;
+  /** Tab holding (or last holding) DOM focus; -1 when focus is outside. */
+  readonly focused: Accessor<number>;
+  /** Programmatic selection request; ignores disabled tabs. */
+  readonly select: (index: number) => void;
+  /** Programmatic selection request (may point at a disabled tab, like base-ui). */
+  readonly setSelected: (index: number) => void;
+  /** Programmatic focus (does not select). */
+  readonly focusTab: (index: number) => void;
+  readonly keyDown: (key: string) => void;
+  readonly tablistProps: TablistProps;
+  readonly tabProps: (index: number) => TabProps;
+  readonly tabpanelProps: (index: number) => TabpanelProps;
+}
+/**
+ * APG Tabs (https://www.w3.org/WAI/ARIA/apg/patterns/tabs/): state plus prop
+ * objects for a tablist, tabs and panels. Roving tabindex, wrapping arrows,
+ * Home/End, automatic vs manual activation and disabled-tab skipping; no
+ * styling, no elements. Checked against `specs/apg/tabs.qnt` by the scenario
+ * bridge, not by running the generated machine here.
+ *
+ * Platform: **hybrid** — focusgroup `tablist` owns arrows/wrap/tab stop; the
+ * library owns selection, activation mode and panel visibility.
+ *
+ * Request/commit (map ticket `rt1p`): uncontrolled by default
+ * (`defaultSelected`); pass `value` + `onValueChange` to own the selection.
+ * Programmatic methods (`select`, `setSelected`, `keyDown`) are requests too.
+ */
+export declare const createTabs: (options?: TabsOptions) => Tabs;
+//#endregion
+//#region src/timeline.d.ts
+/**
+ * APG has no waterfall pattern. This is the span timeline the o11y dashboard
+ * needs: spans laid out on a shared tick axis with nesting/indentation, a
+ * duration ruler, single selection, per-parent collapse and a zoom window.
+ *
+ * State plus attribute objects, no elements, no styling. Behaviour is checked
+ * against `specs/apg/timeline.qnt` by the scenario bridge, not by running the
+ * generated machine here.
+ *
+ * Request/commit (map ticket `rt1p`): the selected row is the value. It is
+ * uncontrolled by default (`defaultValue` / `defaultSelected`); pass `value` +
+ * `onValueChange` to own it. `select`, a click and Enter are requests the host
+ * may ignore. The zoom window (`viewStart`/`viewEnd`) is not the controlled
+ * value and stays uncontrolled.
+ *
+ * ponytail: the fixed 5-span tree is a demo fixture; a real consumer owns the
+ * span list (layout is theirs). Roving tabindex only — a consumer must call
+ * `focus()` on the row whose `tabindex` is 0 after arrow navigation (the tests'
+ * fixture does this with an effect).
+ */
+/** One span row: a fraction of the parent span on a shared 0..1 axis. */
+export interface TimelineRow {
+  readonly id: number;
+  readonly level: number;
+  readonly parent: number;
+  readonly start: number;
+  readonly end: number;
+  /** A parent whose children are hidden. */
+  readonly collapsed: boolean;
+}
+export interface TimelineOptions {
+  /** Node ids whose children start expanded. */
+  readonly defaultExpanded?: ReadonlyArray<number>;
+  /** Controlled: the host owns the selection and this is the only thing that changes it. */
+  readonly value?: number | undefined;
+  /** Uncontrolled starting selection (0 = none); alias of `defaultSelected`. */
+  readonly defaultValue?: number;
+  /** Initially selected node id (0 = none). */
+  readonly defaultSelected?: number;
+  readonly viewStart?: number;
+  readonly viewEnd?: number;
+  /** Base for generated ids. */
+  readonly id?: string;
+  /**
+   * A request to change the selection, called when the intent differs from the
+   * current value. Uncontrolled it is accepted; controlled the host may ignore it.
+   */
+  readonly onValueChange?: (id: number) => void;
+  /** Alias of `onValueChange`. */
+  readonly onSelectedChange?: (id: number) => void;
+}
+export interface TimelineTreeProps {
+  readonly role: "tree";
+  readonly "aria-label": string;
+  readonly "aria-multiselectable": "false";
+}
+export interface TimelineRowProps {
+  readonly role: "treeitem";
+  readonly "aria-level": number;
+  /** Absent on leaves, like treeview's aria-expanded. */
+  readonly "aria-expanded": "true" | "false" | undefined;
+  readonly "aria-selected": "true" | "false";
+  readonly tabindex: number;
+  readonly hidden: boolean;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+/** The zoom window as a slider over the fixed 0..100 tick domain. */
+export interface TimelineRulerProps {
+  readonly role: "slider";
+  readonly "aria-label": string;
+  readonly "aria-valuemin": number;
+  readonly "aria-valuenow": number;
+  readonly "aria-valuemax": number;
+}
+export interface Timeline {
+  readonly rows: () => ReadonlyArray<TimelineRow>;
+  readonly zoom: () => {
+    readonly start: number;
+    readonly end: number;
+  };
+  readonly selected: Accessor<number>;
+  readonly focus: () => number;
+  readonly hasFocus: () => boolean;
+  /** Programmatic selection request; a controlled host may ignore it. */
+  readonly select: (id: number) => void;
+  readonly setFocus: (id: number) => void;
+  readonly expand: (id: number) => void;
+  readonly collapse: (id: number) => void;
+  readonly toggle: (id: number) => void;
+  readonly zoomIn: () => void;
+  readonly zoomOut: () => void;
+  readonly zoomReset: () => void;
+  readonly panLeft: () => void;
+  readonly panRight: () => void;
+  readonly treeProps: TimelineTreeProps;
+  readonly rowProps: (id: number) => TimelineRowProps;
+  readonly rulerProps: TimelineRulerProps;
+}
+/**
+ * Headless span timeline on Solid 2. The exported accessors are signals; the
+ * prop objects are getter-backed, so spreading them keeps every attribute
+ * reactive.
+ */
+export declare const createTimeline: (options?: TimelineOptions) => Timeline;
+//#endregion
+//#region src/toolbar.d.ts
+/**
+ * APG Toolbar on Solid 2: state plus attribute objects, no elements, no
+ * styling. A faithful transcription of `specs/apg/toolbar.qnt`.
+ *
+ * Platform: **polyfill** (map ticket `etfq`). The roving tabindex is the
+ * `focusgroup="toolbar"` contract (see `shared/focusgroup.qnt`); ship the
+ * `@microsoft/focusgroup-polyfill` first and switch to the native attribute
+ * when Chrome/Edge is the floor. The library owns only the spec's delta:
+ * `aria-orientation`, the wrap choice, disabled-but-focusable items, embedded
+ * controls that consume keys, and activation.
+ *
+ * ponytail: item count and kinds come from the constructor; separators, RTL and
+ * the embedded controls' own values are not modelled. Add them when a consumer
+ * needs them.
+ */
+export type ToolbarOrientation = "horizontal" | "vertical";
+export type ToolbarItemKind = "button" | "text" | "spin";
+export interface ToolbarItemInput {
+  readonly label: string;
+  readonly kind?: ToolbarItemKind;
+  readonly disabled?: boolean;
+}
+export interface ToolbarOptions {
+  readonly items: ReadonlyArray<string | ToolbarItemInput>;
+  readonly kinds?: ReadonlyArray<ToolbarItemKind>;
+  readonly orientation?: ToolbarOrientation;
+  readonly wrap?: boolean;
+  readonly defaultFocus?: number;
+  /** Item indices disabled at mount (aria-disabled, still focusable). */
+  readonly disabled?: ReadonlyArray<number>;
+  readonly id?: string;
+  readonly onActivate?: (index: number) => void;
+}
+export interface ToolbarItem {
+  readonly id: string;
+  readonly label: string;
+  readonly kind: ToolbarItemKind;
+  readonly disabled: boolean;
+}
+export interface ToolbarItemProps {
+  readonly id: string;
+  readonly role: "button";
+  readonly "aria-disabled": "true" | undefined;
+  readonly tabindex: 0 | -1;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+}
+export interface Toolbar {
+  readonly focus: Accessor<number>;
+  readonly tabStop: Accessor<number>;
+  readonly orientation: Accessor<ToolbarOrientation>;
+  readonly wrap: Accessor<boolean>;
+  readonly items: ReadonlyArray<ToolbarItem>;
+  readonly focusIn: () => void;
+  readonly leave: () => void;
+  readonly focusItem: (index: number) => void;
+  readonly keyDown: (key: string) => void;
+  readonly tab: (back: boolean) => void;
+  readonly clickItem: (index: number) => void;
+  readonly activate: () => void;
+  readonly toggleDisabled: (index: number) => void;
+  readonly setOrientation: (orientation: ToolbarOrientation) => void;
+  readonly setWrap: (wrap: boolean) => void;
+  readonly toolbarProps: {
+    readonly role: "toolbar";
+    readonly "aria-orientation": ToolbarOrientation;
+    readonly onKeyDown: (event: KeyboardEvent) => void;
+  };
+  readonly itemProps: (index: number) => ToolbarItemProps;
+}
+export declare const createToolbar: (options: ToolbarOptions) => Toolbar;
+//#endregion
+//#region src/tooltip.d.ts
+export interface TooltipTriggerInput {
+  readonly id?: string;
+  /** Id of this trigger's tooltip element (needed for `aria-describedby`). */
+  readonly tooltipId?: string;
+  readonly label?: string;
+}
+export interface TooltipGroupOptions {
+  readonly triggers: ReadonlyArray<TooltipTriggerInput>;
+  /** Ignore focus / pointer entirely while disabled. */
+  readonly disabled?: boolean;
+  /** Keyboard focus opens the tooltip immediately (the host has applied its show delay). */
+  readonly openOnFocus?: boolean;
+  /** Hover opens the tooltip immediately (a `delay: 0` configuration). */
+  readonly openOnHover?: boolean;
+  /**
+   * Whether native pointerenter/pointerleave on the rendered elements drive the
+   * state. Disable for a host that feeds `pointerEnter`/`pointerLeave` itself
+   * (the differential walk does), so a stray pointer sitting over the fixture
+   * cannot inject events the other side never saw. @default true
+   */
+  readonly nativePointer?: boolean;
+  /** Trigger index whose tooltip starts visible (`defaultOpen`). */
+  readonly defaultOpen?: number;
+  /**
+   * Controlled: the host owns the visible tooltip. `0` = none, `1` = first,
+   * `2` = second (`undefined` = uncontrolled).
+   */
+  readonly value?: number | undefined;
+  /** A request to change the visible tooltip when the intent differs. */
+  readonly onOpenChange?: (open: boolean, index: number) => void;
+  /**
+   * Structural mirror of `ing.lexicon.ui.prefs` (`./prefs`). Honoured here:
+   * `tooltipShowDelayMs` / `tooltipHideDelayMs`, exposed as accessors the host
+   * wires its `setTimeout` from. Absent prefs keep the defaults.
+   */
+  readonly prefs?: Partial<Prefs> | undefined;
+}
+export interface TooltipTriggerProps {
+  readonly id: string;
+  readonly "aria-describedby": string | undefined;
+  readonly onFocus: () => void;
+  readonly onPointerEnter: () => void;
+  readonly onPointerLeave: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface TooltipContentProps {
+  readonly id: string;
+  readonly role: "tooltip";
+  readonly hidden: boolean;
+  readonly onPointerEnter: () => void;
+  readonly onPointerLeave: () => void;
+}
+export interface TooltipGroup {
+  /** Index of the visible tooltip, or `null`. */
+  readonly visibleIndex: Accessor<number | null>;
+  /** Resolved show delay (ms) the host wires its `setTimeout` from. */
+  readonly showDelayMs: Accessor<number>;
+  /** Resolved hide delay (ms) the host wires its `setTimeout` from. */
+  readonly hideDelayMs: Accessor<number>;
+  readonly described: (index: number) => boolean;
+  readonly triggerProps: (index: number) => TooltipTriggerProps;
+  readonly tooltipProps: (index: number) => TooltipContentProps;
+  readonly focusTrigger: (index: number) => void;
+  readonly blur: () => void;
+  readonly pointerEnter: (index: number) => void;
+  readonly pointerEnterTip: () => void;
+  readonly pointerLeave: () => void;
+  readonly showTimer: (index: number) => void;
+  readonly hideTimer: () => void;
+  readonly escape: () => void;
+  readonly warmExpire: () => void;
+  readonly setWarmup: (on: boolean) => void;
+  /**
+   * Call before the host writes the controlled visible value directly: it drops
+   * the timer / dismissal memory the new value invalidates (mirrors the spec's
+   * `setValue`).
+   */
+  readonly hostSet: (vis: number) => void;
+  /**
+   * Call before the host flips its controlled value between none and the first
+   * tooltip directly (mirrors the spec's `hostToggle`, which also drops B).
+   */
+  readonly hostToggle: () => void;
+}
+/**
+ * APG Tooltip + WCAG 1.4.13 (dismissable, hoverable, persistent) on Solid 2.
+ * Two triggers stand in for N (`ponytail:` a pair is all the spec models). The
+ * state machine mirrors `specs/apg/tooltip.qnt`: timers are **events**, not
+ * clocks — the host wires `setTimeout` to `showTimer` / `hideTimer` /
+ * `warmExpire`.
+ *
+ * Request/commit (map ticket `rt1p`): the visible tooltip is the controlled
+ * value (0 none / 1 first / 2 second). Uncontrolled by default (`defaultOpen`);
+ * pass `value` + `onOpenChange` to own it. The non-visible state (focus,
+ * pointer, pending timers) still tracks every event; only the visible commit is
+ * gated, so a rejected request leaves the visible tooltip untouched.
+ */
+export declare const createTooltipGroup: (options: TooltipGroupOptions) => TooltipGroup;
+//#endregion
+//#region src/treegrid.d.ts
+/**
+ * APG treegrid primitive on Solid 2: a fixed tree of rows, row/cell roving focus
+ * across the three APG navigation models, expansion and row selection. State plus
+ * getter-backed attribute objects; no elements, no styling.
+ *
+ * Mirrors `specs/apg/treegrid.qnt` (the Email Inbox tree: A > {A.1, A.2 >
+ * {A.2.1}}, B > {B.1, B.2}); the generated machine is the oracle in tests.
+ */
+export type TreegridNav = "rowsFirst" | "cellsFirst" | "cellsOnly";
+export type TreegridSelection = "single" | "multi";
+export interface TreegridOptions {
+  readonly nav?: TreegridNav;
+  readonly selection?: TreegridSelection;
+  /** Column count; the spec fixes three. */
+  readonly cols?: number;
+  /** Controlled: the host owns the selected rows and this is the only thing that changes them. */
+  readonly value?: ReadonlyArray<number> | undefined;
+  /** Uncontrolled starting selected rows; ignored while `value` is set. */
+  readonly defaultValue?: ReadonlyArray<number>;
+  /** Base for generated ids. */
+  readonly id?: string;
+  /**
+   * A request to change the selected rows, called when the intent differs from
+   * the current value. Uncontrolled it is accepted; controlled the host may
+   * ignore it.
+   */
+  readonly onValueChange?: (selected: ReadonlyArray<number>) => void;
+}
+export interface TreegridProps {
+  readonly role: "treegrid";
+  readonly "aria-multiselectable": "true" | undefined;
+  readonly onFocusOut: (event: FocusEvent) => void;
+}
+export interface TreegridRowProps {
+  readonly role: "row";
+  readonly id: string;
+  readonly "aria-level": number;
+  readonly "aria-setsize": number;
+  readonly "aria-posinset": number;
+  readonly "aria-expanded": "true" | "false" | undefined;
+  readonly "aria-selected": "true" | "false" | undefined;
+  readonly tabindex: number;
+  readonly onFocus: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface TreegridCellProps {
+  readonly role: "gridcell";
+  readonly id: string;
+  readonly tabindex: number;
+  readonly onClick: () => void;
+  readonly onFocus: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface TreegridExpanderProps {
+  readonly role: "button";
+  readonly "aria-label": "Expand" | "Collapse";
+  readonly "aria-expanded": "true" | "false";
+  readonly onMouseDown: (event: MouseEvent) => void;
+  readonly onClick: (event: MouseEvent) => void;
+}
+export interface Treegrid {
+  readonly rows: Accessor<number>;
+  readonly cols: Accessor<number>;
+  readonly nav: Accessor<TreegridNav>;
+  readonly selection: Accessor<TreegridSelection>;
+  readonly focusedRow: Accessor<number>;
+  readonly focusedCol: Accessor<number>;
+  readonly kind: Accessor<"row" | "cell">;
+  readonly inGrid: Accessor<boolean>;
+  readonly visible: (row: number) => boolean;
+  readonly hasChildren: (row: number) => boolean;
+  readonly isExpanded: (row: number) => boolean;
+  readonly isSelected: (row: number) => boolean;
+  readonly focusTargetPart: Accessor<string | null>;
+  readonly gridProps: TreegridProps;
+  readonly rowProps: (row: number) => TreegridRowProps;
+  readonly cellProps: (row: number, col: number) => TreegridCellProps;
+  readonly expanderProps: (row: number) => TreegridExpanderProps;
+  readonly focus: () => void;
+  readonly blur: () => void;
+  readonly clickCell: (row: number, col: number) => void;
+  readonly toggleRow: (row: number) => void;
+  readonly configureNav: (nav: TreegridNav) => void;
+  readonly configureSelection: (selection: TreegridSelection) => void;
+  readonly setExpanded: (row: number, expanded: boolean) => void;
+}
+export declare const treegridRowPart: (row: number) => string;
+export declare const treegridCellPart: (row: number, col: number) => string;
+export declare const createTreegrid: (options?: TreegridOptions) => Treegrid;
+/** The `data-part` target the treegrid roving tab stop should focus. */
+export declare const treegridFocusTargetPart: (grid: Treegrid) => string | null;
+//#endregion
+//#region src/treeview.d.ts
+/** A tree node: `parent` is 0 for a root; order in `nodes` is document order. */
+export interface TreeviewNode {
+  readonly id: number;
+  readonly parent: number;
+  readonly label: string;
+}
+/**
+ * The fixed tree of `specs/apg/treeview.qnt` (ids are pre-order = document
+ * order): 1 Projects > {2 Reports > {3 Roadmap, 4 Summary}, 5 Notes}, 6 Photos
+ * > {7 Trip}.
+ */
+export declare const TREEVIEW_NODES: ReadonlyArray<TreeviewNode>;
+export interface TreeviewOptions {
+  readonly nodes?: ReadonlyArray<TreeviewNode>;
+  readonly multiSelectable?: boolean;
+  /** Controlled: the host owns the selected node ids and this is the only thing that changes them. */
+  readonly value?: ReadonlyArray<number> | undefined;
+  /** Uncontrolled starting selected node ids; ignored while `value` is set. */
+  readonly defaultValue?: ReadonlyArray<number>;
+  /** Expanded node ids at mount. */
+  readonly defaultExpanded?: ReadonlyArray<number>;
+  /** Selected node ids at mount (an alias for `defaultValue`). */
+  readonly defaultSelected?: ReadonlyArray<number>;
+  /** Roving-tabindex node id at mount. */
+  readonly defaultFocus?: number;
+  readonly label?: string;
+  readonly orientation?: "vertical" | "horizontal";
+  /** Fires for each node whose expanded state changed, in document order. */
+  readonly onExpandedChange?: (node: TreeviewNode) => void;
+  /** Fires for each node that becomes selected. */
+  readonly onSelectionChange?: (node: TreeviewNode) => void;
+  /**
+   * A request to change the selected node ids, called when the intent differs
+   * from the current value. Uncontrolled it is accepted; controlled the host may
+   * ignore it.
+   */
+  readonly onValueChange?: (selected: ReadonlyArray<number>) => void;
+  /** Enter's default action. */
+  readonly onActivate?: (node: TreeviewNode) => void;
+}
+/** Spread onto the element with `role=tree`. */
+export interface TreeviewTreeProps {
+  readonly role: "tree";
+  readonly "aria-multiselectable": "true" | "false";
+  readonly "aria-label": string | undefined;
+  readonly "aria-orientation": "horizontal" | undefined;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onFocusIn: () => void;
+  readonly onFocusOut: (event: FocusEvent) => void;
+}
+/** Spread onto the element with `role=treeitem` for `id`. */
+export interface TreeviewItemProps {
+  readonly role: "treeitem";
+  readonly "aria-level": number;
+  readonly "aria-setsize": number;
+  readonly "aria-posinset": number;
+  readonly "aria-expanded": "true" | "false" | undefined;
+  readonly "aria-selected": "true" | "false";
+  readonly tabindex: number;
+  readonly hidden: boolean;
+  readonly onClick: () => void;
+}
+export interface Treeview {
+  readonly nodeIds: Accessor<ReadonlyArray<number>>;
+  readonly expanded: Accessor<ReadonlyArray<number>>;
+  readonly selected: Accessor<ReadonlyArray<number>>;
+  readonly focus: Accessor<number>;
+  readonly hasFocus: Accessor<boolean>;
+  readonly isExpanded: (id: number) => boolean;
+  readonly isSelected: (id: number) => boolean;
+  readonly isVisible: (id: number) => boolean;
+  readonly isParent: (id: number) => boolean;
+  readonly expand: (id: number) => void;
+  readonly collapse: (id: number) => void;
+  readonly toggleExpanded: (id: number) => void;
+  readonly select: (id: number) => void;
+  readonly toggleSelected: (id: number) => void;
+  /** Models the type-ahead timeout. */
+  readonly resetTypeahead: () => void;
+  /** Getter-backed, so spreading it keeps every attribute reactive. */
+  readonly treeProps: TreeviewTreeProps;
+  readonly itemProps: (id: number) => TreeviewItemProps;
+}
+/**
+ * APG Tree View (https://www.w3.org/WAI/ARIA/apg/patterns/treeview/): state
+ * plus attribute objects for a `tree` and its `treeitem`s. No styling, no
+ * elements. Behaviour is checked against `specs/apg/treeview.qnt` by the
+ * scenario bridge and the differential walk, not by running the generated
+ * machine here.
+ *
+ * ponytail: the buffer is capped at two characters and its timeout is the
+ * explicit `resetTypeahead` method; add a timer when a consumer wants one.
+ */
+export declare const createTreeview: (options?: TreeviewOptions) => Treeview;
+//#endregion
+//#region src/windowsplitter.d.ts
+export type SplitterOrientation = "vertical" | "horizontal";
+export type SplitterFocus = "none" | "splitter" | "primary" | "secondary";
+/** Options are read lazily: pass an object with getters, never destructured values. */
+export interface WindowSplitterOptions {
+  readonly orientation?: SplitterOrientation;
+  readonly fixed?: boolean;
+  /** Controlled: the host owns the primary-pane size. */
+  readonly value?: number | undefined;
+  /** Uncontrolled starting size (`defaultValue`); ignored while `value` is set. */
+  readonly defaultValue?: number;
+  readonly min?: number;
+  readonly max?: number;
+  readonly step?: number;
+  /** Base for the generated separator / pane ids. */
+  readonly id?: string;
+  readonly primaryId?: string;
+  /** Accessible name of the separator when no visible primary label exists. */
+  readonly label?: string | undefined;
+  /** Id of the visible primary-pane label, referenced by `aria-labelledby`. */
+  readonly labelledby?: string | undefined;
+  /** A request to change the size the host may ignore. */
+  readonly onValueChange?: (value: number) => void;
+  readonly onCollapsedChange?: (collapsed: boolean) => void;
+}
+/** Spread onto the focusable `role=separator` bar. */
+export interface WindowSplitterSeparatorProps {
+  readonly id: string;
+  readonly role: "separator";
+  readonly "aria-orientation": SplitterOrientation;
+  readonly "aria-valuenow": number;
+  readonly "aria-valuemin": number;
+  readonly "aria-valuemax": number;
+  readonly "aria-controls": string;
+  readonly "aria-label": string | undefined;
+  readonly "aria-labelledby": string | undefined;
+  readonly tabindex: 0;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+/** Spread onto a pane the F6 cycle can move focus to. */
+export interface WindowSplitterPaneProps {
+  readonly tabindex: 0;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+}
+export interface WindowSplitter {
+  readonly value: Accessor<number>;
+  readonly collapsed: Accessor<boolean>;
+  readonly focusPart: Accessor<SplitterFocus>;
+  readonly focusSeparator: () => void;
+  readonly setFocusPart: (part: SplitterFocus) => void;
+  readonly keyDown: (key: string) => void;
+  /**
+   * Call before the host writes the controlled `value` directly: it pins the
+   * derived collapse state so the write does not silently uncollapse (or
+   * collapse) the pane.
+   */
+  readonly freezeCollapse: () => void;
+  readonly collapse: () => void;
+  readonly expand: () => void;
+  readonly separatorProps: WindowSplitterSeparatorProps;
+  readonly primaryProps: WindowSplitterPaneProps;
+  readonly secondaryProps: WindowSplitterPaneProps;
+}
+/**
+ * APG Window Splitter (https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/):
+ * a focusable `role=separator` resizing the primary pane.
+ *
+ * Request/commit (map ticket `rt1p`): the primary-pane size is the value.
+ * Uncontrolled by default (`defaultValue`); pass `value` + `onValueChange` to
+ * own it. Movement keys are requests the host may ignore. While controlled a
+ * collapse is only committed once the host's value reaches the target, so
+ * `collapsed` is derived from the controlled value plus the last request.
+ */
+export declare const createWindowSplitter: (options?: WindowSplitterOptions) => WindowSplitter;
+//#endregion
+//#region src/listbox-rearrangeable.d.ts
+export type RearrangeableList = "a" | "b";
+export interface RearrangeableListboxOptions {
+  /** Option labels; the option id is the index, and every option starts in list A. */
+  readonly items: ReadonlyArray<string>;
+  /** Multi-select (APG example 2): Space toggles, Enter/Delete transfer the selected. */
+  readonly multi?: boolean;
+  /** Controlled selection (option ids); the host owns it. */
+  readonly value?: ReadonlyArray<number> | undefined;
+  readonly defaultValue?: ReadonlyArray<number>;
+  readonly id?: string;
+  readonly labels?: Readonly<Record<RearrangeableList, string>>;
+  /** A request to change the selection; uncontrolled it is accepted. */
+  readonly onValueChange?: (selected: ReadonlyArray<number>) => void;
+}
+export interface RearrangeableListProps {
+  readonly role: "listbox";
+  readonly tabindex: 0;
+  readonly "aria-multiselectable": "true" | "false";
+  readonly "aria-activedescendant": string | undefined;
+  readonly "aria-label": string | undefined;
+  readonly onFocus: () => void;
+  readonly onBlur: () => void;
+  readonly onKeyDown: (event: KeyboardEvent) => void;
+}
+export interface RearrangeableOptionProps {
+  readonly id: string;
+  readonly role: "option";
+  readonly "aria-selected": "true" | "false";
+  readonly onClick: () => void;
+}
+export interface RearrangeableListbox {
+  readonly items: ReadonlyArray<string>;
+  /** The option ids a list holds, in order. */
+  readonly order: (list: RearrangeableList) => ReadonlyArray<number>;
+  /** A list's active option id, `null` when the list is empty. */
+  readonly active: (list: RearrangeableList) => number | null;
+  readonly focusedList: Accessor<RearrangeableList | null>;
+  readonly selected: Accessor<ReadonlyArray<number>>;
+  readonly multi: Accessor<boolean>;
+  readonly focus: (list: RearrangeableList) => void;
+  readonly blur: () => void;
+  readonly keyDown: (key: string, modifiers?: ListboxModifiers) => void;
+  /** Single-select: swap the focused list's active option with its neighbour. */
+  readonly move: (direction: "up" | "down") => void;
+  /** Move the focused list's selected options to the other list (deselected). */
+  readonly transfer: () => void;
+  readonly setMulti: (flag: boolean) => void;
+  readonly listProps: (list: RearrangeableList) => RearrangeableListProps;
+  readonly optionProps: (optionId: number) => RearrangeableOptionProps;
+}
+/**
+ * APG rearrangeable listbox (two lists sharing one option set) on Solid 2,
+ * verified against `specs/apg/listbox-rearrangeable.qnt` by a differential
+ * walk. Single-select: selection follows focus, Alt+Up/Down reorder, Delete
+ * moves the focused option across. Multi-select: Space toggles, Enter/Delete
+ * move every selected option of the focused list across. A transferred option
+ * arrives deselected.
+ *
+ * Controlled, the list surgery of a transfer is gated on the request landing:
+ * it is applied when the `value` prop comes back equal to the intent, so a
+ * host that holds the value moves nothing.
+ */
+export declare const createRearrangeableListbox: (options: RearrangeableListboxOptions) => RearrangeableListbox;
+//#endregion
+export { type Canvas, type CanvasGoal, type CanvasLayerProps, type CanvasLiveRegionProps, type CanvasMessages, type CanvasMode, type CanvasMove, type CanvasNodeGeometry, type CanvasNodeInput, type CanvasNodeProps, type CanvasNodeRole, type CanvasOptions, type CanvasSnapshot, type CanvasViewportProps, type Disclosure, type DisclosureOptions, type DisclosurePanelProps, type DisclosureTriggerProps, type MarqueeMode, NO_POS, type PlaybackAdapter, type PlaybackAdapterEvent, type Player, type PlayerButtonProps, type PlayerOptions, type PlayerPlayProps, type PlayerSeekProps, type PlayerStage, type PlayerSurfaceProps, type PlayerToggleProps, type PointerInput, type SnapAxis, type SnapCandidates, type SnapContext, YES_POS };