@mkbabb/glass-ui 7.0.0 → 9.0.0

package/dist/composables/motion/morph/useSelectionIndicator.d.ts

@@ -1,4 +1,5 @@
 import { type Ref, type ComputedRef } from "vue";
+import type { SelectionValue } from "../../../components/_shared/selection.js";
 /**
  * useSelectionIndicator is the library's single traveling-indicator writer. The dock
  * is SegmentedTabs/ToggleGroup wearing chrome, so the indicator that glides under the active
@@ -12,12 +13,29 @@ import { type Ref, type ComputedRef } from "vue";
  *
  * It owns the JS-measured single-select slider style (the slider geometry, the
  * offset measure, the model/options re-measure watchers, the RO lifecycle) AND
- * the travel-squish: a velocity-driven, volume-preserving `--stretch`
- * scalar the active indicator reads so it STRETCHES along its travel axis as it
- * glides and settles to fit (the Material-3 ELASTIC, Apple Liquid-Glass
- * register, capped LOW). Honors `prefers-reduced-motion` (no squish under
- * reduce). The underline material SLIDES (no squish — a hairline does not
- * deform), gated by the caller passing no `indicatorRef` element.
+ * the travel deform: a velocity-driven `--stretch` scalar the active indicator
+ * reads so it lengthens along its travel axis as it glides and settles to fit
+ * (the Material-3 ELASTIC, Apple Liquid-Glass register). Honors
+ * `prefers-reduced-motion` (no deform under reduce).
+ *
+ * WHAT DEFORMS IS A POLICY, AND IT IS A PARAMETER. It used to be inferred from
+ * `indicatorRef` being null, which was an OVERLOADED sentinel: the same null meant
+ * "this group has no single slider" to `useSelectionGroup` and "this material does
+ * not squish" here, so neither meaning could be stated without lying about the
+ * other. `deform` says it outright:
+ *   • `"plate"` (default) — the full body: `--stretch` plus, where the surface arms
+ *     the organ, the EYEGLASS span/swell/lean. A body of glass with area to move.
+ *   • `"mark"` — `--stretch` only. A hairline lengthens along its travel; it has no
+ *     area to inflate and no cross axis to swell.
+ *   • `"none"` — no deform at all (a multi-toggle group has no single travelling
+ *     body to deform).
+ * The `if (!el)` guard below stays what it always should have been: null-safety.
+ *
+ * THE EYEGLASS is armed by the SURFACE, in its own cascade, by declaring
+ * `--eyeglass-span-max`. Where it is armed the deform stops being a centre-pump and
+ * becomes the measured organ — it spans origin and destination, leans 2:1 into its
+ * travel, swells across, and clamps at the track's inner edge. Where it is not
+ * declared the fraction law is byte-identical to what shipped. See `eyeglass.ts`.
  *
  * The writer emits the selected item's full physical border box from the
  * container's padding-box origin. Measuring both axes keeps the resting fill
@@ -25,12 +43,26 @@ import { type Ref, type ComputedRef } from "vue";
  * `vertical` param only selects the transient squish axis.
  *
  * Generic over the minimal `SelectionOption` shape (`value` + optional
- * `disabled`), so it is decoupled from any consumer's option type — the
- * `/motion-core` home carries no component-tree import.
+ * `disabled`), so it is decoupled from any consumer's option type. ~~the
+ * `/motion-core` home carries no component-tree import.~~
+ * [2026-08-08 · BK #84 C-1: it carries exactly one, `import type { SelectionValue }`,
+ * and the claim is restated at the level that is actually load-bearing — no
+ * component-tree RUNTIME import. A `type` import is erased at emit, so the
+ * `/motion-core` chunk's bytes are unchanged; what changed is that the scalar
+ * identity is now named once in the library instead of respelled here.]
+ */
+/**
+ * The minimal option shape the indicator measures against.
+ *
+ * `value` is the library's `SelectionValue` (BK #84 C-1). It used to be `string`,
+ * which is why `<ToggleGroup>` — whose public value has been `string | number`
+ * since it shipped — could not compose this engine without narrowing its own
+ * surface. Widening here rather than narrowing there is the direction C-1 ruled:
+ * the engine only ever compares the value with `===` and interpolates it into a
+ * reset key, so it never needed the narrower type in the first place.
  */
-/** The minimal option shape the indicator measures against. */
 export interface SelectionOption {
-    value: string;
+    value: SelectionValue;
     disabled?: boolean;
 }
 /**
@@ -42,15 +74,6 @@ export interface SelectionOption {
  * lockstep, never a fork).
  */
 export declare const DEFAULT_INDICATOR_MAX_STRETCH = 1.11;
