stimeo-ui 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { Controller, Application } from '@hotwired/stimulus';
+import { Application } from '@hotwired/stimulus';
 import { AccordionController } from './controllers/accordion_controller.js';
+import { AlertDialogController } from './controllers/alert_dialog_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';
@@ -7,8 +8,12 @@ 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 { CarouselController } from './controllers/carousel_controller.js';
 import { CharacterCounterController } from './controllers/character_counter_controller.js';
 import { CheckboxController } from './controllers/checkbox_controller.js';
+import { ClipboardController } from './controllers/clipboard_controller.js';
+import { CollapsibleController } from './controllers/collapsible_controller.js';
+import { ColorPickerController } from './controllers/color_picker_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';
@@ -16,11 +21,19 @@ import { ConfirmController } from './controllers/confirm_controller.js';
 import { ContextMenuController } from './controllers/context_menu_controller.js';
 import { CountUpController } from './controllers/count_up_controller.js';
 import { CountdownController } from './controllers/countdown_controller.js';
+import { CurrencyInputController } from './controllers/currency_input_controller.js';
+import { DataGridController } from './controllers/data_grid_controller.js';
+import { DateRangePickerController } from './controllers/date_range_picker_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 { DismissibleController } from './controllers/dismissible_controller.js';
+import { DrawerController } from './controllers/drawer_controller.js';
 import { DropdownController } from './controllers/dropdown_controller.js';
+import { EditableController } from './controllers/editable_controller.js';
 import { EmptyStateController } from './controllers/empty_state_controller.js';
+import { FileDropzoneController } from './controllers/file_dropzone_controller.js';
+import { FilterController } from './controllers/filter_controller.js';
 import { FlashController } from './controllers/flash_controller.js';
 import { FocusController } from './controllers/focus_controller.js';
 import { FormFieldController } from './controllers/form_field_controller.js';
@@ -34,8 +47,12 @@ import { IntersectionController } from './controllers/intersection_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 { MasonryController } from './controllers/masonry_controller.js';
 import { MenuController } from './controllers/menu_controller.js';
+import { MenubarController } from './controllers/menubar_controller.js';
 import { MeterController } from './controllers/meter_controller.js';
+import { MultiSelectController } from './controllers/multi_select_controller.js';
+import { NavigationMenuController } from './controllers/navigation_menu_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';
@@ -44,6 +61,7 @@ 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 { PasswordRevealController } from './controllers/password_reveal_controller.js';
 import { PasswordStrengthController } from './controllers/password_strength_controller.js';
 import { PersistController } from './controllers/persist_controller.js';
 import { PointerDragController } from './controllers/pointer_drag_controller.js';
@@ -52,15 +70,20 @@ 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 { RangeSliderController } from './controllers/range_slider_controller.js';
 import { RatingController } from './controllers/rating_controller.js';
+import { ReadMoreController } from './controllers/read_more_controller.js';
 import { ReadingProgressController } from './controllers/reading_progress_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 { ScrollRestoreController } from './controllers/scroll_restore_controller.js';
 import { ScrollVisibilityController } from './controllers/scroll_visibility_controller.js';
 import { ScrollspyController } from './controllers/scrollspy_controller.js';
+import { SeparatorController } from './controllers/separator_controller.js';
+import { SidebarController } from './controllers/sidebar_controller.js';
 import { SkeletonController } from './controllers/skeleton_controller.js';
 import { SliderController } from './controllers/slider_controller.js';
 import { SmartStickyHeaderController } from './controllers/smart_sticky_header_controller.js';
@@ -73,1830 +96,16 @@ import { StickyObserverController } from './controllers/sticky_observer_controll
 import { SubmitOnceController } from './controllers/submit_once_controller.js';
 import { SwitchController } from './controllers/switch_controller.js';
 import { TabsController } from './controllers/tabs_controller.js';
+import { TagsInputController } from './controllers/tags_input_controller.js';
 import { TextareaAutosizeController } from './controllers/textarea_autosize_controller.js';
 import { ThemeController } from './controllers/theme_controller.js';
