@mkbabb/glass-ui 7.0.0 → 8.0.0

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

@@ -1,18 +1,23 @@
 import { type Ref } from "vue";
+/**
+ * The bounded velocity lag — `clamp(v·τ, ±ceil)`. The worm's trail edge and the
+ * carousel's interior content-lag are the same law over different quantities.
+ */
+export declare function trailOffset(velocity: number, tau: number, ceil: number): number;
 export interface UseLeadTrailOptions {
-    /** The lead spring response (2π/response = the natural frequency). Default 0.68. */
-    response?: number;
-    /** The lead spring damping ratio ζ. Default 0.64. */
-    damping?: number;
-    /** The trailing follower time constant, seconds. Default 0.27 (≈270ms). */
-    trailTau?: number;
+    /**
+     * The lag ceiling in px, re-read per frame so it can be a live geometry band
+     * (`clamp(pitch, |Δ|·0.55, 3·pitch)`). A plain number is a fixed ceiling.
+     */
+    ceil?: number | (() => number);
+    /** The elongation time constant, seconds. Default 0.08. */
+    tau?: number;
     /** Honor `prefers-reduced-motion: reduce` → `drive` seats instantly. Default true. */
     respectReducedMotion?: boolean;
     /**
-     * The per-frame writer the consumer supplies (the DOM-write path, NO reactive
-     * thrash). Called each rAF tick with the live numeric edges — the consumer
-     * projects its silhouette (for example, a barbell) off `lo`/`hi`. Also called
-     * once on `seat` so a static mount paints correctly.
+     * The per-frame writer. Called each rAF tick with the live numeric edges — the
+     * consumer projects its silhouette off `lo`/`hi`. Also called once on `seat`
+     * so a static mount paints correctly.
      */
     onFrame?: (edges: LeadTrailEdges) => void;
 }