-/**
- * Fallback for `--tab-indicator-blob-max` when the cascade leaves it unset: the
- * 5-beat blob's area-inflation overshoot peak. The 2nd `useLiquidFlex` channel
- * drives `--tab-blob` toward this on the grow-overshoot beat, then de-inflates
- * to 1 at arrival (shrink-to-fit). Kept LOW so the COMPOSED bbox area
- * (`blob × stretch` ≈ blob², the squish being volume-preserving) clears the
- * ≤ ~1.14 anti-taffy fence.
- */
-export declare const DEFAULT_INDICATOR_BLOB_MAX = 1.045;
 /**
  * The travel-progress fraction at which the squish RELEASES — the Material
  * "grow then shrink" close, keyed to ARRIVAL. The squish opens with the glide
@@ -58,6 +81,11 @@ export declare const DEFAULT_INDICATOR_BLOB_MAX = 1.045;
  * stretch peaks DURING travel and shrinks to fit AT arrival, never before.
  */
 export declare const INDICATOR_RELEASE_AT_ARRIVAL = 0.82;
+/**
+ * The deform POLICY — what the travelling body is made of, stated rather than
+ * inferred from a null ref. See the module docstring for why the sentinel had to go.
+ */
+export type SelectionDeform = "plate" | "mark" | "none";
 export interface UseSelectionIndicatorParams<O extends SelectionOption> {
     /** The container scroller root (observed by the ResizeObserver). */
     containerRef: Ref<HTMLElement | null>;
@@ -67,12 +95,14 @@ export interface UseSelectionIndicatorParams<O extends SelectionOption> {
     buttonRefs: Ref<HTMLElement[]>;
     /** The selectable options (re-measure on change). */
     options: ComputedRef<O[]>;
-    /** The active value (re-measure on change). */
-    model: Ref<string | undefined>;
+    /** The active value (re-measure on change), at the option type's own scalar. */
+    model: Ref<O["value"] | undefined>;
     /** The active option values (used by the initial squish seed). */
-    activeValues: ComputedRef<string[]>;
+    activeValues: ComputedRef<O["value"][]>;
     /** True for the vertical (block-axis) orientation. */
     vertical: ComputedRef<boolean>;
+    /** What the travelling body is made of. Defaults to `"plate"`. */
+    deform?: ComputedRef<SelectionDeform>;
 }
 export interface UseSelectionIndicatorReturn {
     /** Inline style for the single-select JS slider — the ONE writer. */

package/dist/composables/motion/number/useAnimatedNumberMap.d.ts

@@ -1,5 +1,5 @@
 import { type ComputedRef } from "vue";
-import { type UseAnimatedNumberOptions } from "./useAnimatedNumber";
+import { type UseAnimatedNumberOptions } from "./useAnimatedNumber.js";
 export interface UseAnimatedNumberMapOptions extends UseAnimatedNumberOptions {
 }
 /**

package/dist/composables/motion/pointer/pointerFieldMappings.d.ts

@@ -1,4 +1,4 @@
-import type { PointerVec2 } from "./usePointerVelocityField";
+import type { PointerVec2 } from "./usePointerVelocityField.js";
 export type { PointerVec2 };
 /**
  * A plain-value read of the pointer field for ONE frame. The renderer snapshots the field
@@ -20,47 +20,6 @@ export interface PointerFieldSnapshot {
     /** The smoothed active-engagement envelope (0..1). */
     engagement: number;
 }
-/** The default bias gain — the curve advances at most ±BIAS_GAIN faster/slower (≤0.15). */
-export declare const FOURIER_BIAS_GAIN = 0.15;
-/** The default centroid-lean fraction (the subtle lean). */
-export declare const FOURIER_FOLLOW_LEAN = 0.15;
-export interface FourierLeanGeometry {
-    /** The canvas backing aspect (w/h) — the model→clip fit inverse. */
-    aspect: number;
-    /** The fit scale (`model = center + clip·aspect / scale`). */
-    scale: number;
-    /**
-     * The head→cursor direction in CLIP space (the renderer computes it from the head
-     * model position + the cursor clip position). Its dot with the head's travel tangent
-     * is the draw-bias alignment. Omit (or zero) → no draw-bias (phaseRateMul = 1).
-     */
-    headToCursor?: PointerVec2;
-    /** The head's travel TANGENT (clip space), for the draw-bias alignment. Omit → no bias. */
-    headTangent?: PointerVec2;
-}
-export interface FourierLeanOptions {
-    /** The centroid-lean fraction (default {@link FOURIER_FOLLOW_LEAN}). */
-    lean?: number;
-    /** The draw-bias gain (default {@link FOURIER_BIAS_GAIN}; clamped ≤0.15). */
-    biasGain?: number;
-}
-export interface FourierLeanResult {
-    /** The MODEL-space centroid lean the setups subtract from `fit.center`. */
-    leanX: number;
-    leanY: number;
-    /**
-     * The clock phase-rate multiplier (1 = neutral). >1 draws toward the cursor a hair
-     * faster; <1 a hair slower. Bounded [1-biasGain, 1+biasGain].
-     */
-    phaseRateMul: number;
-}
-/**
- * The fourier draw-bias + subtle-lean mapping (PURE). The lean uses the SAME [0,1]→clip
- * (y-inverted) → model math the renderer inverts, at the subtle FOLLOW_LEAN (NOT the retired
- * FOLLOW_REACH teleport), scaled by engagement. The draw-bias modulates the clock phase-rate
- * by the head-tangent · head→cursor alignment, bounded by biasGain.
- */
-export declare function fourierLeanMapping(snap: PointerFieldSnapshot, geom: FourierLeanGeometry, options?: FourierLeanOptions): FourierLeanResult;
 /** The steady velocity-lead gain (the body anticipates the heading). */
 export declare const BLOB_LEAD_K = 0.09;
 /** The pseudopod stretch gain off |acceleration| (capped LOW so it swells, never taffies). */

package/dist/composables/motion/pointer/useRoutePointer.d.ts

@@ -1,5 +1,5 @@
 import { type MaybeRefOrGetter, type Ref } from "vue";
-import type { PointerVec2 } from "./usePointerVelocityField";
+import type { PointerVec2 } from "./usePointerVelocityField.js";
 export type { PointerVec2 };
 export interface RoutePointerContext {
     /** The viewport-normalized pointer (0..1 across the viewport). */

package/dist/composables/motion/reveal/useLiquidReveal.d.ts

@@ -1,8 +1,9 @@
 import { type ComponentPublicInstance, type Ref } from "vue";
-import { type ElementMorphPreset } from "../morph/useElementMorph";
-/** The reveal spring register — `snappy` (the quick app-open default) or `bouncy` (the
- *  emphatic large-dialog bloom). */
-export type LiquidRevealPreset = ElementMorphPreset;
+import { type ElementMorphPreset } from "../morph/useElementMorph.js";
+/** The reveal spring register — `bloom` (the room-sized growth, the default: a surface
+ *  expanding to fill a sheet or a screen IS this row's one job) or `panel` (the emphatic
+ *  fired deploy, the one row that rebounds). */
+export type LiquidRevealPreset = Extract<ElementMorphPreset, "bloom" | "panel">;
 export interface UseLiquidRevealOptions {
     /**
      * The trigger element the surface blooms FROM — the source rect (the button, the
@@ -12,7 +13,7 @@ export interface UseLiquidRevealOptions {
      * immediately; no invented geometry substitutes for a missing trigger.
      */
     trigger?: Ref<HTMLElement | ComponentPublicInstance | null>;
-    /** The spring register (default `snappy`). */
+    /** The spring register (default `bloom`). */
     preset?: LiquidRevealPreset;
     /** The starting filter-blur radius in px (the decongest start). Default 4. */
     blur?: number;
@@ -33,7 +34,7 @@ export interface UseLiquidRevealReturn {
  *
  * @example
  * ```ts
- * const { reveal, conceal } = useLiquidReveal(surfaceRef, { trigger: triggerRef, preset: "bouncy" })
+ * const { reveal, conceal } = useLiquidReveal(surfaceRef, { trigger: triggerRef, preset: "panel" })
  * watch(open, (o) => (o ? reveal() : conceal()))
  * ```
  */

package/dist/composables/motion/route/routeGrammar.d.ts

@@ -0,0 +1,60 @@
+import type { SpringPresetName } from "../spring/springPresets.js";
+/** The four nav classes. One mechanism each; a navigation is exactly one of them. */
+export type RouteNavClass = "route" | "zoom" | "lateral" | "collapse";
+/**
+ * A row is what the mechanism and the CSS mirror both READ. Nothing that neither reads
+ * belongs here: whether a window travels is `nav !== "route"` at the one site that needs
+ * it (`useRouteTransition`), and which channels a class moves is the recipe body's own
+ * keyframe list in `styles/view-transition.css` — a second copy of either would be prose
+ * in a type position, drifting the moment one of them is retuned.
+ */
+export interface RouteNavRow {
+    readonly nav: RouteNavClass;
+    /** The spring row the FOREGROUND binds, or `null` where the class takes a bezier. */
+    readonly foreground: SpringPresetName | null;
+    /** The bezier a `null`-foreground class takes instead (§7 — an exit is never a spring). */
+    readonly ease: "--ease-in" | null;
+    /** The row the WORLD recedes/recovers on; `null` where no world moves. */
+    readonly world: SpringPresetName | null;
+    /** The class's foreground clock: `duration` on an entrance, `exit-duration` on an exit. */
+    readonly clock: "duration" | "exit-duration";
+    /** The world starts only after the foreground is gone — an exit's recovery order. */
+    readonly worldWaitsForForeground: boolean;
+    readonly comment: string;
+}
+/** The grammar. Order is the reading order of the record, not a precedence. */
+export declare const ROUTE_GRAMMAR: readonly RouteNavRow[];
+/**
+ * The measured constants of the codex row, carried in ONE table.
+ *
+ * Every one traces to `EXEMPLARS-CODEX.md` rows I4 (`:131`, the icon↔app morph) and I4b
+ * (`:132`, the windowing transition). They are measurements of a corpus, not derivations,
+ * so they cannot be re-derived from the spring table — which is exactly why they are
+ * fenced here rather than sprinkled. Three of the four are mirrored into
+ * `tokens/motion-registers.css` for the recipe to read, and those two sites are the whole
+ * census: `route-motion.test.ts` reads every stylesheet under `src/` and every module on
+ * the `composables/motion` surface, comments and string literals stripped, and reds on a
+ * third site or on a `--route-*` token declared in a second file.
+ */
+export declare const ROUTE_CONSTANTS: {
+    /** I4: "the tapped icon alone scales to 1.57× in 42ms, razor sharp, z-lifted". */
+    readonly inhaleScale: 1.57;
+    /** I4, the same beat's window. The label is already gone by the time it ends. */
+    readonly inhaleMs: 42;
+    /** I4b: "the lateral push runs parallax ~1:8". One ratio, both parallax cases. */
+    readonly parallax: number;
+    /** I4: "opacity held then CUT at the last tenth" — the hold ends at 90% of the exit. */
+    readonly opacityCutAt: 0.9;
+};
+/** Look one class up by name. */
+export declare function routeNav(nav: RouteNavClass): RouteNavRow;
+/** The curve the foreground rides: a spring row's curve, or the exit bezier. */
+export declare function foregroundCurveToken(row: RouteNavRow): string;
+/**
+ * The foreground's clock. An exit reverses `zoom`, so it reads THAT row's exit reader —
+ * BK #26's law that a register binds the exit reader of its own entering row, which is
+ * what stops a recede outlasting the arrival it undoes.
+ */
+export declare function foregroundClockToken(row: RouteNavRow): string;
+/** The world's clock, or `null` where no world moves. */
+export declare function worldClockToken(row: RouteNavRow): string | null;

package/dist/composables/motion/route/useRouteTransition.d.ts

@@ -0,0 +1,45 @@
+import type { RouteNavClass } from "./routeGrammar.js";
+/** The name the travelling window carries. One per document state, always. */
+export declare const ROUTE_WINDOW_NAME = "gl-route-window";
+/** The name the window's own label carries, so it can leave before the window does. */
+export declare const ROUTE_LABEL_NAME = "gl-route-label";
+/** The attribute a destination marks its window with, read after the mutation. */
+export declare const ROUTE_WINDOW_ATTR = "data-route-window";
+/** The attribute a source marks its label with, read before the mutation. */
+export declare const ROUTE_LABEL_ATTR = "data-route-label";
+/** The root property the `lateral` class reads its push direction from. */
+export declare const ROUTE_DIRECTION_PROP = "--route-direction";
+export interface RouteTransitionOptions {
+    /** Which grammar class this navigation is. */
+    nav: RouteNavClass;
+    /** The DOM mutation — typically an awaited router push plus a render tick. */
+    mutate: () => void | Promise<void>;
+    /**
+     * The tapped element. Named `gl-route-window` for the OLD state; its
+     * `[data-route-label]` descendant, if any, is named `gl-route-label`.
+     */
+    source?: HTMLElement | null;
+    /**
+     * Resolves the destination's window AFTER `mutate` settles, still inside the update
+     * callback — the last moment before the new state is snapshotted.
+     */
+    target?: () => HTMLElement | null;
+    /** `lateral` only: +1 forward, −1 back, 0 unknown (the push degrades to a fade). */
+    direction?: number;
+}
+/**
+ * Run a route mutation under the typed grammar.
+ *
+ * @returns `{ finished }` — await it to route focus, per the substrate's a11y MANDATORY.
+ *
+ * @example
+ *   await routeTransition({
+ *       nav: "zoom",
+ *       source: cardEl,
+ *       target: () => document.querySelector("[data-route-window]"),
+ *       mutate: async () => { await router.push(to); await nextTick(); },
+ *   }).finished;
+ */
+export declare function routeTransition(options: RouteTransitionOptions): {
+    finished: Promise<void>;
+};

package/dist/composables/motion/scroll/useScrollProgress.d.ts

@@ -10,13 +10,6 @@ interface ScrollProgressConfig {
      * bottom, 1 when target top reaches viewport top.
      */
     trackExit?: boolean;
-    /**
-     * Keep the returned ref live even when CSS scroll timelines are available.
-     * Use this only when JavaScript consumes the value directly (for example a
-     * shader uniform); CSS-authored progress should keep the default compositor
-     * path and attach no reader.
-     */
-    reactive?: boolean;
     /** Attach the reader only while this source is truthy. */
     enabled?: MaybeRef<boolean>;
 }
@@ -25,13 +18,13 @@ interface ScrollProgressConfig {
  * `Ref<number>` in [0, 1]. Drives things like scroll-linked typography
  * axes, parallax depth, or progress indicators.
  *
- * On an engine with native scroll-driven animations, the listener +
- * `ResizeObserver` machinery does NOT attach — prefer the `.scroll-progress`
- * CSS recipe (scroll-driven.css), which runs the same 0..1 axis on the
- * compositor. This composable is the feature-detected fallback (the sole writer
- * when the native feature is absent); `computeProgress()` still runs once on
- * mount for a correct initial value. `reactive: true` is the explicit exception
- * for a non-CSS consumer such as a shader uniform.
+ * THE READER ALWAYS ATTACHES. The prior form gated the whole machine behind a
+ * module-load `supportsScrollTimeline()` probe, so on a supporting engine the
+ * returned ref froze at its mount value while reading alive at every call site —
+ * a silent inert arm, not a fallback (its ONE consumer opted out of it with
+ * `reactive: true`, which is how the arm survived untested in both directions).
+ * A CSS-authored axis belongs in the `.scroll-progress` recipe and never calls
+ * this composable at all; a caller who wants the NUMBER gets the number.
  */
 export declare function useScrollProgress(options: ScrollProgressConfig): Ref<number>;
 export {};

package/dist/composables/motion/scroll/useScrollScene.d.ts

@@ -1,5 +1,5 @@
 import { type MaybeRefOrGetter, type Ref } from "vue";
-import { type ScrollReader, type ScrollSource } from "./scrollReader";
+import { type ScrollReader, type ScrollSource } from "./scrollReader.js";
 /** The smoother register — a pure-lag low-pass (`SmoothProgress`) or an overshooting
  *  spring (`SpringProgress`). The FELT reveal wants the spring (it overshoots, then
  *  settles — the cartoon slam); the pure-lag legs (a progress number) want the smooth. */
@@ -28,13 +28,14 @@ export interface UseScrollSceneOptions {
     /** The smoother register (default `smooth` — the pure-lag low-pass). */
     register?: ScrollSceneRegister;
     /**
-     * For the `spring` register: the damping ratio ζ. < 1 overshoots (the felt slam),
-     * 0.85 ≈ the `--spring-gentle` identity. Default 0.85. Ignored for `smooth`.
+     * For the `spring` register: the damping ratio ζ. < 1 overshoots (the felt slam).
+     * Defaults to the `world` row's own damping — the substrate-travel register —
+     * read from the table rather than restated. Ignored for `smooth`.
      */
     dampingFraction?: number;
     /** The element the damped value is written onto as a custom property (when bound). */
     bindEl?: MaybeRefOrGetter<HTMLElement | null>;
-    /** The custom property name to write the damped 0..1 onto (e.g. `--pin-t`). */
+    /** The custom property name to write the damped 0..1 onto (e.g. `--scene-t`). */
     property?: string;
     /** Honor `prefers-reduced-motion: reduce` (scrub → 0, snap 1:1). Default true. */
     respectReducedMotion?: boolean;

package/dist/composables/motion/spring/springPresets.d.ts

@@ -1,5 +1,5 @@
 /** A glass-ui named-spring preset name. */
-export type SpringPresetName = "smooth" | "snappy" | "bouncy" | "gentle" | "dock" | "press" | "transient";
+export type SpringPresetName = "press" | "present" | "dock" | "panel" | "bloom" | "world";
 /** One named-spring row: the analytic (response, dampingFraction) pair + its register doc. */
 export interface SpringPresetRow {
     /** The token suffix for the generated `--spring-<name>` CSS pair. */
@@ -8,38 +8,24 @@ export interface SpringPresetRow {
     readonly response: number;
     /** Damping fraction ζ (1 = critical; <1 overshoots). */
     readonly dampingFraction: number;
+    /** LAW 0b — the settle band the emitted `linear()` and `-settle` clock normalize over. */
+    readonly settleBand: 0.02 | 0.005;
     /** The register this curve serves (the doc-table derives from this one string). */
     readonly comment: string;
 }
 /**
- * iOS-canonical (response, dampingFraction) pairs. The names match the `--spring-*`
- * CSS tokens AND the CSS consumers that read `var(--spring-smooth)` etc. directly, so
- * they MUST stay stable across retunes — only the `(response, ζ)` pair and the emitted
- * curves change. Each row's `comment` describes the register it serves (the doc-table
- * on /motion/springs derives from that one string):
+ * The six rows. Every row owns exactly ONE job; no job is owned twice; no row
+ * ships without a rider. The names match the `--spring-*` CSS tokens AND the CSS
+ * consumers that read `var(--spring-press)` etc. directly, so a rename is a
+ * clean break across the library and its consumers, never an alias.
  *
- *   SETTLE  → smooth  — patient entrances, fades, scale-ins (no overshoot read).
- *   CONTROL → snappy  — crisp position morphs: tab underline glide, progress fill,
- *                       the continuous-marker pop, the generic crisp settle.
- *   PLAYFUL → bouncy  — deliberate emphatic one-shots ONLY: the bouncy toggle press,
- *                       dialog/success entrances. Largest overshoot.
- *   GENTLE  → gentle  — critically-damped slow settles (the patient end of the ladder).
- *   DOCK    → dock    — the dock expand/collapse morph AND everything inside it.
- *   PRESS   → press   — the iOS interactive tap-press: a sub-200ms answer, a tiny alive
- *                       rebound.
- *   TRANSIENT → transient — the center-seed materialize bloom (Toast):
- *                       a deep scale-from with a near-critically-damped settle (no flick).
+ * Exactly one row rebounds and it is the fired deploy — the measured corpus
+ * ceiling is a clip edge, and a celebration's liveliness belongs to the LIGHT
+ * channel (engageEnvelopes), never to a geometry bounce.
  *
- * The whole table sits at the iOS weighty-inertial pole: longer `response` (weight) +
- * through-body damping toward critically-damped-with-a-touch-of-overshoot, while keeping
- * the perceptual arrival audacious. The invariant fences:
- *   · every overshoot ∈ [0%,10%] — the "touch of overshoot" band (>10% reads too springy).
- *   · every non-gentle settle is at least as long as the calm baseline (the inertia floor);
- *     nothing gets faster (faster = the mechanical-snap defect).
- *   · t90 (the 90%-arrival fraction of the response clock) is NOT a single tight band —
- *     it varies materially by preset (snappy arrives earlier than smooth/press). The
- *     inertia is carried by the `response`/ζ pair below, not by a t90 fence.
- *   · gentle ζ stays exactly 1.0: a calm arrival must not overshoot.
+ * Every figure describing these rows is GENERATED — the register mirror in
+ * scheme-spring.css is emitted from this table by scripts/regen-spring-tokens.mjs.
+ * Nothing here states a settle, a peak, or a clock in prose.
  */
 export declare const SPRING_PRESETS: readonly SpringPresetRow[];
 /** Lookup one Glass semantic spring preset by name. */

package/dist/composables/motion/spring/springProjection.d.ts

@@ -1,6 +1,6 @@
 import { type TimingFunction } from "@mkbabb/keyframes.js";
-import type { SpringPresetRow } from "./springPresets";
-type SpringParameters = Pick<SpringPresetRow, "response" | "dampingFraction">;
+import type { SpringPresetRow } from "./springPresets.js";
+type SpringParameters = Pick<SpringPresetRow, "response" | "dampingFraction"> & Partial<Pick<SpringPresetRow, "settleBand">>;
 /** Internal projection shared by token generation and the Springs lab. */
 export interface SpringProjection {
     readonly settleSeconds: number;
@@ -11,8 +11,7 @@ export interface SpringProjection {
      *  overshoot the Springs lab must contain within available travel. */
     readonly peak: number;
 }
-export declare const SPRING_TOKEN_SAMPLE_COUNT = 48;
-/** Numeric 2%-band settle, rounded to the token register's nearest 10 ms. */
+/** Numeric settle over the row's OWN band, rounded to the token register's nearest 10 ms. */
 export declare function springSettleDurationSeconds(parameters: SpringParameters): number;
 /** Project one spring through the exact horizon and density used by CSS tokens. */
 export declare function springProjection(parameters: SpringParameters): SpringProjection;

package/dist/composables/motion/spring/useLiquidPress.d.ts

@@ -1,11 +1,11 @@
 import { type CSSProperties, type ComputedRef, type MaybeRefOrGetter, type Ref } from "vue";
-import { type UseSpringPressOptions } from "./useSpringPress";
+import { type UseSpringPressOptions } from "./useSpringPress.js";
 export interface UseLiquidPressOptions extends UseSpringPressOptions {
     /**
      * The uniform press SHRINK depth — the contraction the press scale reaches at
      * `t=1` (the iOS uniform shrink the reciprocal squish deforms AROUND). The X axis
      * reads `shrink·stretch`, the Y axis `shrink/stretch` (the volume preserved on the
-     * travel axis). Default 0.03 (the button `--scale-press-btn` 0.97 magnitude — the
+     * travel axis). Default 0.03 (the button `--scale-press-sm` 0.97 magnitude — the
      * JS path AGREES with the CSS `.tap-squish active:scale` floor). A calmer surface
      * (the dock control's no-overshoot tap register) passes a smaller depth.
      */

package/dist/composables/motion/spring/useSpring.d.ts

@@ -3,15 +3,15 @@ export interface UseSpringOptions {
     /**
      * Angular period of oscillation in seconds. Roughly: how long the spring
      * takes to swing through one cycle if undamped. Default 0.5 — this
-     * primitive's own bare default, NOT a named preset (the `smooth` preset is
-     * 0.58; pass `springPreset("smooth")` for that).
+     * primitive's own bare default, NOT a named preset (pass
+     * `springPreset("<row>")` to ride the table).
      */
     response?: number;
     /**
      * Damping ratio ζ. `1` is critically damped (fastest settle, no
      * overshoot); `< 1` rings (overshoots target); `> 1` is overdamped
      * (sluggish, monotone). Default 0.86 — this primitive's own bare default,
-     * NOT a named preset (the `smooth` preset's ζ is 0.8).
+     * NOT a named preset (pass `springPreset("<row>")` to ride the table).
      */
     dampingFraction?: number;
     /** Starting position. Default 0. */

package/dist/composables/motion/spring/useSpringMount.d.ts

@@ -1,7 +1,10 @@
 import { type Ref } from "vue";
-import { type SpringRef } from "./useSpring";
-/** Named iOS spring presets the mount register exposes (the dock register is not a mount enter). */
-export type SpringPreset = "smooth" | "snappy" | "bouncy" | "gentle";
+import { type SpringRef } from "./useSpring.js";
+import { type SpringPresetName } from "./springPresets.js";
+/** The registers a mount ENTER may ride — DERIVED from the one table, never re-typed.
+ *  A centred plate presents, a fired sheet deploys, a full-screen surface blooms;
+ *  travel and touch are not mount enters. */
+export type SpringPreset = Extract<SpringPresetName, "present" | "panel" | "bloom">;
 export interface UseSpringMountOptions {
     /**
      * Reactive open-state mirror from the host's DialogContext. Accepts

package/dist/composables/motion/spring/useSpringPress.d.ts

@@ -1,14 +1,14 @@
-import { type UseSpringOptions, type SpringRef } from "./useSpring";
+import { type UseSpringOptions, type SpringRef } from "./useSpring.js";
 export interface UseSpringPressOptions extends UseSpringOptions {
     /**
-     * Spring `response`. Default `0.2s` — the `press` SPRING_PRESETS row (the iOS
-     * interactive tap): the sub-200ms iOS tap-press window, faster than the generic
-     * `useSpring` 0.5s so the feedback lands with a hair of inertial carry.
+     * Spring `response` — defaults to the `press` row's own, the tap-press window:
+     * faster than the generic `useSpring` bare default so the feedback lands with a
+     * hair of inertial carry.
      */
     response?: number;
     /**
-     * Spring `dampingFraction`. Default `0.8` — the `press` row's ζ: a tiny
-     * sub-perceptual rebound (+1.5%, springy/alive) that does NOT ring.
+     * Spring `dampingFraction` — defaults to the `press` row's own ζ, which lands the
+     * press dead rather than ringing.
      */
     dampingFraction?: number;
 }

package/dist/composables/reactive/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./useInterval";
-export * from "./useTimer";
+export * from "./useInterval.js";
+export * from "./useTimer.js";

package/dist/composables/search/index.d.ts

@@ -0,0 +1,5 @@
+export { useFuzzySearch } from "./useFuzzySearch.js";
+export type { UseFuzzySearchOptions } from "./useFuzzySearch.js";
+export { buildIndex, searchIndex, fuzzyMatch, clearSearchCache } from "./match.js";
+export type { SearchIndex } from "./match.js";
+export type { SearchableItem, SearchResult, FuzzySearchState } from "./types.js";

package/dist/{components/search/composables/fuzzySearchIndex.d.ts → composables/search/match.d.ts}

@@ -1,9 +1,14 @@
 /**
- * Generic fuzzy search index — builds a flat searchable index from items
- * and scores queries with VSCode-style fuzzy matching.
- * Pure functions, no Vue reactivity.
+ * The engine's matcher — builds a flat searchable index from items and scores queries
+ * with VSCode-style fuzzy matching. Pure functions, no Vue reactivity.
+ *
+ * [2026-08-25 · BK #42 W-SEARCH] Landed here from
+ * `src/components/search/composables/fuzzySearchIndex.ts`. The name lost its
+ * `fuzzySearchIndex` prefix with the directory: under `composables/search/` the words
+ * "search" and "fuzzy" are the path, and a file called `search/fuzzySearchIndex.ts`
+ * says them twice.
  */
-import type { SearchableItem, SearchResult } from "./types";
+import type { SearchableItem, SearchResult } from "./types.js";
 interface IndexEntry<T extends SearchableItem> {
     item: T;
     /** Pre-lowercased fields, built once at index time. */

package/dist/{components/search/composables → composables/search}/useFuzzySearch.d.ts

@@ -1,4 +1,4 @@
-import type { SearchableItem, SearchResult, FuzzySearchState } from "./types";
+import type { SearchableItem, SearchResult, FuzzySearchState } from "./types.js";
 export interface UseFuzzySearchOptions<T extends SearchableItem = SearchableItem> {
     /** Reactive or static list of searchable items. */
     items: T[] | (() => T[]);

package/dist/composables/sidebar/index.d.ts

@@ -1,10 +1,10 @@
-export { useScrollTracker } from "./useScrollTracker";
-export { useSidebarFollow } from "./useSidebarFollow";
-export type { SidebarFollowOptions } from "./useSidebarFollow";
-export { useSidebarState } from "./useSidebarState";
-export type { UseSidebarStateOptions, GenericSidebarState } from "./useSidebarState";
-export { useTreeIndex, buildTreeIndex, isActive, isInActiveChain } from "./useTreeIndex";
-export { useScrollTo } from "./useScrollTo";
-export { useClickDelegate } from "./useClickDelegate";
-export { useLazyLoader } from "./useLazyLoader";
-export type { TreeNode, TreeIndexEntry, SidebarSection, SidebarIndexEntry, SidebarState, ScrollTrackerOptions, ScrollToOptions, ClickDelegateOptions, LazyLoaderOptions, } from "./types";
+export { useScrollTracker } from "./useScrollTracker.js";
+export { useSidebarFollow } from "./useSidebarFollow.js";
+export type { SidebarFollowOptions } from "./useSidebarFollow.js";
+export { useSidebarState } from "./useSidebarState.js";
+export type { UseSidebarStateOptions, GenericSidebarState } from "./useSidebarState.js";
+export { useTreeIndex, buildTreeIndex, isActive, isInActiveChain } from "./useTreeIndex.js";
+export { useScrollTo } from "./useScrollTo.js";
+export { useClickDelegate } from "./useClickDelegate.js";
+export { useLazyLoader } from "./useLazyLoader.js";
+export type { TreeNode, TreeIndexEntry, SidebarSection, SidebarIndexEntry, SidebarState, ScrollTrackerOptions, ScrollToOptions, ClickDelegateOptions, LazyLoaderOptions, } from "./types.js";

package/dist/composables/sidebar/useClickDelegate.d.ts

@@ -1,4 +1,4 @@
-import type { ClickDelegateOptions } from "./types";
+import type { ClickDelegateOptions } from "./types.js";
 export declare function useClickDelegate(options: ClickDelegateOptions): {
     handleClick: (e: MouseEvent) => void;
 };

package/dist/composables/sidebar/useLazyLoader.d.ts

@@ -1,4 +1,4 @@
-import type { LazyLoaderOptions } from "./types";
+import type { LazyLoaderOptions } from "./types.js";
 export declare function useLazyLoader(totalCount: number, options?: LazyLoaderOptions): {
     visibleCount: import("vue").Ref<number, number>;
     loadSentinel: import("vue").Ref<HTMLElement | null, HTMLElement | null>;