+import { TimePickerController } from './controllers/time_picker_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;
-    /** Keeps the Escape listener aligned with a live `closeOnEscape` Value. */
-    closeOnEscapeValueChanged(): 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" hidden>
- *       <div 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>
- *       </div>
- *     </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. Keys
- *   pressed during an IME composition act on the composition, never the edit:
- *   a conversion-cancelling `Escape` keeps editing and a conversion-confirming
- *   `Enter` never saves (lifecycle-tracked, covering events that omit
- *   `isComposing`).
- * - 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;
-    /** Releases the composition listeners so nothing outlives the element. */
-    disconnect(): void;
-    /** Tracks an input added initially or after connect (e.g. a Turbo swap). */
-    inputTargetConnected(input: HTMLElement): void;
-    /** Removes composition listeners when the active input is replaced or removed. */
-    inputTargetDisconnected(input: HTMLElement): 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 — while a menu is open the menubar is a
- * layer on the shared {@link EscapeLayer} stack, claiming a press only while
- * focus is inside the controller or fell to the body, so one keypress closes
- * exactly one layer (the shared layered-Escape contract). `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, stack membership, 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"
- *            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>
- *     <!-- Optional: submit the selection as name="fruits[]" hidden inputs. -->
- *     <div data-stimeo--multi-select-target="fields"></div>
- *     <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).
- * - With a `fields` target the selected values are mirrored into named hidden
- *   inputs (default name `options[]`), so the selection submits with a normal
- *   form and no consumer JS — parity with {@link TagsInputController}. An optional
- *   `form` value sets the hidden inputs' `form` attribute, associating them with a
- *   `<form>` by id even when the picker lives outside it. Purely additive: with no
- *   `fields` target the behavior is unchanged.
- */
-declare class MultiSelectController extends Controller<HTMLElement> {
-    #private;
-    static targets: string[];
-    static values: {
-        max: {
-            type: NumberConstructor;
-            default: number;
-        };
-        name: {
-            type: StringConstructor;
-            default: string;
-        };
-        form: {
-            type: StringConstructor;
-            default: string;
-        };
-    };
-    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 fieldsTarget: HTMLElement;
-    readonly hasListTarget: boolean;
-    readonly hasInputTarget: boolean;
-    readonly hasTagsTarget: boolean;
-    readonly hasTagTemplateTarget: boolean;
-    readonly hasStatusTarget: boolean;
-    readonly hasFieldsTarget: boolean;
-    maxValue: number;
-    nameValue: string;
-    formValue: string;
-    readonly hasFormValue: boolean;
-    /** 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;
-    /** Tracks an input added initially or after connect. */
-    inputTargetConnected(input: HTMLInputElement): void;
-    /** Removes composition listeners when the active input is replaced or removed. */
-    inputTargetDisconnected(input: HTMLInputElement): void;
-    /** Filters confirmed input text, opens, and re-seeds the active option. */
-    filter(event?: InputEvent): 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`. Focus is
-     * re-homed to the input afterwards: options are non-focusable, so the click blurs
-     * the input to `body` — and with the list deliberately staying open, every
-     * keyboard affordance (Escape, arrows, typing) is bound to the input and would
-     * otherwise go dead until the user clicks back in ("focus stays on the input").
-     */
-    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.
- * While a panel is open the nav is a layer on the shared {@link EscapeLayer}
- * stack; it claims a press only while focus is inside the nav or fell to the
- * body (a click on non-focusable panel content), so one keypress closes exactly
- * one layer (the shared layered-Escape contract). An outside click, or focus
- * leaving the nav for a known external destination, 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`.
- *
- * By default the hover region is each trigger and its panel. An optional
- * `hoverArea` target widens it: mark a wrapper that contains a trigger (e.g. the
- * `<li>` holding a top-level *link*, its disclosure button, and its panel — the
- * APG "Disclosure Navigation with Top-Level Links" arrangement) and hovering
- * anywhere over that wrapper opens the contained trigger's panel. A trigger or
- * panel inside a `hoverArea` defers to the wrapper (its own edges stop scheduling
- * open/close), so pointer movement within the area never flickers the panel.
- * Keep a trigger's panel inside its `hoverArea`: a panel left outside simply
- * falls back to the default two-region behavior — moving straight across a
- * shared edge never schedules a close (the leave handler checks
- * `relatedTarget`), and `hoverDelay` bridges the pointer's travel across an
- * actual gap. Targets added or removed while connected (e.g. a Turbo Stream
- * append) re-wire the hover listeners via Stimulus target callbacks.
- * `hoverArea` has no effect unless `openOnHover` is enabled.
- *
- * @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[];
-    readonly hoverAreaTargets: HTMLElement[];
-    openOnHoverValue: boolean;
-    hoverDelayValue: number;
-    /** Establishes the closed baseline and the dismissal listeners. */
-    connect(): void;
-    /** Removes every listener, pending hover timer, and stack membership registered while connected. */
-    disconnect(): void;
-    /** Re-wires hover listeners when a target is added after connect (Turbo Streams etc.). */
-    triggerTargetConnected(): void;
-    /** Re-wires hover listeners when a target is removed while connected. */
-    triggerTargetDisconnected(): void;
-    /** See {@link NavigationMenuController.triggerTargetConnected}. */
-    panelTargetConnected(): void;
-    /** See {@link NavigationMenuController.triggerTargetDisconnected}. */
-    panelTargetDisconnected(): void;
-    /** See {@link NavigationMenuController.triggerTargetConnected}. */
-    hoverAreaTargetConnected(): void;
-    /** See {@link NavigationMenuController.triggerTargetDisconnected}. */
-    hoverAreaTargetDisconnected(): 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;
-    readonly hasInputTarget: 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;
-    /** Tracks an input added initially or after connect. */
-    inputTargetConnected(input: HTMLInputElement): void;
-    /** Removes composition listeners when the active input is replaced or removed. */
-    inputTargetDisconnected(input: HTMLInputElement): 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;
-}
+import { TreeViewController } from './controllers/tree_view_controller.js';
 
 /**
  * Maps Stimeo controller identifiers to their controller classes.