@@ -20,27 +25,28 @@ export interface UseLeadTrailOptions {
 export interface LeadTrailEdges {
     /** The lead edge (px) — springs toward the drive target. */
     lead: number;
-    /** The trail edge (px) — lags then catches the lead. */
+    /** The trail edge (px) — the lead, offset by the bounded velocity lag. */
     trail: number;
-    /** `min(lead, trail)` — the trailing silhouette edge (direction-agnostic). */
+    /** The lead's velocity (px/s) — the elongation's own cause. */
+    velocity: number;
+    /** `min(lead, trail)` — direction-agnostic. */
     lo: number;
-    /** `max(lead, trail)` — the leading silhouette edge (direction-agnostic). */
+    /** `max(lead, trail)`. */
     hi: number;
-    /** True once the edges have re-formed on the target (the emergent release). */
+    /** True once the edges have re-formed on the target. */
     settled: boolean;
 }
 export interface UseLeadTrail {
-    /** The live lead edge (updated per frame; the consumer usually reads `onFrame`). */
+    /** The live lead edge (updated per frame). */
     readonly lead: Readonly<Ref<number>>;
     /** The live trail edge (updated per frame). */
     readonly trail: Readonly<Ref<number>>;
-    /** True while the worm has re-formed on the target (the rAF is parked). */
+    /** True while the morph has re-formed on the target (the rAF is parked). */
     readonly settled: Readonly<Ref<boolean>>;
     /**
      * Retarget the lead edge (px). The velocity carries — a retarget mid-flight
-     * re-seats the target, the spring continues from its LIVE `(position, velocity)`
-     * so interruption is free. Under PRM this SEATS instantly (zero in-between frames).
-     * The `drive(fractionalIndex→px)` seam consumed by carousel drag scrubbing.
+     * continues from the LIVE `(position, velocity)`, so interruption is free.
+     * Under PRM this SEATS instantly (zero in-between frames).
      */
     drive(target: number): void;
     /** Snap BOTH edges to `value` instantly (mount / resize / PRM). Paints once. */
@@ -49,21 +55,17 @@ export interface UseLeadTrail {
     dispose(): void;
 }
 /**
- * The two-edge lead/trail integrator — a spring LEAD + a damped TRAIL follower in
- * ONE rAF. The gap between the edges is the morph's live elongation; the trail
- * catching the lead is the emergent release. keyframes-FREE + vueuse-FREE. See the
- * module header for the pager-worm rationale.
+ * The two-edge morph driver — a governed spring LEAD and a velocity-derived TRAIL
+ * in ONE rAF, with ZERO per-frame style reads. See the module header for the law.
  *
  * @example
  * ```ts
  * const worm = useLeadTrail({
- *   onFrame({ lo, hi }) {
- *     // project the barbell off the two edges (no getComputedStyle)
- *     paintBarbell(lo, hi)
- *   },
+ *   ceil: () => elongationCeil(),          // clamp(pitch, |Δ|·0.55, 3·pitch)
+ *   onFrame: ({ lo, hi }) => paintBarbell(lo, hi),
  * })
  * worm.seat(centerOf(active))   // mount
- * worm.drive(centerOf(next))    // hop — the lead springs, the trail lags then reels in
+ * worm.drive(centerOf(next))    // hop — the gap peaks with the velocity, then is 0
  * ```
  */
 export declare function useLeadTrail(options?: UseLeadTrailOptions): UseLeadTrail;

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

@@ -1,22 +1,30 @@
 import { type ComputedRef, type Ref } from "vue";
-import { type SelectionOption } from "./useSelectionIndicator";
-import { type TabActivation } from "../../../components/tabs/composables/useTabRovingFocus";
+import { type SelectionDeform, type SelectionOption } from "./useSelectionIndicator.js";
+import type { SelectionValue } from "../../../components/_shared/selection.js";
+import { type TabActivation } from "../../../components/tabs/composables/useTabRovingFocus.js";
 /**
  * useSelectionGroup is the library's single headless selection engine. The dock
- * control run, `<SegmentedTabs>`, and
- * `<ToggleGroup type="single">` are the SAME thing — a roving-focus selection
- * strip with a traveling indicator. This composable assembles that ONE engine
- * from the shared parts, reka-free and engine-free so it
- * ships on `/motion-core`:
+ * control run and `<SegmentedTabs>` are the SAME thing — a roving-focus selection
+ * strip with a traveling indicator — and both compose it (BK #19 W-SELECTION-ONE
+ * made SegmentedTabs the second; the arm at `tests/gates/overfit-structure.test.ts`
+ * forbids a third assembly). `<ToggleGroup>` is the THIRD consumer, adopted at
+ * **BK #84 W-TOGGLE-ROW**: reka retired from that component entirely and it now
+ * feeds this engine from an item registry, taking the role-per-mode ARIA, the
+ * roving machine and the recenter while DECLINING the indicator — `indicatorRef`
+ * omitted, which is the "plain toggle row" the param below already named as a
+ * first-class caller. The C-1 `SelectionOption["value"]` widening landed with it
+ * (`string` → `SelectionValue`), so the engine's consumer set is THREE, and this
+ * doc says three. The assembly, reka-free and engine-free so it ships on
+ * `/motion-core`:
  *
- *   • the SELECTION MODEL — `single` (a `string`) | `multiple` (a `string[]`),
- *     driven off a caller-owned `model` ref (no shadow registry — the ONE
- *     registry discipline);
+ *   • the SELECTION MODEL — `single` (one scalar) | `multiple` (an array of them),
+ *     at the OPTION TYPE's own value (`O["value"]`), driven off a caller-owned
+ *     `model` ref (no shadow registry — the ONE registry discipline);
  *   • the ROVING MACHINE — `useTabRovingFocus` composed VERBATIM (exactly-one-
  *     tabstop, axis-derived arrows, Home/End, wrap, disabled-skip);
  *   • the ONE TRAVELING-INDICATOR WRITER — `useSelectionIndicator` (the
  *     center-anchored ResizeObserver measure + the `--stretch` squish), so the
- *     dock/tabs/toggle-group indicator is Safari-identical by construction;
+ *     dock and tabs indicator is Safari-identical by construction;
  *   • the RECENTER CALL — `el.scrollIntoView({inline:'nearest', block:'nearest'})`
  *     on every select, so a selection past the fold pulls itself into view.
  *
@@ -32,10 +40,13 @@ export interface UseSelectionGroupParams<O extends SelectionOption> {
     options: ComputedRef<O[]>;
     /**
      * The caller-owned selection model — the ONE registry (no shadow state). A
-     * `single`-mode group reads/writes a `string`; a `multiple`-mode group a
-     * `string[]`.
+     * `single`-mode group reads/writes one option value; a `multiple`-mode group an
+     * array of them. Keyed to `O["value"]` rather than fixed at `string` (BK #84
+     * C-1), so a caller whose options carry `SelectionValue` keeps its own scalar
+     * end to end and a caller whose options carry `string` sees exactly what it saw
+     * before — the widening is by DERIVATION, so it breaks nothing.
      */
-    model: Ref<string | string[] | undefined>;
+    model: Ref<O["value"] | O["value"][] | undefined>;
     /** `single` (default) | `multiple`. */
     mode?: ComputedRef<SelectionMode> | SelectionMode;
     /**
@@ -51,24 +62,51 @@ export interface UseSelectionGroupParams<O extends SelectionOption> {
     /** The container scroller root (observed by the indicator's ResizeObserver). */
     containerRef: Ref<HTMLElement | null>;
     /**
-     * The traveling-indicator element (the `--stretch` squish target). Omit (or
-     * leave null) for a group with no glide indicator (e.g. a paper-hairline
-     * strip or a plain toggle row) — the squish/measure then no-ops.
+     * The traveling-indicator element (the deform write target). Omit (or leave
+     * null) for a group with no glide indicator at all (a paper-hairline strip, a
+     * plain toggle row) — the SQUISH then no-ops, which is HEAD's accurate half and
+     * is restored here. ~~The MEASURE does not no-op, and BK #84's rewording asserted
+     * that it did: `useSelectionIndicator` attaches its `ResizeObserver`
+     * unconditionally — that is the Safari-identical guarantee — and
+     * `updateSingleSlider` keeps writing a `singleSliderStyle` such a caller never
+     * reads. Economizing it is the indicator writer's own change to make.~~
+     * [2026-08-08 · BK #71 W-EYEGLASS, RT-84O: the change was made, in the file this
+     * text routed it to. `updateSingleSlider` now returns before its first rect read
+     * when `indicatorRef` is null, so such a caller runs ZERO layout. What #84 wrote
+     * was true of #84's HEAD and is false of this one — the `ResizeObserver` still
+     * attaches unconditionally (that guarantee is untouched), and a strip that
+     * appears late is measured on arrival because the indicator is a CHILD of the
+     * container, so the container watcher already covers it.]
      */
     indicatorRef?: Ref<HTMLElement | null>;
+    /**
+     * What the travelling body is made of — `"plate"` (default, the full body and
+     * the eyeglass host), `"mark"` (a hairline: length only), `"none"`. STATED, not
+     * inferred: a multi-toggle group has no single travelling body, and that is a
+     * different fact from a hairline having no area, even though the old null-ref
+     * sentinel spelled both the same way.
+     */
+    deform?: ComputedRef<SelectionDeform>;
     /** Per-option item refs, index-aligned to `options`. */
     buttonRefs: Ref<HTMLElement[]>;
+    /**
+     * A per-commit side effect the CALLER owns, fired on every committed selection
+     * (pointer AND keyboard) before the model write — e.g. SegmentedTabs' press
+     * squish on the pressed button. The engine stays the one selection path; a
+     * caller that needs a local flourish hangs it here rather than forking `select`.
+     */
+    onSelect?: (value: O["value"], idx: number) => void;
 }
-export interface UseSelectionGroupReturn {
+export interface UseSelectionGroupReturn<V extends SelectionValue = string> {
     /** The active option values (one for `single`, N for `multiple`). */
-    activeValues: ComputedRef<string[]>;
+    activeValues: ComputedRef<V[]>;
     /** True when `value` is currently selected. */
-    isSelected: (value: string) => boolean;
+    isSelected: (value: V) => boolean;
     /**
      * Commit a selection at `idx` — writes the model (toggle in `multiple`),
      * fires the travel-squish, and recenters the item via `scrollIntoView`.
      */
-    select: (value: string, idx: number) => void;
+    select: (value: V, idx: number) => void;
     /** The roving tabindex for option `idx` (`0` for the tabstop, `-1` else). */
     rovingTabindex: (idx: number) => number;
     /** The strip-root keydown handler (axis-derived arrows + Home/End). */
@@ -80,6 +118,6 @@ export interface UseSelectionGroupReturn {
     /** The resolved group `role` (`radiogroup` | `tablist` | `group`). */
     groupRole: ComputedRef<SelectionRole>;
     /** The per-item ARIA attributes for `value`, role-per-mode. */
-    itemAttrs: (value: string) => Record<string, string>;
+    itemAttrs: (value: V) => Record<string, string>;
 }
-export declare function useSelectionGroup<O extends SelectionOption>(params: UseSelectionGroupParams<O>): UseSelectionGroupReturn;
+export declare function useSelectionGroup<O extends SelectionOption>(params: UseSelectionGroupParams<O>): UseSelectionGroupReturn<O["value"]>;

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

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;