stimeo-ui 0.1.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,1931 @@
+import { Controller, Application } from '@hotwired/stimulus';
+import { AccordionController } from './controllers/accordion_controller.js';
+import { AnnouncerController } from './controllers/announcer_controller.js';
+import { AspectRatioController } from './controllers/aspect_ratio_controller.js';
+import { AutoSubmitController } from './controllers/auto_submit_controller.js';
+import { AvatarController } from './controllers/avatar_controller.js';
+import { BreadcrumbController } from './controllers/breadcrumb_controller.js';
+import { BulkSelectController } from './controllers/bulk_select_controller.js';
+import { CalendarController } from './controllers/calendar_controller.js';
+import { CharacterCounterController } from './controllers/character_counter_controller.js';
+import { CheckboxController } from './controllers/checkbox_controller.js';
+import { ComboboxController } from './controllers/combobox_controller.js';
+import { CommandPaletteController } from './controllers/command_palette_controller.js';
+import { ConditionalFieldsController } from './controllers/conditional_fields_controller.js';
+import { ConfirmController } from './controllers/confirm_controller.js';
+import { ContextMenuController } from './controllers/context_menu_controller.js';
+import { CountdownController } from './controllers/countdown_controller.js';
+import { DialogController } from './controllers/dialog_controller.js';
+import { DirectUploadController } from './controllers/direct_upload_controller.js';
+import { DirtyFormController } from './controllers/dirty_form_controller.js';
+import { DropdownController } from './controllers/dropdown_controller.js';
+import { EmptyStateController } from './controllers/empty_state_controller.js';
+import { FlashController } from './controllers/flash_controller.js';
+import { FocusController } from './controllers/focus_controller.js';
+import { FormFieldController } from './controllers/form_field_controller.js';
+import { FormValidationController } from './controllers/form_validation_controller.js';
+import { FrameLoadingController } from './controllers/frame_loading_controller.js';
+import { HighlightController } from './controllers/highlight_controller.js';
+import { HoverCardController } from './controllers/hover_card_controller.js';
+import { IdleController } from './controllers/idle_controller.js';
+import { InputMaskController } from './controllers/input_mask_controller.js';
+import { LazyFrameController } from './controllers/lazy_frame_controller.js';
+import { ListboxController } from './controllers/listbox_controller.js';
+import { LocalTimeController } from './controllers/local_time_controller.js';
+import { MenuController } from './controllers/menu_controller.js';
+import { MeterController } from './controllers/meter_controller.js';
+import { NestedFormController } from './controllers/nested_form_controller.js';
+import { NetworkStatusController } from './controllers/network_status_controller.js';
+import { NumberInputController } from './controllers/number_input_controller.js';
+import { OtpController } from './controllers/otp_controller.js';
+import { OverflowIndicatorController } from './controllers/overflow_indicator_controller.js';
+import { OverflowMenuController } from './controllers/overflow_menu_controller.js';
+import { PaginationController } from './controllers/pagination_controller.js';
+import { PasswordStrengthController } from './controllers/password_strength_controller.js';
+import { PersistController } from './controllers/persist_controller.js';
+import { PopoverController } from './controllers/popover_controller.js';
+import { PortalController } from './controllers/portal_controller.js';
+import { PreviewGuardController } from './controllers/preview_guard_controller.js';
+import { ProgressController } from './controllers/progress_controller.js';
+import { RadioGroupController } from './controllers/radio_group_controller.js';
+import { RatingController } from './controllers/rating_controller.js';
+import { RelativeTimeController } from './controllers/relative_time_controller.js';
+import { ResetBeforeCacheController } from './controllers/reset_before_cache_controller.js';
+import { ResizableController } from './controllers/resizable_controller.js';
+import { RovingController } from './controllers/roving_controller.js';
+import { ScrollAreaController } from './controllers/scroll_area_controller.js';
+import { ScrollVisibilityController } from './controllers/scroll_visibility_controller.js';
+import { ScrollspyController } from './controllers/scrollspy_controller.js';
+import { SkeletonController } from './controllers/skeleton_controller.js';
+import { SliderController } from './controllers/slider_controller.js';
+import { SpinnerController } from './controllers/spinner_controller.js';
+import { StepIndicatorController } from './controllers/step_indicator_controller.js';
+import { StepperController } from './controllers/stepper_controller.js';
+import { StickToBottomController } from './controllers/stick_to_bottom_controller.js';
+import { StickyObserverController } from './controllers/sticky_observer_controller.js';
+import { SubmitOnceController } from './controllers/submit_once_controller.js';
+import { SwitchController } from './controllers/switch_controller.js';
+import { TabsController } from './controllers/tabs_controller.js';
+import { TextareaAutosizeController } from './controllers/textarea_autosize_controller.js';
+import { ThemeController } from './controllers/theme_controller.js';
+import { ToastController } from './controllers/toast_controller.js';
+import { ToggleGroupController } from './controllers/toggle_group_controller.js';
+import { ToolbarController } from './controllers/toolbar_controller.js';
+import { TooltipController } from './controllers/tooltip_controller.js';
+import { TransitionController } from './controllers/transition_controller.js';
+
+/**
+ * Headless, accessible **alert dialog** behavior.
+ *
+ * Markup contract (identifier: `stimeo--alert-dialog`):
+ *   <div data-controller="stimeo--alert-dialog">
+ *     <button data-stimeo--alert-dialog-target="trigger"
+ *             data-action="click->stimeo--alert-dialog#open">Delete…</button>
+ *     <div data-stimeo--alert-dialog-target="dialog" role="alertdialog"
+ *          aria-modal="true" aria-labelledby="t" aria-describedby="d" hidden>
+ *       <h2 id="t">…</h2><p id="d">…</p>
+ *       <button data-stimeo--alert-dialog-target="initialFocus"
+ *               data-action="click->stimeo--alert-dialog#cancel">Cancel</button>
+ *       <button data-action="click->stimeo--alert-dialog#confirm">Delete</button>
+ *     </div>
+ *   </div>
+ *
+ * Implements the WAI-ARIA APG **Alert Dialog** pattern. It is the same modal as
+ * `stimeo--dialog` with two deliberate differences that suit an *interrupting
+ * confirmation*: it never closes on a backdrop click (an accidental dismissal
+ * would be dangerous), and it exposes explicit {@link confirm}/{@link cancel}
+ * actions that emit events so the consumer only writes the message and "what to
+ * do on confirm".
+ *
+ * @remarks
+ * Behavior only. The modal lifecycle (focus trap, scroll lock, background
+ * `inert`, focus restore, teardown reversal) is delegated to the shared
+ * {@link FocusTrap}. The only closing affordances are the confirm/cancel actions
+ * and `Escape` (which cancels) — there is intentionally no backdrop close.
+ *
+ * Behavior provided:
+ * - {@link open} shows the dialog and moves focus to the `initialFocus` target
+ *   (the least destructive action, by convention), else the first focusable
+ *   element.
+ * - `Tab`/`Shift+Tab` cycle focus within the dialog (focus trap).
+ * - {@link confirm} closes and dispatches `stimeo--alert-dialog:confirm`.
+ * - {@link cancel} and `Escape` close and dispatch `stimeo--alert-dialog:cancel`
+ *   with a `reason` of `"user"` / `"escape"`. Focus returns to the opener.
+ */
+declare class AlertDialogController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static actions: readonly ["cancel", "confirm", "open"];
+    static events: readonly ["cancel", "confirm"];
+    readonly triggerTarget: HTMLElement;
+    readonly dialogTarget: HTMLElement;
+    readonly initialFocusTarget: HTMLElement;
+    readonly hasTriggerTarget: boolean;
+    readonly hasDialogTarget: boolean;
+    readonly hasInitialFocusTarget: boolean;
+    /** Starts closed (idempotently reflects the closed state on the markup). */
+    connect(): void;
+    /** Reverts the modal side effects if torn down while open (Turbo navigation). */
+    disconnect(): void;
+    /** Opens the dialog, traps focus, and locks background scroll. */
+    open(): void;
+    /** Confirms: closes and dispatches `confirm`. Bound via `data-action`. */
+    confirm(): void;
+    /** Cancels (user action): closes and dispatches `cancel` with `reason: "user"`. */
+    cancel(): void;
+}
+
+/**
+ * Headless, accessible **Carousel** (slideshow) behavior.
+ *
+ * Markup contract (identifier: `stimeo--carousel`):
+ *   <section data-controller="stimeo--carousel" aria-roledescription="carousel"
+ *            aria-label="Featured"
+ *            data-stimeo--carousel-autoplay-value="false"
+ *            data-stimeo--carousel-interval-value="5000"
+ *            data-stimeo--carousel-loop-value="true"
+ *            data-action="mouseenter->stimeo--carousel#pause
+ *                         mouseleave->stimeo--carousel#resume
+ *                         focusin->stimeo--carousel#pause
+ *                         focusout->stimeo--carousel#resume">
+ *     <button data-stimeo--carousel-target="playToggle"
+ *             data-action="stimeo--carousel#togglePlay">…</button>
+ *     <div data-stimeo--carousel-target="viewport">
+ *       <div role="tabpanel" data-stimeo--carousel-target="slide">…</div>
+ *       <div role="tabpanel" data-stimeo--carousel-target="slide" hidden>…</div>
+ *     </div>
+ *     <button data-stimeo--carousel-target="prev" data-action="stimeo--carousel#prev">‹</button>
+ *     <button data-stimeo--carousel-target="next" data-action="stimeo--carousel#next">›</button>
+ *     <div role="tablist">
+ *       <button role="tab" data-stimeo--carousel-target="picker"
+ *               data-action="stimeo--carousel#goto
+ *                            keydown->stimeo--carousel#onPickerKeydown"></button>
+ *     </div>
+ *   </section>
+ *
+ * Implements the WAI-ARIA APG **Carousel** (tabbed) pattern. The current slide is
+ * exposed through `data-state` (`active`/`inactive`) and the `hidden` attribute on
+ * inactive slides (removing them from focus order); the matching picker carries
+ * `aria-selected` and the single roving `tabindex`. The play/pause toggle's
+ * `aria-pressed` mirrors the autoplay state.
+ *
+ * @remarks
+ * Behavior only — transitions, layout, and visuals are the consumer's CSS.
+ * Autoplay honors WCAG 2.2.2: it suspends while the pointer is over the carousel
+ * and **hard-stops** when keyboard focus enters (it does not silently resume on
+ * focus out — the user must press play), so motion never surprises a keyboard
+ * user. The interval is cleared on `disconnect()` (Turbo navigation included).
+ * Picker arrow keys move focus only (manual activation); slide changes never steal
+ * focus from the control the user operated.
+ */
+declare class CarouselController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        autoplay: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        interval: {
+            type: NumberConstructor;
+            default: number;
+        };
+        loop: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    static actions: readonly ["goto", "next", "onPickerKeydown", "pause", "prev", "resume", "togglePlay"];
+    static events: readonly ["change", "pause", "play"];
+    readonly slideTargets: HTMLElement[];
+    readonly pickerTargets: HTMLElement[];
+    readonly playToggleTarget: HTMLElement;
+    readonly hasPlayToggleTarget: boolean;
+    autoplayValue: boolean;
+    intervalValue: number;
+    loopValue: boolean;
+    /** Renders the initial slide and starts autoplay when requested. */
+    connect(): void;
+    /** Clears the autoplay interval so it never fires after teardown. */
+    disconnect(): void;
+    /** Advances to the next slide. Bound via `data-action`. */
+    next(): void;
+    /** Returns to the previous slide. Bound via `data-action`. */
+    prev(): void;
+    /** Jumps to the slide whose picker was activated (click / Enter / Space). */
+    goto(event: Event): void;
+    /** Toggles autoplay on the user's explicit request and syncs the timer. */
+    togglePlay(): void;
+    /**
+     * Suspends autoplay. Hover (`mouseenter`) is a temporary suspension that resumes
+     * on leave; keyboard focus (`focusin`) is a hard stop that turns autoplay off so
+     * it cannot resume without an explicit play (WCAG 2.2.2).
+     */
+    pause(event?: Event): void;
+    /**
+     * Lifts a hover suspension (`mouseleave`) and resumes autoplay if it is still
+     * on. A `focusout` does nothing here: the focus pause was a hard stop, so the
+     * user must press play to restart.
+     */
+    resume(event?: Event): void;
+    /** Picker roving: arrows move focus only; Home/End activate first/last slide. */
+    onPickerKeydown(event: KeyboardEvent): void;
+}
+
+/**
+ * Headless copy-to-clipboard behavior with a live-region completion notice.
+ *
+ * Markup contract (identifier: `stimeo--clipboard`):
+ *   <div data-controller="stimeo--clipboard"
+ *        data-stimeo--clipboard-feedback-duration-value="2000">
+ *     <input type="text" value="https://example.com" readonly
+ *            data-stimeo--clipboard-target="source">
+ *     <button type="button" data-stimeo--clipboard-target="button"
+ *             data-action="stimeo--clipboard#copy">Copy</button>
+ *     <span role="status" aria-live="polite"
+ *           data-stimeo--clipboard-target="feedback"></span>
+ *   </div>
+ *
+ * No dedicated APG pattern; this follows the Button + live-region practice. The
+ * copy uses the standard `navigator.clipboard` API (no extra dependency); when
+ * it is unavailable or rejects, the failure is surfaced rather than silently
+ * swallowed, and never communicated by icon alone — the `role="status"` region
+ * carries text so screen readers announce the outcome.
+ *
+ * @remarks
+ * Behavior only — icon swaps and styling are the consumer's, keyed off
+ * `data-state` (`idle` / `copied` / `error`). The completion notice clears
+ * itself after `feedbackDuration`; that timer is torn down on disconnect (Turbo)
+ * via {@link SafeTimeout}.
+ */
+declare class ClipboardController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        text: {
+            type: StringConstructor;
+            default: string;
+        };
+        feedbackDuration: {
+            type: NumberConstructor;
+            default: number;
+        };
+        copiedLabel: {
+            type: StringConstructor;
+            default: string;
+        };
+        errorLabel: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    static actions: readonly ["copy"];
+    static events: readonly ["copy"];
+    readonly sourceTarget: HTMLElement;
+    readonly buttonTarget: HTMLElement;
+    readonly feedbackTarget: HTMLElement;
+    readonly hasSourceTarget: boolean;
+    readonly hasButtonTarget: boolean;
+    readonly hasFeedbackTarget: boolean;
+    textValue: string;
+    feedbackDurationValue: number;
+    copiedLabelValue: string;
+    errorLabelValue: string;
+    connect(): void;
+    disconnect(): void;
+    /**
+     * Copies the resolved text and reports the outcome. Bound via `data-action`
+     * (click). Always dispatches `stimeo--clipboard:copy` with `{ success, text }`
+     * — including on failure — so consumers can react either way.
+     */
+    copy(): Promise<void>;
+}
+
+/**
+ * Headless, accessible single-disclosure (collapsible) behavior.
+ *
+ * Markup contract (identifier: `stimeo--collapsible`):
+ *   <div data-controller="stimeo--collapsible">
+ *     <button data-stimeo--collapsible-target="trigger"
+ *             data-action="stimeo--collapsible#toggle"
+ *             aria-expanded="false" aria-controls="more">Show details</button>
+ *     <div id="more" data-stimeo--collapsible-target="content"
+ *          data-state="closed" hidden>…</div>
+ *   </div>
+ *
+ * Implements the WAI-ARIA APG **Disclosure** pattern for a single inline region.
+ * Unlike {@link AccordionController} it manages exactly one trigger/content pair
+ * with no sibling coordination, and unlike a dropdown the content expands in
+ * flow and never closes on an outside click.
+ *
+ * @remarks
+ * Behavior only — the consumer owns the height transition and all decoration.
+ * The controller keeps the open lifecycle ordered so `hidden` (effectively
+ * `display:none`) never blocks measurement or the transition:
+ * - **Open**: drop `hidden` → measure the natural height into
+ *   `--stimeo-collapsible-content-height` → set `data-state="open"`.
+ * - **Close**: set `data-state="closed"` (CSS shrinks the height) → re-apply
+ *   `hidden` after `transitionend`. With no transition (or reduced motion, which
+ *   the consumer's CSS expresses as a zero duration) it is applied immediately.
+ */
+declare class CollapsibleController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        open: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    static actions: readonly ["toggle"];
+    readonly triggerTarget: HTMLElement;
+    readonly contentTarget: HTMLElement;
+    readonly hasTriggerTarget: boolean;
+    readonly hasContentTarget: boolean;
+    openValue: boolean;
+    /**
+     * Establishes the initial open/closed state without animating.
+     *
+     * The DOM is the source of truth on reconnect (Turbo cache restore / morph): an
+     * **explicit** state attribute — `aria-expanded="true"`/`"false"` (or, with no
+     * trigger, `data-state="open"`/`"closed"`) — is honored verbatim so a region the
+     * user opened *or* closed survives a back-navigation, even when the declarative
+     * `open` Value disagrees. The Value only seeds a genuinely fresh render where no
+     * state attribute is present yet. Mirrors `sidebar`'s `#restoreCollapsed`.
+     */
+    connect(): void;
+    disconnect(): void;
+    /** Toggles the region open/closed. Bound via `data-action` (click). */
+    toggle(): void;
+}
+
+/**
+ * Headless, accessible **Color Picker** behavior.
+ *
+ * Markup contract (identifier: `stimeo--color-picker`):
+ *   <div data-controller="stimeo--color-picker"
+ *        data-stimeo--color-picker-value-value="#3366cc">
+ *     <div role="slider" aria-label="Hue" data-channel="hue" tabindex="0"
+ *          aria-valuemin="0" aria-valuemax="360" aria-valuenow="210"
+ *          data-stimeo--color-picker-target="slider"
+ *          data-action="keydown->stimeo--color-picker#onKeydown
+ *                       pointerdown->stimeo--color-picker#onPointerDown"></div>
+ *     <!-- saturation / lightness / alpha sliders share the same contract -->
+ *     <input type="text" aria-label="Hex color"
+ *            data-stimeo--color-picker-target="hex"
+ *            data-action="change->stimeo--color-picker#onHexInput" />
+ *     <div data-stimeo--color-picker-target="preview" aria-hidden="true"></div>
+ *     <input type="hidden" data-stimeo--color-picker-target="field" />
+ *   </div>
+ *
+ * Decomposes color selection into independent APG **Slider** channels (hue,
+ * saturation, lightness, optional alpha) instead of a 2-D palette, so every
+ * adjustment is keyboard- and screen-reader-operable. Each slider exposes
+ * `aria-valuenow` and a human-readable `aria-valuetext` (e.g. "Hue 210 degrees");
+ * the hex input stays two-way synced; the current color is published on the
+ * preview and root as the `--stimeo-color` custom property and mirrored into a
+ * hidden form field.
+ *
+ * @remarks
+ * Behavior only — the swatch/gradient visuals are the consumer's CSS/canvas, fed
+ * by `--stimeo-color`. Pointer-drag listeners on `document` are bound to an
+ * {@link AbortController} and released on drag end and on `disconnect()` (Turbo
+ * navigation included). Color is fully reconstructable from the `value` (hex), so
+ * there is no transient state to restore after a Turbo cache/morph.
+ *
+ * The internal model is integer HSL(A), so a hex → HSL → hex round-trip is not
+ * exactly bijective: a typed hex can normalize to a near (not identical) value
+ * once the HSL sliders are touched. This keeps the model small and zero-dep; use a
+ * dedicated color library on the consumer side if exact hex preservation matters.
+ */
+declare class ColorPickerController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        value: {
+            type: StringConstructor;
+            default: string;
+        };
+        alpha: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    static actions: readonly ["onHexInput", "onKeydown", "onPointerDown"];
+    static events: readonly ["change"];
+    readonly sliderTargets: HTMLElement[];
+    readonly hexTarget: HTMLInputElement;
+    readonly hasHexTarget: boolean;
+    readonly previewTargets: HTMLElement[];
+    readonly fieldTargets: HTMLInputElement[];
+    valueValue: string;
+    alphaValue: boolean;
+    /** Seeds the model from the initial hex value and renders every surface. */
+    connect(): void;
+    /** Cancels any active pointer drag so document listeners never leak. */
+    disconnect(): void;
+    /** Keyboard stepping on the focused channel slider (APG Slider model). */
+    onKeydown(event: KeyboardEvent): void;
+    /** Begins a pointer drag on a channel slider and tracks movement. */
+    onPointerDown(event: PointerEvent): void;
+    /** Parses the hex input on confirm and syncs every channel + surface. */
+    onHexInput(): void;
+}
+
+/**
+ * Headless currency / amount input behavior: groups digits for display while
+ * keeping a machine-readable number in a hidden field, and mirrors the
+ * normalized value to a visually-hidden span so assistive tech reads the real
+ * amount rather than the grouped display string.
+ *
+ * Markup contract (identifier: `stimeo--currency-input`):
+ *   <div data-controller="stimeo--currency-input"
+ *        data-stimeo--currency-input-locale-value="en-US"
+ *        data-stimeo--currency-input-currency-value="USD"
+ *        data-stimeo--currency-input-precision-value="2">
+ *     <input type="text" inputmode="decimal"
+ *            aria-describedby="amt-sr"
+ *            data-stimeo--currency-input-target="display"
+ *            data-action="input->stimeo--currency-input#onInput
+ *                         blur->stimeo--currency-input#format" />
+ *     <span id="amt-sr" class="visually-hidden"
+ *           data-stimeo--currency-input-target="srValue"></span>
+ *     <input type="hidden" data-stimeo--currency-input-target="field" />
+ *   </div>
+ *
+ * @remarks
+ * Behavior only — no styling, no validation (range/required belong to the
+ * consumer or Form Field). The display field is the sole Tab stop and keeps its
+ * native text-editing behavior; this controller never steals focus. Grouping is
+ * applied on every input while preserving the caret (counted by digits to its
+ * left), and the fixed-precision rounding is applied on `blur`.
+ *
+ * Honest a11y note: a hidden `<input>` is not exposed to assistive tech, so the
+ * normalized value is *also* published as text in the `srValue` span referenced
+ * by the display's `aria-describedby` — that, not the hidden field, is what a
+ * screen reader announces.
+ */
+declare class CurrencyInputController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        locale: {
+            type: StringConstructor;
+            default: string;
+        };
+        currency: {
+            type: StringConstructor;
+            default: string;
+        };
+        precision: {
+            type: NumberConstructor;
+            default: number;
+        };
+    };
+    static actions: readonly ["format", "onInput"];
+    static events: readonly ["change"];
+    readonly displayTarget: HTMLInputElement;
+    readonly fieldTarget: HTMLInputElement;
+    readonly srValueTarget: HTMLElement;
+    readonly hasDisplayTarget: boolean;
+    readonly hasFieldTarget: boolean;
+    readonly hasSrValueTarget: boolean;
+    localeValue: string;
+    currencyValue: string;
+    precisionValue: number;
+    /** Normalizes any pre-filled display value to its fixed-precision form. */
+    connect(): void;
+    /** Re-groups digits as the user types, preserving the caret position. */
+    onInput(): void;
+    /** Applies the fixed-precision rounding on blur. */
+    format(): void;
+}
+
+/**
+ * Headless, accessible **Data Grid** behavior: column sorting, row selection, and
+ * roving keyboard navigation over an interactive table.
+ *
+ * Markup contract (identifier: `stimeo--data-grid`):
+ *   <table data-controller="stimeo--data-grid" role="grid" aria-label="Users"
+ *          data-stimeo--data-grid-selection-value="single">
+ *     <thead><tr role="row">
+ *       <th role="columnheader" aria-sort="none" tabindex="-1"
+ *           data-stimeo--data-grid-target="columnHeader"
+ *           data-action="click->stimeo--data-grid#sort
+ *                        keydown->stimeo--data-grid#onKeydown">Name</th>
+ *     </tr></thead>
+ *     <tbody><tr role="row" aria-selected="false"
+ *                data-stimeo--data-grid-target="row">
+ *       <td role="gridcell" tabindex="0" data-stimeo--data-grid-target="cell"
+ *           data-action="keydown->stimeo--data-grid#onKeydown">Jane</td>
+ *     </tr></tbody>
+ *   </table>
+ *
+ * Implements the WAI-ARIA APG **Grid** pattern plus `aria-sort`. The whole grid is
+ * a single Tab stop (roving `tabindex`: exactly one cell/header is `0`, the rest
+ * `-1`); arrow keys move both DOM focus and that tabbable position. Sort state is
+ * exposed via `aria-sort` on headers, selection via `aria-selected` on rows.
+ *
+ * @remarks
+ * Behavior only — the consumer performs the actual data sort/render in response to
+ * the `sort` event and owns all styling. No timers or observers are held, so there
+ * is nothing to leak across Turbo navigations; `connect()` rebuilds the single tab
+ * stop idempotently from the DOM.
+ *
+ * Behavior provided:
+ * - `Arrow*` move between cells (clamped at edges); `Home`/`End` to the row's
+ *   first/last cell; `Ctrl+Home`/`Ctrl+End` to the grid's first/last cell.
+ * - `Enter`/`Space` cycles a header's sort (`none→ascending→descending`) or toggles
+ *   the focused row's selection when selection is enabled.
+ */
+declare class DataGridController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        selection: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    static actions: readonly ["onKeydown", "sort", "toggleSelect"];
+    static events: readonly ["selectionchange", "sort"];
+    readonly columnHeaderTargets: HTMLElement[];
+    readonly rowTargets: HTMLElement[];
+    readonly cellTargets: HTMLElement[];
+    selectionValue: string;
+    /** Establishes a single tab stop across all navigable cells/headers. */
+    connect(): void;
+    /**
+     * Keeps `aria-multiselectable` in step with the `selection` Value. Fires on connect
+     * (so it self-heals after a Turbo morph) and on any runtime change, so the ARIA
+     * never drifts from the selection logic, which reads `selectionValue` live.
+     */
+    selectionValueChanged(): void;
+    /** Cycles the activated column header's sort and emits `sort`. */
+    sort(event: Event): void;
+    /** Toggles selection of the row owning the event target. Bound optionally. */
+    toggleSelect(event: Event): void;
+    /** Grid navigation + sort/select activation. Bound to cells and headers. */
+    onKeydown(event: KeyboardEvent): void;
+}
+
+/**
+ * Headless, accessible **date range picker** behavior. A derivative of
+ * {@link CalendarController}: it reuses the month-grid navigation model and adds
+ * two-point range selection, in-progress range preview, and presets.
+ *
+ * Markup contract (identifier: `stimeo--date-range-picker`):
+ *   <div data-controller="stimeo--date-range-picker"
+ *        data-stimeo--date-range-picker-min-value="2026-01-01"
+ *        data-stimeo--date-range-picker-max-value="2026-12-31">
+ *     <button data-action="stimeo--date-range-picker#prev">Prev</button>
+ *     <span data-stimeo--date-range-picker-target="monthLabel" aria-live="polite"></span>
+ *     <button data-action="stimeo--date-range-picker#next">Next</button>
+ *     <div role="grid" data-stimeo--date-range-picker-target="grid">
+ *       <!-- exactly 42 cell targets (7 days × 6 rows) -->
+ *       <button role="gridcell" tabindex="-1"
+ *               data-stimeo--date-range-picker-target="cell"
+ *               data-action="click->stimeo--date-range-picker#selectDate
+ *                            mouseenter->stimeo--date-range-picker#previewTo
+ *                            focus->stimeo--date-range-picker#previewTo
+ *                            keydown->stimeo--date-range-picker#onKeydown"></button>
+ *     </div>
+ *     <button data-range="last7" data-action="stimeo--date-range-picker#applyPreset">…</button>
+ *     <span role="status" aria-live="polite" data-stimeo--date-range-picker-target="status"></span>
+ *     <input type="hidden" data-stimeo--date-range-picker-target="startField" />
+ *     <input type="hidden" data-stimeo--date-range-picker-target="endField" />
+ *   </div>
+ *
+ * @remarks
+ * Behavior only — the consumer styles the grid and renders the range using the
+ * `data-range-start` / `data-in-range` / `data-range-end` hooks. Assistive tech
+ * is told the two confirmed endpoints via `aria-selected`; inner cells use
+ * `data-in-range` (visual only) so the announcement stays to the two ends. The
+ * confirmed range is also mirrored to the live `status` region.
+ *
+ * Selection model: the first click/Enter sets a *pending* start and enters
+ * "selecting" mode (preview follows the pointer/focus); the second confirms the
+ * end (auto-swapped if earlier than the start) and dispatches `change`. Escape
+ * abandons an in-progress selection, restoring the last confirmed range.
+ */
+declare class DateRangePickerController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        min: {
+            type: StringConstructor;
+            default: string;
+        };
+        max: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    static actions: readonly ["applyPreset", "next", "onKeydown", "prev", "previewTo", "selectDate"];
+    static events: readonly ["change"];
+    readonly gridTarget: HTMLElement;
+    readonly monthLabelTarget: HTMLElement;
+    readonly cellTargets: HTMLElement[];
+    readonly statusTarget: HTMLElement;
+    readonly startFieldTarget: HTMLInputElement;
+    readonly endFieldTarget: HTMLInputElement;
+    readonly hasMonthLabelTarget: boolean;
+    readonly hasStatusTarget: boolean;
+    readonly hasStartFieldTarget: boolean;
+    readonly hasEndFieldTarget: boolean;
+    minValue: string;
+    maxValue: string;
+    /** Seeds the range from any pre-filled hidden fields and renders the grid. */
+    connect(): void;
+    /** Cancels any pending deferred focus so it never fires on a detached element. */
+    disconnect(): void;
+    /** Navigates to the previous month. */
+    prev(event?: Event): void;
+    /** Navigates to the next month. */
+    next(event?: Event): void;
+    /** Confirms a range endpoint from a clicked cell. */
+    selectDate(event: Event): void;
+    /** Previews the range up to a hovered/focused cell while selecting. */
+    previewTo(event: Event): void;
+    /** Applies a named preset (`today` / `last7` / `last30` / `thisMonth`). */
+    applyPreset(event: Event): void;
+    /** Grid keyboard navigation, selection (Enter/Space), and Escape-to-cancel. */
+    onKeydown(event: KeyboardEvent): void;
+}
+
+/**
+ * Headless "dismissible" behavior for banners, notices, and inline alerts.
+ *
+ * Markup contract (identifier: `stimeo--dismissible`):
+ *   <div data-controller="stimeo--dismissible"
+ *        data-stimeo--dismissible-mode-value="remove">
+ *     <div data-stimeo--dismissible-target="root" role="status">
+ *       <p>Saved.</p>
+ *       <button type="button" aria-label="Close"
+ *               data-action="stimeo--dismissible#dismiss">×</button>
+ *     </div>
+ *   </div>
+ *
+ * A general utility with no dedicated APG pattern. Its accessibility job is to
+ * keep focus from being orphaned: if focus is inside the element being removed,
+ * it is moved to a safe place first so the close button vanishing never strands
+ * the user (WCAG 2.4.3).
+ *
+ * @remarks
+ * Behavior only — the consumer owns any exit transition (use `hide` mode, which
+ * adds `hidden`, and animate off `data-state`) and any semantics like
+ * `role="alert"`. Focus retreats to, in order: the `fallback` target → the next
+ * focusable element after the root → the previous one → `document.body` as a
+ * last resort (weak focus; prefer providing a `fallback`).
+ */
+declare class DismissibleController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        mode: {
+            type: StringConstructor;
+            default: string;
+        };
+        closeOnEscape: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    static actions: readonly ["dismiss"];
+    static events: readonly ["dismiss"];
+    readonly rootTarget: HTMLElement;
+    readonly fallbackTarget: HTMLElement;
+    readonly hasRootTarget: boolean;
+    readonly hasFallbackTarget: boolean;
+    modeValue: string;
+    closeOnEscapeValue: boolean;
+    connect(): void;
+    disconnect(): void;
+    /** Dismisses the element. Bound via `data-action` (click on the close button). */
+    dismiss(): void;
+}
+
+/**
+ * Headless, accessible **drawer / slide-over** behavior.
+ *
+ * Markup contract (identifier: `stimeo--drawer`):
+ *   <div data-controller="stimeo--drawer" data-stimeo--drawer-placement-value="right">
+ *     <button data-stimeo--drawer-target="trigger"
+ *             data-action="click->stimeo--drawer#open">Open panel</button>
+ *     <div data-stimeo--drawer-target="overlay"
+ *          data-action="click->stimeo--drawer#closeOnBackdrop">
+ *       <aside data-stimeo--drawer-target="panel" role="dialog" aria-modal="true"
+ *              aria-labelledby="t" data-state="closed" hidden>
+ *         <h2 id="t">…</h2>
+ *         <button data-action="click->stimeo--drawer#close">Close</button>
+ *       </aside>
+ *     </div>
+ *   </div>
+ *
+ * Implements the WAI-ARIA APG **Dialog (Modal)** pattern. It is the same modal as
+ * `stimeo--dialog`; what it adds is the state plumbing an enter/exit *slide*
+ * needs: `data-state` (`open`/`closed`) is synced on the panel and overlay so CSS
+ * can animate, and `hidden` is applied only *after* the close transition finishes
+ * (so the exit animation can play). `placement` is reflected as `data-placement`
+ * for the CSS to read — the controller never computes coordinates.
+ *
+ * @remarks
+ * Behavior only. The modal lifecycle (focus trap, scroll lock, background
+ * `inert`, focus restore, teardown reversal) is delegated to the shared
+ * {@link FocusTrap}. Placement, slide direction, distance, and easing are all the
+ * consumer's CSS — `data-placement` is merely a flag.
+ *
+ * Behavior provided:
+ * - {@link open}/{@link close} toggle `data-state` and (deferred) `hidden`.
+ * - On open, focus moves to the first focusable element in the panel.
+ * - `Tab`/`Shift+Tab` cycle focus within the panel; `Escape` closes.
+ * - {@link closeOnBackdrop} closes only when the overlay *itself* is clicked.
+ */
+declare class DrawerController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        placement: {
+            type: StringConstructor;
+            default: string;
+        };
+        open: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    static actions: readonly ["close", "closeOnBackdrop", "open"];
+    readonly triggerTarget: HTMLElement;
+    readonly overlayTarget: HTMLElement;
+    readonly panelTarget: HTMLElement;
+    readonly hasTriggerTarget: boolean;
+    readonly hasOverlayTarget: boolean;
+    readonly hasPanelTarget: boolean;
+    placementValue: string;
+    openValue: boolean;
+    /**
+     * Reflects placement and establishes the initial open/closed state.
+     *
+     * The DOM is the source of truth on reconnect (Turbo cache restore / morph): a
+     * restored snapshot whose panel is already `data-state="open"` stays open
+     * rather than being re-derived from the declarative `open` Value (which would
+     * close a user-opened drawer). The `open` Value only seeds a genuinely fresh
+     * render. We normalize to a clean closed baseline first so {@link open} runs its
+     * full reveal + trap activation — the {@link FocusTrap} is a fresh instance
+     * after a reconnect and must be re-activated.
+     */
+    connect(): void;
+    /** Reverts the modal side effects and pending hide if torn down while open. */
+    disconnect(): void;
+    /** Keeps `data-placement` in sync if the value changes at runtime. */
+    placementValueChanged(): void;
+    /** Opens the drawer: reveals it, syncs `data-state`, traps focus. */
+    open(): void;
+    /**
+     * Closes the drawer: syncs `data-state` to start the exit transition, then
+     * defers both `hidden` *and* the modal teardown (scroll lock / background
+     * `inert` / focus restore) until the transition finishes — see
+     * `#applyHidden`. This keeps the background inert and focus trapped while
+     * the drawer is still visually on screen, preserving the modal contract during
+     * the exit animation.
+     */
+    close(): void;
+    /** Closes only when the overlay itself (not its contents) is clicked. */
+    closeOnBackdrop(event: MouseEvent): void;
+}
+
+/**
+ * Headless, accessible inline-editing behavior.
+ *
+ * Markup contract (identifier: `stimeo--editable`):
+ *   <div data-controller="stimeo--editable"
+ *        data-stimeo--editable-submit-on-blur-value="true">
+ *     <button type="button" aria-label="Edit title"
+ *             data-stimeo--editable-target="display"
+ *             data-action="click->stimeo--editable#edit
+ *                          keydown->stimeo--editable#onDisplayKeydown">Current title</button>
+ *     <input type="text" aria-label="Title" hidden
+ *            data-stimeo--editable-target="input"
+ *            data-action="keydown->stimeo--editable#onKeydown
+ *                         blur->stimeo--editable#onBlur" />
+ *   </div>
+ *
+ * There is no dedicated APG pattern; this implements a display ⇄ edit toggle with
+ * focus management and keyboard commit/cancel, leaning on native form-control
+ * labeling (WCAG 1.3.1 / 4.1.2). The look is the consumer's CSS, keyed off
+ * `data-mode`.
+ *
+ * Behavior provided:
+ * - Activating the display element (`Enter`/`Space` via the `<button>`, or `F2`)
+ *   enters edit mode, focuses the input, and selects its text.
+ * - `Enter` (single-line) or `Ctrl+Enter` / `Cmd+Enter` (multiline `<textarea>`)
+ *   saves; `Escape` cancels. Both return focus to the display element.
+ * - Losing focus while editing saves when `submitOnBlur` is true (the default),
+ *   honoring wherever focus moved; when false, editing is kept.
+ * - Saving dispatches `stimeo--editable:change` with `{ value, previous }` only
+ *   when the value actually changed; cancelling dispatches
+ *   `stimeo--editable:cancel`.
+ */
+declare class EditableController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        submitOnBlur: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    static actions: readonly ["edit", "onBlur", "onDisplayKeydown", "onKeydown"];
+    static events: readonly ["cancel", "change"];
+    readonly displayTarget: HTMLElement;
+    readonly inputTarget: HTMLInputElement | HTMLTextAreaElement;
+    readonly hasDisplayTarget: boolean;
+    readonly hasInputTarget: boolean;
+    submitOnBlurValue: boolean;
+    /** Establishes the initial display mode (display shown, input hidden). */
+    connect(): void;
+    /** Enters edit mode: seeds the input from the display text, focuses, selects. */
+    edit(): void;
+    /** Adds `F2` as an editing entry point alongside the button's native activation. */
+    onDisplayKeydown(event: KeyboardEvent): void;
+    /** Commits on `Enter` (or `Ctrl+Enter` when multiline) and cancels on `Escape`. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Saves on blur when `submitOnBlur` is set; otherwise keeps editing. */
+    onBlur(): void;
+}
+
+/**
+ * Headless, accessible file drag-and-drop / upload field.
+ *
+ * Markup contract (identifier: `stimeo--file-dropzone`):
+ *   <div data-controller="stimeo--file-dropzone"
+ *        data-stimeo--file-dropzone-max-size-value="5242880">
+ *     <div data-stimeo--file-dropzone-target="zone"
+ *          data-action="dragover->stimeo--file-dropzone#onDragOver
+ *                       dragleave->stimeo--file-dropzone#onDragLeave
+ *                       drop->stimeo--file-dropzone#onDrop">
+ *       <button type="button" data-stimeo--file-dropzone-target="trigger"
+ *               data-action="click->stimeo--file-dropzone#openDialog">Choose…</button>
+ *       <input type="file" accept="image/*" multiple class="visually-hidden"
+ *              data-stimeo--file-dropzone-target="input"
+ *              data-action="change->stimeo--file-dropzone#onChange" />
+ *     </div>
+ *     <ul data-stimeo--file-dropzone-target="list" aria-label="Selected files"></ul>
+ *     <span role="status" aria-live="polite" class="visually-hidden"
+ *           data-stimeo--file-dropzone-target="status"></span>
+ *     <template data-stimeo--file-dropzone-target="itemTemplate">…</template>
+ *   </div>
+ *
+ * There is no single APG pattern; the native `<input type="file">` stays the
+ * primary, keyboard-operable path and the drop zone is an enhancement, mapping to
+ * WCAG 2.1.1, 2.4.7, 4.1.2, 4.1.3, and 1.4.1 (drag state is conveyed in words,
+ * not color alone).
+ *
+ * Behavior provided:
+ * - Click / keyboard via the `trigger` opens the native file dialog; drag-and-drop
+ *   over the `zone` adds files (with a `data-dragover` flag and a spoken hint).
+ * - Each file is validated against `accept`, `maxSize`, and the file count
+ *   (`maxFiles`, or 1 when the input is not `multiple`); rejects fire
+ *   `stimeo--file-dropzone:reject` and set `data-…-invalid`.
+ * - Accepted files render from `itemTemplate` with a `Remove {name}` button and an
+ *   image thumbnail (`objectURL`); every change dispatches
+ *   `stimeo--file-dropzone:change` with the current `File[]`.
+ * - Removing a file revokes its `objectURL` and moves focus to the next (else
+ *   previous) remove button, falling back to the trigger; `disconnect()` revokes
+ *   every outstanding `objectURL`.
+ */
+declare class FileDropzoneController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        maxSize: {
+            type: NumberConstructor;
+            default: number;
+        };
+        maxFiles: {
+            type: NumberConstructor;
+            default: number;
+        };
+        dragLabel: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    static actions: readonly ["onChange", "onDragLeave", "onDragOver", "onDrop", "openDialog"];
+    static events: readonly ["change", "reject"];
+    readonly inputTarget: HTMLInputElement;
+    readonly listTarget: HTMLElement;
+    readonly triggerTarget: HTMLElement;
+    readonly itemTemplateTarget: HTMLTemplateElement;
+    readonly statusTarget: HTMLElement;
+    readonly hasListTarget: boolean;
+    readonly hasTriggerTarget: boolean;
+    readonly hasItemTemplateTarget: boolean;
+    readonly hasStatusTarget: boolean;
+    readonly hasZoneTarget: boolean;
+    readonly zoneTarget: HTMLElement;
+    maxSizeValue: number;
+    maxFilesValue: number;
+    dragLabelValue: string;
+    /** Wires file removal as a delegated listener on the list container. */
+    connect(): void;
+    /** Revokes any outstanding preview URLs so none leaks across navigations. */
+    disconnect(): void;
+    /** Opens the native file dialog. Bound via `data-action` (trigger click). */
+    openDialog(): void;
+    /** Adds the files chosen through the native dialog. */
+    onChange(): void;
+    /** Marks the zone as a drop target and announces the affordance in words. */
+    onDragOver(event: DragEvent): void;
+    /** Clears the drag-over flag when the pointer leaves the zone. */
+    onDragLeave(): void;
+    /** Accepts dropped files, clearing the drag-over state. */
+    onDrop(event: DragEvent): void;
+}
+
+/** A control whose "on" state contributes its token to the active filter set. */
+type FilterControl = HTMLElement;
+/**
+ * Headless faceted-filter behavior: shows or hides a collection of items based on the
+ * set of currently-active facet tokens, decoupled from how those tokens are toggled
+ * (native checkboxes/radios, or button toggles such as `stimeo--toggle-group`).
+ *
+ * Markup contract (identifier: `stimeo--filter`):
+ *   <div data-controller="stimeo--filter" data-stimeo--filter-match-value="all">
+ *     <!-- controls: each contributes its token while "on" (aria-pressed / checked) -->
+ *     <button type="button" aria-pressed="false" data-value="apg:dialog"
+ *             data-stimeo--filter-target="control">Dialog</button>
+ *     <!-- items: filtered in/out by their space-separated tokens -->
+ *     <li data-stimeo--filter-target="item"
+ *         data-stimeo--filter-tokens="apg:dialog overlay">…</li>
+ *     <!-- optional: a container hidden once it holds no visible item -->
+ *     <section data-stimeo--filter-target="group">…</section>
+ *     <!-- optional: an element revealed when nothing matches -->
+ *     <p data-stimeo--filter-target="empty" hidden>No matches</p>
+ *   </div>
+ *
+ * `match` decides how multiple active tokens combine: `all` (default — an item must
+ * carry every active token) or `any` (at least one). With no active token every item
+ * is shown. Items are toggled via `hidden`; groups with zero visible items and the
+ * `empty` element are kept in sync, and `stimeo--filter:change` is dispatched.
+ *
+ * @remarks
+ * Behavior only — the consumer owns all styling and the controls' own accessible
+ * state (e.g. `aria-pressed`). Visibility is re-derived from the live DOM on
+ * `connect()` (Morph/Turbo-safe) and on every native `change` that bubbles to the
+ * root; button toggles that emit no native `change` wire their event to the `apply`
+ * action (e.g. `stimeo--toggle-group:change->stimeo--filter#apply`).
+ */
+declare class FilterController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        match: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    static actions: readonly ["apply", "clear"];
+    static events: readonly ["change"];
+    readonly itemTargets: HTMLElement[];
+    readonly controlTargets: FilterControl[];
+    readonly groupTargets: HTMLElement[];
+    readonly emptyTargets: HTMLElement[];
+    matchValue: string;
+    connect(): void;
+    disconnect(): void;
+    /** Re-derives every item's visibility from the active tokens and syncs groups/empty. */
+    apply(): void;
+    /** Turns every control off (uncheck / aria-pressed="false") and re-applies. */
+    clear(): void;
+}
+
+/**
+ * Headless **Masonry** layout helper: assigns each item to the shortest column so
+ * variable-height cards pack without vertical gaps. There is no APG widget — this
+ * is a layout-only utility that emits state hooks, never visual structure.
+ *
+ * Markup contract (identifier: `stimeo--masonry`):
+ *   <div data-controller="stimeo--masonry"
+ *        data-stimeo--masonry-min-column-width-value="240"
+ *        data-stimeo--masonry-gap-value="16">
+ *     <div data-stimeo--masonry-target="item">…</div>
+ *     <div data-stimeo--masonry-target="item">…</div>
+ *   </div>
+ *
+ * The column count is derived responsively from the container width and
+ * `minColumnWidth`; each item is then placed into whichever column is currently
+ * shortest (measured from item heights). The count is published on the controller
+ * element as the `--stimeo-masonry-columns` custom property and each item gets a
+ * `data-column` index, so the consumer's CSS owns the actual placement.
+ *
+ * @remarks
+ * Behavior only. **DOM order is never changed** — reading order and focus order
+ * stay the source markup order (WCAG 1.3.2). The visual packing is purely the
+ * column assignment a consumer reads from `data-column`; this controller writes no
+ * positioning styles. Re-layout runs on connect, on resize ({@link LayoutObserver}),
+ * and on item add/remove ({@link MutationObserver}); both observers are released on
+ * `disconnect()` (Turbo navigation included). Use only for independent cards whose
+ * visual order carries no meaning.
+ */
+declare class MasonryController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        minColumnWidth: {
+            type: NumberConstructor;
+            default: number;
+        };
+        gap: {
+            type: NumberConstructor;
+            default: number;
+        };
+    };
+    static events: readonly ["layout"];
+    readonly itemTargets: HTMLElement[];
+    minColumnWidthValue: number;
+    gapValue: number;
+    /** Observes size/content changes and performs the first layout pass. */
+    connect(): void;
+    /** Releases both observers and the load listener so nothing fires after detach. */
+    disconnect(): void;
+}
+
+/**
+ * Headless, accessible **menubar** behavior.
+ *
+ * Markup contract (identifier: `stimeo--menubar`):
+ *   <div data-controller="stimeo--menubar" role="menubar" aria-label="Main">
+ *     <button role="menuitem" aria-haspopup="menu" aria-expanded="false"
+ *             aria-controls="m-file" data-stimeo--menubar-target="top"
+ *             data-action="click->stimeo--menubar#toggle
+ *                          keydown->stimeo--menubar#onTopKeydown">File</button>
+ *     <ul id="m-file" role="menu" data-stimeo--menubar-target="menu" hidden>
+ *       <li role="none">
+ *         <button role="menuitem" tabindex="-1" data-stimeo--menubar-target="item"
+ *                 data-action="click->stimeo--menubar#activate
+ *                              keydown->stimeo--menubar#onItemKeydown">New</button>
+ *       </li>
+ *     </ul>
+ *     <!-- more top items + menus -->
+ *   </div>
+ *
+ * Implements the WAI-ARIA APG **Menubar** pattern (single level): the top items
+ * form one Tab stop via roving tabindex and the arrow keys move between them;
+ * `ArrowDown`/`Enter`/`Space` open a menu (`ArrowUp` opens it at the last item),
+ * the arrow keys then move within the menu, and pressing `ArrowLeft`/`ArrowRight`
+ * while a menu is open jumps to the adjacent top menu. `Escape` closes and
+ * returns focus to the owning top item; `Tab` and an outside click close.
+ *
+ * @remarks
+ * Behavior only. Each top item↔menu pair is linked by `aria-controls`/`id` (not by
+ * position), so the markup order is free. Menu placement and viewport-edge
+ * collision are out of scope — static placement is the consumer's CSS, and dynamic
+ * placement is delegated to the opt-in `stimeo-ui/positioning` module (never
+ * imported here, keeping the core zero-dependency). Roving mechanics across the top
+ * items are delegated to {@link RovingTabindex}.
+ */
+declare class MenubarController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static actions: readonly ["activate", "onItemKeydown", "onTopKeydown", "toggle"];
+    readonly topTargets: HTMLElement[];
+    readonly menuTargets: HTMLElement[];
+    readonly itemTargets: HTMLElement[];
+    /** Establishes the single tab stop and the closed baseline. */
+    connect(): void;
+    /** Removes the document listener and any pending typeahead timer. */
+    disconnect(): void;
+    /** Toggles a top item's menu. Bound via `data-action` (click on the top item). */
+    toggle(event: Event): void;
+    /** Keyboard handling while focus is on a top item. */
+    onTopKeydown(event: KeyboardEvent): void;
+    /** Keyboard handling while focus is on a menu item. */
+    onItemKeydown(event: KeyboardEvent): void;
+    /** Closes the owning menu after an item is activated and refocuses its top. */
+    activate(event: Event): void;
+}
+
+/**
+ * Headless, accessible multi-select combobox with chips.
+ *
+ * Markup contract (identifier: `stimeo--multi-select`):
+ *   <div data-controller="stimeo--multi-select">
+ *     <ul data-stimeo--multi-select-target="tags" aria-label="Selected"></ul>
+ *     <input type="text" role="combobox" aria-expanded="false"
+ *            aria-autocomplete="list" aria-controls="ms-list" aria-activedescendant=""
+ *            data-stimeo--multi-select-target="input"
+ *            data-action="input->stimeo--multi-select#filter
+ *                         keydown->stimeo--multi-select#onKeydown
+ *                         focus->stimeo--multi-select#open" />
+ *     <ul id="ms-list" role="listbox" aria-multiselectable="true" hidden
+ *         data-stimeo--multi-select-target="list">
+ *       <li id="ms-opt-1" role="option" aria-selected="false" data-value="apple"
+ *           data-stimeo--multi-select-target="option"
+ *           data-action="click->stimeo--multi-select#toggleOption">Apple</li>
+ *     </ul>
+ *     <span role="status" aria-live="polite" class="visually-hidden"
+ *           data-stimeo--multi-select-target="status"></span>
+ *     <template data-stimeo--multi-select-target="tagTemplate">…</template>
+ *   </div>
+ *
+ * Implements the WAI-ARIA APG **Combobox** pattern in its list-autocomplete,
+ * multi-select form. Focus stays on the input; the active option is tracked with
+ * `aria-activedescendant` and selection with `aria-selected`. Selected options are
+ * mirrored as removable chips. For single selection use {@link ListboxController}
+ * or Combobox; for free-text tags use {@link TagsInputController}.
+ *
+ * Behavior provided:
+ * - Typing filters options by substring and opens the list; `ArrowDown`/`ArrowUp`
+ *   (wrapping), `Home`/`End` move the active option; `Enter` toggles it (the list
+ *   stays open); `Escape`/`Tab`/outside click close.
+ * - Toggling syncs `aria-selected`, adds/removes a `Remove {label}` chip, mirrors
+ *   the live region, and dispatches `stimeo--multi-select:change` with `values`;
+ *   filtering dispatches `stimeo--multi-select:filter` for async candidates.
+ * - The chips are one roving Tab stop: `ArrowLeft`/`ArrowRight` move between them,
+ *   `Delete`/`Backspace` remove the focused chip, and `Backspace` on an empty
+ *   input removes the last; removal re-homes focus to a neighbor or the input.
+ * - `max` caps the selection (`0` = unlimited).
+ */
+declare class MultiSelectController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        max: {
+            type: NumberConstructor;
+            default: number;
+        };
+    };
+    static actions: readonly ["close", "filter", "onKeydown", "open", "toggleOption"];
+    static events: readonly ["change", "filter"];
+    readonly inputTarget: HTMLInputElement;
+    readonly listTarget: HTMLElement;
+    readonly optionTargets: HTMLElement[];
+    readonly tagsTarget: HTMLElement;
+    readonly tagTargets: HTMLElement[];
+    readonly tagTemplateTarget: HTMLTemplateElement;
+    readonly statusTarget: HTMLElement;
+    readonly hasListTarget: boolean;
+    readonly hasTagsTarget: boolean;
+    readonly hasTagTemplateTarget: boolean;
+    readonly hasStatusTarget: boolean;
+    maxValue: number;
+    /** Starts closed, syncs chips for any pre-selected options, and listens out. */
+    connect(): void;
+    /** Tears down document and chip listeners on disconnect (Turbo included). */
+    disconnect(): void;
+    /** Filters options by the input substring, opens, and re-seeds the active one. */
+    filter(): void;
+    /** Opens the list and activates the first visible option when none is active. */
+    open(): void;
+    /** Closes the list and clears the active option. */
+    close(): void;
+    /** Routes input keyboard interaction per the multi-select combobox model. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Toggles the clicked option's selection. Bound via `data-action`. */
+    toggleOption(event: Event): void;
+}
+
+/**
+ * Headless, accessible **navigation menu** behavior (disclosure navigation).
+ *
+ * Markup contract (identifier: `stimeo--navigation-menu`):
+ *   <nav data-controller="stimeo--navigation-menu" aria-label="Main">
+ *     <ul>
+ *       <li>
+ *         <button data-stimeo--navigation-menu-target="trigger"
+ *                 aria-expanded="false" aria-controls="nav-products"
+ *                 data-action="click->stimeo--navigation-menu#toggle
+ *                              keydown->stimeo--navigation-menu#onTriggerKeydown">
+ *           Products
+ *         </button>
+ *         <div id="nav-products" data-stimeo--navigation-menu-target="panel" hidden>
+ *           <a href="/a">Product A</a><a href="/b">Product B</a>
+ *         </div>
+ *       </li>
+ *     </ul>
+ *   </nav>
+ *
+ * Implements the WAI-ARIA APG **Disclosure** navigation pattern: each top-level
+ * button toggles its sub-panel (`aria-expanded` + `hidden` synced), only one panel
+ * is open at a time, and the panel content is a plain set of links (not a
+ * `role="menu"`). Focus is **not** trapped — `Tab` moves through the links
+ * naturally. `Escape` closes the open panel and returns focus to its trigger; an
+ * outside click or focus leaving the nav closes it. `ArrowLeft`/`ArrowRight` move
+ * focus between triggers without rewriting `tabindex` (they keep their natural Tab
+ * order). Hover open/close is opt-in via `openOnHover`.
+ *
+ * @remarks
+ * Behavior only. Panel layout, mega-menu styling, and animation are the
+ * consumer's CSS. Static placement is CSS; viewport-edge collision avoidance is
+ * delegated to the opt-in `stimeo-ui/positioning` module (never imported here, so
+ * the core stays zero-dependency). For an app command menu with arrow roving and
+ * `role="menu"`, use `stimeo--menubar` instead.
+ */
+declare class NavigationMenuController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        openOnHover: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hoverDelay: {
+            type: NumberConstructor;
+            default: number;
+        };
+    };
+    static actions: readonly ["onTriggerKeydown", "toggle"];
+    readonly triggerTargets: HTMLElement[];
+    readonly panelTargets: HTMLElement[];
+    openOnHoverValue: boolean;
+    hoverDelayValue: number;
+    /** Establishes the closed baseline and the dismissal listeners. */
+    connect(): void;
+    /** Removes every listener and pending hover timer registered in {@link connect}. */
+    disconnect(): void;
+    /** Toggles a trigger's panel (single-open). Bound via `data-action` (click). */
+    toggle(event: Event): void;
+    /** `ArrowLeft`/`ArrowRight` move focus between triggers (keeping Tab order). */
+    onTriggerKeydown(event: KeyboardEvent): void;
+}
+
+/**
+ * Headless password show/hide (unmask) toggle behavior.
+ *
+ * Markup contract (identifier: `stimeo--password-reveal`):
+ *   <div data-controller="stimeo--password-reveal">
+ *     <input type="password" aria-label="Password"
+ *            data-stimeo--password-reveal-target="input">
+ *     <button type="button" aria-pressed="false" aria-label="Show password"
+ *             data-stimeo--password-reveal-target="toggle"
+ *             data-action="stimeo--password-reveal#toggle"></button>
+ *   </div>
+ *
+ * No dedicated APG pattern; this follows the toggle **Button** practice. The
+ * accessible name stays state-independent ("Show password") while the pressed
+ * state is conveyed by `aria-pressed`.
+ *
+ * @remarks
+ * Behavior only — icon rendering is the consumer's, keyed off `aria-pressed` /
+ * `data-state` (`hidden` / `visible`). Flipping `input.type` can drop focus and
+ * the caret, so when (and only when) the input was the focused element its focus
+ * and selection are restored afterward; when the toggle button holds focus
+ * (keyboard use) focus is left on the button. An optional `autoHide` re-masks
+ * after a delay, and that timer is torn down on disconnect (Turbo).
+ */
+declare class PasswordRevealController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        autoHide: {
+            type: NumberConstructor;
+            default: number;
+        };
+    };
+    static actions: readonly ["toggle"];
+    static events: readonly ["toggle"];
+    readonly inputTarget: HTMLInputElement;
+    readonly toggleTarget: HTMLElement;
+    readonly hasInputTarget: boolean;
+    readonly hasToggleTarget: boolean;
+    autoHideValue: number;
+    connect(): void;
+    disconnect(): void;
+    /** Toggles the input between masked and revealed. Bound via `data-action`. */
+    toggle(): void;
+}
+
+/**
+ * Headless, accessible **two-thumb range slider** behavior (APG Slider —
+ * Multi-Thumb). A derivative of {@link SliderController}: it manages two thumbs
+ * (`start` ≤ `end`) that constrain each other.
+ *
+ * Markup contract (identifier: `stimeo--range-slider`):
+ *   <div data-controller="stimeo--range-slider"
+ *        data-stimeo--range-slider-min-value="0"
+ *        data-stimeo--range-slider-max-value="100"
+ *        data-stimeo--range-slider-step-value="1"
+ *        data-stimeo--range-slider-start-value="20"
+ *        data-stimeo--range-slider-end-value="80">
+ *     <div data-stimeo--range-slider-target="track"
+ *          data-action="pointerdown->stimeo--range-slider#onPointerDown">
+ *       <div role="slider" tabindex="0" aria-label="Minimum"
+ *            data-stimeo--range-slider-target="startThumb"
+ *            data-action="keydown->stimeo--range-slider#onKeydown"></div>
+ *       <div role="slider" tabindex="0" aria-label="Maximum"
+ *            data-stimeo--range-slider-target="endThumb"
+ *            data-action="keydown->stimeo--range-slider#onKeydown"></div>
+ *     </div>
+ *   </div>
+ *
+ * @remarks
+ * Behavior only — the consumer owns all layout (positioning the thumbs and the
+ * selected range from the fractions). Only the horizontal orientation is handled
+ * in this MVP. Each thumb's movable range is bounded by the *other* thumb's
+ * current value, reflected on its `aria-valuemin`/`aria-valuemax` so assistive
+ * tech announces the live constraint.
+ *
+ * Behavior provided (per focused thumb):
+ * - `ArrowRight`/`ArrowUp` increase and `ArrowLeft`/`ArrowDown` decrease by one
+ *   step; `Home`/`End` jump to that thumb's movable min/max; `PageUp`/`PageDown`
+ *   move by ten steps. A thumb never crosses the other.
+ * - Pointer press/drag on the track moves the nearest thumb.
+ */
+declare class RangeSliderController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        min: {
+            type: NumberConstructor;
+            default: number;
+        };
+        max: {
+            type: NumberConstructor;
+            default: number;
+        };
+        step: {
+            type: NumberConstructor;
+            default: number;
+        };
+        start: {
+            type: NumberConstructor;
+            default: number;
+        };
+        end: {
+            type: NumberConstructor;
+            default: number;
+        };
+    };
+    static actions: readonly ["onKeydown", "onPointerDown"];
+    static events: readonly ["change"];
+    readonly trackTarget: HTMLElement;
+    readonly startThumbTarget: HTMLElement;
+    readonly endThumbTarget: HTMLElement;
+    readonly hasTrackTarget: boolean;
+    readonly hasStartThumbTarget: boolean;
+    readonly hasEndThumbTarget: boolean;
+    minValue: number;
+    maxValue: number;
+    stepValue: number;
+    startValue: number;
+    endValue: number;
+    /** Normalizes the initial pair (clamped, snapped, ordered) and renders. */
+    connect(): void;
+    /** Cancels any active pointer drag so document listeners never leak. */
+    disconnect(): void;
+    /** Keyboard stepping for whichever thumb is focused (the action's element). */
+    onKeydown(event: KeyboardEvent): void;
+    /** Begins a pointer drag on the track, moving the thumb nearest the press. */
+    onPointerDown(event: PointerEvent): void;
+}
+
+/**
+ * Headless "read more / truncate" behavior for visually clamped text.
+ *
+ * Markup contract (identifier: `stimeo--read-more`):
+ *   <div data-controller="stimeo--read-more">
+ *     <p id="bio" data-stimeo--read-more-target="content" data-state="collapsed">…</p>
+ *     <button data-stimeo--read-more-target="trigger"
+ *             data-action="stimeo--read-more#toggle"
+ *             aria-expanded="false" aria-controls="bio" hidden>Read more</button>
+ *   </div>
+ *
+ * There is no dedicated APG widget; the toggle borrows the **Disclosure**
+ * convention (`aria-expanded`). The visual clamp itself (`-webkit-line-clamp`
+ * etc.) is the consumer's CSS, keyed off `data-state`.
+ *
+ * @remarks
+ * Behavior only. The full text always stays in the DOM — the clamp is purely
+ * visual, so assistive technology reads everything regardless of state; here
+ * `aria-expanded` therefore signals the *visual* expansion, not content hidden
+ * from AT. The controller's extra job is **overflow detection**: when the
+ * content is not actually clamped (it fits), the toggle is `hidden` so no
+ * pointless "read more" is offered. This is re-evaluated on resize.
+ */
+declare class ReadMoreController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        collapsed: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    static actions: readonly ["toggle"];
+    readonly contentTarget: HTMLElement;
+    readonly triggerTarget: HTMLElement;
+    readonly hasContentTarget: boolean;
+    readonly hasTriggerTarget: boolean;
+    collapsedValue: boolean;
+    connect(): void;
+    disconnect(): void;
+    /** Toggles between the collapsed (clamped) and expanded states. */
+    toggle(): void;
+}
+
+/**
+ * Headless **Scroll Restore** behavior: persists and restores the scroll
+ * position of an inner scrolling region across Turbo Drive navigations (and full
+ * reloads within the same tab session). No APG widget — a pure state-preservation
+ * utility, like {@link import("./scroll_visibility_controller").ScrollVisibilityController}
+ * and the Sticky State Observer.
+ *
+ * Markup contract (identifier: `stimeo--scroll-restore`):
+ *   <div data-controller="stimeo--scroll-restore"
+ *        data-stimeo--scroll-restore-key-value="sidebar"
+ *        style="overflow: auto">
+ *     …long content…
+ *   </div>
+ *
+ * Turbo swaps the whole `<body>` on navigation, so an inner scroll container is
+ * rebuilt with `scrollTop` reset to 0. Rather than have every app hand-write a
+ * controller for this (which contradicts a "ship the behavior" library), this
+ * persists the offset under a stable key in `sessionStorage` and restores it on
+ * `connect()`.
+ *
+ * @remarks
+ * Behavior only — it sets no ARIA/`data-*`/CSS and never moves focus (restore is
+ * a plain `scrollTop`/`scrollLeft` assignment). The `scroll` listener is internal
+ * and `passive` (no consumer `data-action` needed): each event records the live
+ * offset synchronously, and a `requestAnimationFrame` coalesces the writes to
+ * `sessionStorage`. On `disconnect()` (Turbo navigation included) it flushes the
+ * **last captured** offset rather than re-reading the element — by the time Turbo
+ * fires `disconnect` it has already detached the node, whose `scrollTop` then
+ * reads `0`, so a fresh read would clobber the saved position with `0`. Keying by
+ * `key` (falling back to the element `id`) in `sessionStorage` makes it
+ * multi-instance safe and survives full reloads — unlike a module-scope variable,
+ * which only survives Turbo Drive and assumes a single instance.
+ */
+declare class ScrollRestoreController extends Controller<HTMLElement> {
+    #private;
+    static values: {
+        key: {
+            type: StringConstructor;
+            default: string;
+        };
+        axis: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    keyValue: string;
+    axisValue: string;
+    connect(): void;
+    disconnect(): void;
+}
+
+/**
+ * Headless **Separator** behavior (APG Separator pattern).
+ *
+ * Markup contract (identifier: `stimeo--separator`):
+ *   <!-- decorative -->
+ *   <div data-controller="stimeo--separator" role="separator"
+ *        data-stimeo--separator-orientation-value="horizontal"></div>
+ *
+ *   <!-- focusable, value-bearing -->
+ *   <div data-controller="stimeo--separator" role="separator" tabindex="0"
+ *        aria-label="Resize sidebar" aria-orientation="vertical"
+ *        aria-valuemin="0" aria-valuemax="100" aria-valuenow="50"
+ *        data-stimeo--separator-focusable-value="true"
+ *        data-action="keydown->stimeo--separator#onKeydown"></div>
+ *
+ * Most separators are static (`role="separator"` + `aria-orientation`); this
+ * controller adds those semantics and, for the optional **focusable** variant,
+ * keeps `aria-valuenow` in sync and emits arrow-key value changes. The actual
+ * pane resize/drag is out of scope — that belongs to {@link ResizableController}.
+ *
+ * @remarks
+ * Behavior only — line drawing is the consumer's CSS. Increment direction
+ * follows the slider convention: ArrowUp/ArrowRight increase, ArrowDown/ArrowLeft
+ * decrease, scoped to the relevant axis for the orientation.
+ */
+declare class SeparatorController extends Controller<HTMLElement> {
+    #private;
+    static values: {
+        orientation: {
+            type: StringConstructor;
+            default: string;
+        };
+        focusable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        step: {
+            type: NumberConstructor;
+            default: number;
+        };
+    };
+    static actions: readonly ["onKeydown"];
+    static events: readonly ["change"];
+    orientationValue: string;
+    focusableValue: boolean;
+    stepValue: number;
+    connect(): void;
+    /** Adjusts the value on arrow / Home / End keys (focusable variant only). */
+    onKeydown(event: KeyboardEvent): void;
+}
+
+/**
+ * Headless, accessible **responsive collapsible sidebar** behavior.
+ *
+ * Markup contract (identifier: `stimeo--sidebar`):
+ *   <div data-controller="stimeo--sidebar"
+ *        data-stimeo--sidebar-breakpoint-value="768"
+ *        data-stimeo--sidebar-key-value="main-nav">
+ *     <header>
+ *       <button data-stimeo--sidebar-target="trigger"
+ *               data-action="click->stimeo--sidebar#toggle"
+ *               aria-expanded="true" aria-controls="app-sidebar">Menu</button>
+ *     </header>
+ *     <div data-stimeo--sidebar-target="backdrop"
+ *          data-action="click->stimeo--sidebar#close" hidden></div>
+ *     <aside id="app-sidebar" data-stimeo--sidebar-target="panel"
+ *            aria-label="Main" data-mode="inline" data-state="expanded">
+ *       <nav aria-label="…">…</nav>
+ *     </aside>
+ *   </div>
+ *   <main>…</main>   <!-- a body-level sibling so it can be made inert in overlay -->
+ *
+ * No dedicated APG pattern: the base is **Disclosure** (the trigger's
+ * `aria-expanded` controls the panel's expanded state) and, *below* the
+ * `breakpoint`, it borrows the **Dialog (Modal)** focus behavior via the shared
+ * {@link FocusTrap} (the same trap used by dialog / alert-dialog / drawer).
+ *
+ * Above the breakpoint it is an **inline**, non-modal element that toggles
+ * `expanded`↔`collapsed` (a rail), persisting that preference in `localStorage`.
+ * Below it, it becomes an **overlay** off-canvas panel: opening activates the
+ * trap (focus move, `Tab` cycle, `Escape`, body scroll lock, background `inert`,
+ * focus restore); closing defers `hidden` and the trap teardown until the exit
+ * transition ends (synchronously when there is none).
+ *
+ * @remarks
+ * Behavior only — rail width, slide, and backdrop are the consumer's CSS, keyed
+ * off `data-mode` (`inline`/`overlay`) and `data-state`. `aria-expanded` is an
+ * abstract "is the panel expanded" flag, independent of the visual difference
+ * between an inline collapsed rail (still in the DOM) and an overlay closed panel
+ * (`hidden`/off-canvas). The `role="dialog"` semantics are intentionally **not**
+ * applied — the sidebar stays an `<aside>`/`<nav>` landmark and only borrows the
+ * modal *behavior* (cf. drawer's note on `<aside role="dialog">` conflicts).
+ * The collapsed preference persists across Turbo navigations and full reloads;
+ * the transient overlay-open state never persists, so "back/forward" never
+ * restores a stuck-open menu.
+ */
+declare class SidebarController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        breakpoint: {
+            type: NumberConstructor;
+            default: number;
+        };
+        key: {
+            type: StringConstructor;
+            default: string;
+        };
+        collapsed: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    static actions: readonly ["close", "open", "toggle"];
+    readonly triggerTarget: HTMLElement;
+    readonly panelTarget: HTMLElement;
+    readonly backdropTarget: HTMLElement;
+    readonly hasTriggerTarget: boolean;
+    readonly hasPanelTarget: boolean;
+    readonly hasBackdropTarget: boolean;
+    breakpointValue: number;
+    keyValue: string;
+    collapsedValue: boolean;
+    connect(): void;
+    disconnect(): void;
+    /** Toggles the panel: inline flips collapsed/expanded, overlay flips open/closed. */
+    toggle(): void;
+    /** Shows the panel (inline: expand; overlay: open). */
+    open(): void;
+    /** Hides the panel (inline: collapse; overlay: close). */
+    close(): void;
+}
+
+/**
+ * Headless, accessible free-input tags / chips field.
+ *
+ * Markup contract (identifier: `stimeo--tags-input`):
+ *   <div data-controller="stimeo--tags-input"
+ *        data-stimeo--tags-input-delimiter-value=",">
+ *     <ul role="list" aria-label="Tags" data-stimeo--tags-input-target="tags"></ul>
+ *     <input type="text" aria-label="Add tag" aria-describedby="tags-help"
+ *            data-stimeo--tags-input-target="input"
+ *            data-action="keydown->stimeo--tags-input#onKeydown" />
+ *     <span role="status" aria-live="polite" class="visually-hidden"
+ *           data-stimeo--tags-input-target="status"></span>
+ *     <div data-stimeo--tags-input-target="fields"></div>
+ *     <template data-stimeo--tags-input-target="tagTemplate">
+ *       <li role="listitem" data-stimeo--tags-input-target="tag">
+ *         <span data-tags-input-slot="label"></span>
+ *         <!-- Removal is delegated on the tags container; no per-chip action needed. -->
+ *         <button type="button" tabindex="-1">×</button>
+ *       </li>
+ *     </template>
+ *   </div>
+ *
+ * There is no single established APG pattern; this composes a labeled text input
+ * with a roving-tabindex list of removable chips, mapping to WCAG 2.1.1, 2.4.7,
+ * 4.1.2, 4.1.3, and 1.3.1. Unlike {@link MultiSelectController} (pick from a
+ * candidate list) the user types arbitrary strings.
+ *
+ * Behavior provided:
+ * - `Enter` or the configured delimiter commits the trimmed input as a tag.
+ * - Empty / duplicate / over-limit additions are rejected with
+ *   `stimeo--tags-input:reject`; duplicates are allowed when `allowDuplicates`.
+ * - Tags render from the `tagTemplate`, each with a `Remove {label}` button; the
+ *   `fields` container mirrors the tag set as `name`d hidden inputs for form
+ *   submission, and every change dispatches `stimeo--tags-input:change`.
+ * - The remove buttons form one roving Tab stop: `ArrowLeft`/`ArrowRight` move
+ *   between them (right past the end returns to the input), `Delete`/`Backspace`
+ *   delete the focused tag, and `Backspace` on an empty input deletes the last.
+ * - Removing a tag moves focus to the neighboring tag, else back to the input.
+ */
+declare class TagsInputController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        delimiter: {
+            type: StringConstructor;
+            default: string;
+        };
+        max: {
+            type: NumberConstructor;
+            default: number;
+        };
+        allowDuplicates: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        name: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    static actions: readonly ["onKeydown"];
+    static events: readonly ["change", "reject"];
+    readonly inputTarget: HTMLInputElement;
+    readonly tagsTarget: HTMLElement;
+    readonly tagTargets: HTMLElement[];
+    readonly tagTemplateTarget: HTMLTemplateElement;
+    readonly statusTarget: HTMLElement;
+    readonly fieldsTarget: HTMLElement;
+    readonly hasStatusTarget: boolean;
+    readonly hasFieldsTarget: boolean;
+    readonly hasTagTemplateTarget: boolean;
+    delimiterValue: string;
+    maxValue: number;
+    allowDuplicatesValue: boolean;
+    nameValue: string;
+    /** Wires tag-list keyboard navigation and removal, and seeds the single Tab stop. */
+    connect(): void;
+    /** Releases the delegated listeners so no handler outlives the element. */
+    disconnect(): void;
+    /** Commits on `Enter`/delimiter and deletes the last tag on empty `Backspace`. */
+    onKeydown(event: KeyboardEvent): void;
+}
+
+/**
+ * Headless, accessible **time picker** behavior. Each segment (hour, minute,
+ * optional second, optional AM/PM) is an APG **Spinbutton**; the controller
+ * composes them into an `HH:MM[:SS]` value mirrored to a hidden field.
+ *
+ * Markup contract (identifier: `stimeo--time-picker`):
+ *   <div data-controller="stimeo--time-picker"
+ *        data-stimeo--time-picker-hour-cycle-value="24"
+ *        role="group" aria-label="Time">
+ *     <span role="spinbutton" aria-label="Hours" tabindex="0"
+ *           aria-valuenow="9" aria-valuemin="0" aria-valuemax="23" aria-valuetext="09"
+ *           data-segment="hour" data-stimeo--time-picker-target="segment"
+ *           data-action="keydown->stimeo--time-picker#onKeydown">09</span>
+ *     <span aria-hidden="true">:</span>
+ *     <span role="spinbutton" aria-label="Minutes" tabindex="0"
+ *           data-segment="minute" data-stimeo--time-picker-target="segment"
+ *           data-action="keydown->stimeo--time-picker#onKeydown">30</span>
+ *     <input type="hidden" data-stimeo--time-picker-target="field" />
+ *   </div>
+ *
+ * @remarks
+ * Behavior only — no styling, no locale formatting. Every segment is its own Tab
+ * stop (multi-tabstop, *not* roving); `ArrowLeft`/`ArrowRight` are an auxiliary
+ * move between segments. `ArrowUp`/`ArrowDown` step the focused segment, wrapping
+ * (and, when `wrap` is set, carrying minutes→hours and seconds→minutes). Typing
+ * digits enters a value directly and advances after two digits. AM/PM is modeled
+ * as a `meridiem` spinbutton that toggles; the hidden field is always 24-hour.
+ */
+declare class TimePickerController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static values: {
+        hourCycle: {
+            type: NumberConstructor;
+            default: number;
+        };
+        step: {
+            type: NumberConstructor;
+            default: number;
+        };
+        seconds: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        wrap: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    static actions: readonly ["onKeydown"];
+    static events: readonly ["change"];
+    readonly segmentTargets: HTMLElement[];
+    readonly fieldTarget: HTMLInputElement;
+    readonly hasFieldTarget: boolean;
+    hourCycleValue: number;
+    stepValue: number;
+    secondsValue: boolean;
+    wrapValue: boolean;
+    /** Seeds each segment from its initial `aria-valuenow` and syncs the field. */
+    connect(): void;
+    /** Handles stepping, inter-segment focus moves, jumps, and direct entry. */
+    onKeydown(event: KeyboardEvent): void;
+}
+
+/**
+ * Headless, accessible single-select tree view.
+ *
+ * Markup contract (identifier: `stimeo--tree-view`):
+ *   <ul data-controller="stimeo--tree-view" role="tree" aria-label="Files">
+ *     <li role="treeitem" aria-expanded="false" aria-selected="false" tabindex="0"
+ *         data-stimeo--tree-view-target="item"
+ *         data-action="keydown->stimeo--tree-view#onKeydown
+ *                      click->stimeo--tree-view#onClick">
+ *       <span>src</span>
+ *       <ul role="group" data-stimeo--tree-view-target="group" hidden>
+ *         <li role="treeitem" aria-selected="false" tabindex="-1"
+ *             data-stimeo--tree-view-target="item" data-action="…">…</li>
+ *       </ul>
+ *     </li>
+ *   </ul>
+ *
+ * Implements the WAI-ARIA APG **Tree View** (single-select) pattern. Parent/child
+ * structure is read from the DOM nesting (`treeitem` → child `group`). The whole
+ * tree is one Tab stop (roving tabindex); arrows navigate visible items, expand /
+ * collapse, and move between parent and child.
+ *
+ * Behavior provided:
+ * - `ArrowDown`/`ArrowUp` move between visible items; `Home`/`End` jump to the
+ *   first / last visible item; printable characters typeahead by label prefix.
+ * - `ArrowRight` expands a collapsed parent or steps into its first child;
+ *   `ArrowLeft` collapses an expanded parent or steps to the parent item.
+ * - `Enter`/`Space`/click select the item (single selection via `aria-selected`).
+ * - `aria-expanded` and each child `group`'s `hidden` stay in sync, dispatching
+ *   `stimeo--tree-view:toggle`; selection dispatches `stimeo--tree-view:select`.
+ */
+declare class TreeViewController extends Controller<HTMLElement> {
+    #private;
+    static targets: string[];
+    static actions: readonly ["onClick", "onKeydown"];
+    static events: readonly ["select", "toggle"];
+    readonly itemTargets: HTMLElement[];
+    /** Establishes the single tab stop (keeps an existing one, else the first). */
+    connect(): void;
+    /** Clears the pending typeahead-reset timer. */
+    disconnect(): void;
+    /**
+     * Routes tree keyboard interaction. Because `treeitem`s nest, only the handler
+     * on the nearest item to the event target acts; the same keydown bubbling to an
+     * ancestor item's handler is ignored to avoid double moves / selections.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /** Selects the clicked item (nearest to the target only). */
+    onClick(event: Event): void;
+}
+
+/**
+ * Maps Stimeo controller identifiers to their controller classes.
+ * Identifiers use the official `stimeo--` namespace.
+ */
+declare const stimeoControllers: {
+    readonly "stimeo--accordion": typeof AccordionController;
+    readonly "stimeo--alert-dialog": typeof AlertDialogController;
+    readonly "stimeo--announcer": typeof AnnouncerController;
+    readonly "stimeo--aspect-ratio": typeof AspectRatioController;
+    readonly "stimeo--auto-submit": typeof AutoSubmitController;
+    readonly "stimeo--avatar": typeof AvatarController;
+    readonly "stimeo--breadcrumb": typeof BreadcrumbController;
+    readonly "stimeo--bulk-select": typeof BulkSelectController;
+    readonly "stimeo--calendar": typeof CalendarController;
+    readonly "stimeo--carousel": typeof CarouselController;
+    readonly "stimeo--character-counter": typeof CharacterCounterController;
+    readonly "stimeo--checkbox": typeof CheckboxController;
+    readonly "stimeo--clipboard": typeof ClipboardController;
+    readonly "stimeo--collapsible": typeof CollapsibleController;
+    readonly "stimeo--color-picker": typeof ColorPickerController;
+    readonly "stimeo--combobox": typeof ComboboxController;
+    readonly "stimeo--command-palette": typeof CommandPaletteController;
+    readonly "stimeo--conditional-fields": typeof ConditionalFieldsController;
+    readonly "stimeo--confirm": typeof ConfirmController;
+    readonly "stimeo--context-menu": typeof ContextMenuController;
+    readonly "stimeo--countdown": typeof CountdownController;
+    readonly "stimeo--currency-input": typeof CurrencyInputController;
+    readonly "stimeo--data-grid": typeof DataGridController;
+    readonly "stimeo--date-range-picker": typeof DateRangePickerController;
+    readonly "stimeo--dialog": typeof DialogController;
+    readonly "stimeo--direct-upload": typeof DirectUploadController;
+    readonly "stimeo--dirty-form": typeof DirtyFormController;
+    readonly "stimeo--dismissible": typeof DismissibleController;
+    readonly "stimeo--drawer": typeof DrawerController;
+    readonly "stimeo--dropdown": typeof DropdownController;
+    readonly "stimeo--editable": typeof EditableController;
+    readonly "stimeo--empty-state": typeof EmptyStateController;
+    readonly "stimeo--file-dropzone": typeof FileDropzoneController;
+    readonly "stimeo--filter": typeof FilterController;
+    readonly "stimeo--flash": typeof FlashController;
+    readonly "stimeo--focus": typeof FocusController;
+    readonly "stimeo--form-field": typeof FormFieldController;
+    readonly "stimeo--form-validation": typeof FormValidationController;
+    readonly "stimeo--frame-loading": typeof FrameLoadingController;
+    readonly "stimeo--highlight": typeof HighlightController;
+    readonly "stimeo--hover-card": typeof HoverCardController;
+    readonly "stimeo--idle": typeof IdleController;
+    readonly "stimeo--input-mask": typeof InputMaskController;
+    readonly "stimeo--lazy-frame": typeof LazyFrameController;
+    readonly "stimeo--listbox": typeof ListboxController;
+    readonly "stimeo--local-time": typeof LocalTimeController;
+    readonly "stimeo--masonry": typeof MasonryController;
+    readonly "stimeo--menu": typeof MenuController;
+    readonly "stimeo--menubar": typeof MenubarController;
+    readonly "stimeo--meter": typeof MeterController;
+    readonly "stimeo--multi-select": typeof MultiSelectController;
+    readonly "stimeo--navigation-menu": typeof NavigationMenuController;
+    readonly "stimeo--nested-form": typeof NestedFormController;
+    readonly "stimeo--network-status": typeof NetworkStatusController;
+    readonly "stimeo--number-input": typeof NumberInputController;
+    readonly "stimeo--otp": typeof OtpController;
+    readonly "stimeo--overflow-indicator": typeof OverflowIndicatorController;
+    readonly "stimeo--overflow-menu": typeof OverflowMenuController;
+    readonly "stimeo--pagination": typeof PaginationController;
+    readonly "stimeo--password-reveal": typeof PasswordRevealController;
+    readonly "stimeo--password-strength": typeof PasswordStrengthController;
+    readonly "stimeo--persist": typeof PersistController;
+    readonly "stimeo--popover": typeof PopoverController;
+    readonly "stimeo--portal": typeof PortalController;
+    readonly "stimeo--preview-guard": typeof PreviewGuardController;
+    readonly "stimeo--progress": typeof ProgressController;
+    readonly "stimeo--radio-group": typeof RadioGroupController;
+    readonly "stimeo--range-slider": typeof RangeSliderController;
+    readonly "stimeo--rating": typeof RatingController;
+    readonly "stimeo--read-more": typeof ReadMoreController;
+    readonly "stimeo--relative-time": typeof RelativeTimeController;
+    readonly "stimeo--reset-before-cache": typeof ResetBeforeCacheController;
+    readonly "stimeo--resizable": typeof ResizableController;
+    readonly "stimeo--roving": typeof RovingController;
+    readonly "stimeo--scroll-area": typeof ScrollAreaController;
+    readonly "stimeo--scroll-restore": typeof ScrollRestoreController;
+    readonly "stimeo--scroll-visibility": typeof ScrollVisibilityController;
+    readonly "stimeo--scrollspy": typeof ScrollspyController;
+    readonly "stimeo--separator": typeof SeparatorController;
+    readonly "stimeo--sidebar": typeof SidebarController;
+    readonly "stimeo--skeleton": typeof SkeletonController;
+    readonly "stimeo--slider": typeof SliderController;
+    readonly "stimeo--spinner": typeof SpinnerController;
+    readonly "stimeo--step-indicator": typeof StepIndicatorController;
+    readonly "stimeo--stepper": typeof StepperController;
+    readonly "stimeo--stick-to-bottom": typeof StickToBottomController;
+    readonly "stimeo--sticky-observer": typeof StickyObserverController;
+    readonly "stimeo--submit-once": typeof SubmitOnceController;
+    readonly "stimeo--switch": typeof SwitchController;
+    readonly "stimeo--tabs": typeof TabsController;
+    readonly "stimeo--tags-input": typeof TagsInputController;
+    readonly "stimeo--textarea-autosize": typeof TextareaAutosizeController;
+    readonly "stimeo--theme": typeof ThemeController;
+    readonly "stimeo--time-picker": typeof TimePickerController;
+    readonly "stimeo--toast": typeof ToastController;
+    readonly "stimeo--toggle-group": typeof ToggleGroupController;
+    readonly "stimeo--toolbar": typeof ToolbarController;
+    readonly "stimeo--tooltip": typeof TooltipController;
+    readonly "stimeo--transition": typeof TransitionController;
+    readonly "stimeo--tree-view": typeof TreeViewController;
+};
+/**
+ * Registers all official Stimeo controllers on a Stimulus Application.
+ *
+ * @param application - The Stimulus application to register controllers on.
+ *
+ * @example
+ * ```ts
+ * import { Application } from "@hotwired/stimulus";
+ * import { registerStimeo } from "stimeo-ui";
+ *
+ * const application = Application.start();
+ * registerStimeo(application);
+ * ```
+ */
+declare function registerStimeo(application: Application): void;
+
+export { AccordionController, AlertDialogController, AnnouncerController, AspectRatioController, AutoSubmitController, AvatarController, BreadcrumbController, BulkSelectController, CalendarController, CarouselController, CharacterCounterController, CheckboxController, ClipboardController, CollapsibleController, ColorPickerController, ComboboxController, CommandPaletteController, ConditionalFieldsController, ConfirmController, ContextMenuController, CountdownController, CurrencyInputController, DataGridController, DateRangePickerController, DialogController, DirectUploadController, DirtyFormController, DismissibleController, DrawerController, DropdownController, EditableController, EmptyStateController, FileDropzoneController, FilterController, FlashController, FocusController, FormFieldController, FormValidationController, FrameLoadingController, HighlightController, HoverCardController, IdleController, InputMaskController, LazyFrameController, ListboxController, LocalTimeController, MasonryController, MenuController, MenubarController, MeterController, MultiSelectController, NavigationMenuController, NestedFormController, NetworkStatusController, NumberInputController, OtpController, OverflowIndicatorController, OverflowMenuController, PaginationController, PasswordRevealController, PasswordStrengthController, PersistController, PopoverController, PortalController, PreviewGuardController, ProgressController, RadioGroupController, RangeSliderController, RatingController, ReadMoreController, RelativeTimeController, ResetBeforeCacheController, ResizableController, RovingController, ScrollAreaController, ScrollRestoreController, ScrollVisibilityController, ScrollspyController, SeparatorController, SidebarController, SkeletonController, SliderController, SpinnerController, StepIndicatorController, StepperController, StickToBottomController, StickyObserverController, SubmitOnceController, SwitchController, TabsController, TagsInputController, TextareaAutosizeController, ThemeController, TimePickerController, ToastController, ToggleGroupController, ToolbarController, TooltipController, TransitionController, TreeViewController, registerStimeo, stimeoControllers };