@mkbabb/glass-ui 3.13.0 → 4.0.1

package/dist/components/custom/constellation/constellationTypes.d.ts

@@ -0,0 +1,369 @@
+export interface ConstellationNode {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    r: number;
+    dim: boolean;
+}
+export interface ConstellationRipple {
+    x: number;
+    y: number;
+    /** `performance.now()` at first draw; -1 until stamped. */
+    start: number;
+}
+/** The pointer position in canvas-local CSS px (`-1` = inactive). */
+export interface ConstellationPointer {
+    x: number;
+    y: number;
+}
+/**
+ * The neutral palette + legibility weights resolved off the canvas custom
+ * properties (the FULL `--constellation-*` set — AX.W17). `node`/`nodeDim`/
+ * `line` are the colors; `edgeAlpha`/`edgeFocusAlpha`/`alpha` are the per-mode
+ * legibility multipliers (replacing the `0.17`/`0.24` magic literals).
+ */
+export interface ConstellationPalette {
+    node: string;
+    nodeDim: string;
+    line: string;
+    /** The hairline-edge alpha multiplier (was the `0.17` literal). */
+    edgeAlpha: number;
+    /** The focus-proximity edge multiplier (consumer skins may read it). */
+    edgeFocusAlpha: number;
+    /** The field-yields-to-type translucency knob (the global field dimmer). */
+    alpha: number;
+    /**
+     * The ACCENT-edge skin tint (AZ.W-CON-GEN G3) — the flagged-node EDGE color the
+     * optional `drawEdges(…, accentIndex)` pass strokes for edges incident on the
+     * accented node. Reads `--constellation-accent` (the consumer-preset boundary —
+     * the library ships a neutral default; a consumer aliases it to its brand hue).
+     */
+    accent: string;
+    /**
+     * The neutral-edge alpha FLOOR (AZ.W-CON-GEN G3) — added to a distance-faded
+     * neutral hairline's alpha so it clears the perceptual/sampling floor across its
+     * full length on a bright ground (the "web doesn't read in light mode" fix).
+     * Default `0` is byte-identical (no floor). Reads `--constellation-edge-floor`.
+     */
+    edgeFloor: number;
+    /**
+     * The ACCENT-incident edge alpha multiplier (AZ.W-CON-GEN G3) — the per-mode
+     * weight for an edge touching the accented node. Reads
+     * `--constellation-edge-accent-alpha`; the accented edges read a touch louder
+     * than the neutral lattice (the flagged-node tether).
+     */
+    edgeAccentAlpha: number;
+}
+/**
+ * The per-axis critically-damped warp spring on the focal node (AX.W17). The
+ * focal mark's position is `(x, y)`; `vx`/`vy` its velocity; `targetIdx` the
+ * LIVE node index it chases (re-read each frame so it tracks a DRIFTING target,
+ * not a frozen click-time snapshot). `-1` = no active warp (the focal mark
+ * rides its node's drift directly — the identity-ride at settle).
+ */
+export interface ConstellationWarp {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    /** The chased node's INDEX (live target), or -1 when inactive. */
+    targetIdx: number;
+}
+/**
+ * The auto-DRIFT target-source (AY.W-CON1 — the 2nd half of the AX.W17 "drift +
+ * warp are ONE mechanic" thesis). The warp re-points its focal node to a
+ * periodically-chosen RANDOM node on a jittered cadence: the SAME warp spring,
+ * a different target-PICKER (a click for warp, this cadence for drift). No new
+ * rAF, no second mechanic — `stepField` steps this cadence inline, re-pointing
+ * `setWarpTarget` to a picked node only when the spring has SETTLED (so a
+ * click-warp in flight always pre-empts the cadence). PRM is enforced by the
+ * CALLER (the component does not advance the cadence under reduced-motion — the
+ * `stepField` call lives inside the `!reducedMotion` block — so the focal mark
+ * stays at its seed: the WARP precedent, NOT fire-but-freeze).
+ */
+export interface ConstellationWander {
+    /** ms timestamp of the next auto re-target; -1 until armed on the first stepped frame. */
+    nextAt: number;
+    /** the minimum idle (ms) between auto re-targets. */
+    minIdle: number;
+    /** the random extra idle (ms) added per cadence (so the rhythm is not metronomic). */
+    jitter: number;
+}
+/**
+ * The autonomous PINNED-ANCHOR drift state (AZ.W-CON-GEN G5) — the gentle wander of
+ * the PINNED node (`field.pinnedIndex`) around its seeded ANCHOR. DISTINCT from
+ * `wander` (which re-targets the WARP spring among random nodes): this eases ONE
+ * designated node a small fraction around its rest position on a jittered cadence,
+ * so a flagged point breathes its neighborhood without leaving the dead-space it was
+ * anchored in. Stepped inside `stepField` (no second rAF) via a closed-form
+ * easeInOutQuad over `now` — no integrator. Absent (`undefined`) → `stepField` skips
+ * the block (byte-identical to HEAD).
+ */
+export interface ConstellationPinnedDrift {
+    /** The anchor (the pinned node's rest position) the drift eases around (px). */
+    anchorX: number;
+    anchorY: number;
+    /** ms timestamp of the next leg; -1 until armed on the first stepped frame. */
+    nextAt: number;
+    /** ms timestamp the current leg started; -1 between legs (resting at the anchor). */
+    legStart: number;
+    /** the current leg's from/to (px) — the eased segment endpoints. */
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+    /** the ± fraction of the canvas the drift wanders around the anchor. */
+    wanderFrac: number;
+    /** the per-leg easeInOutQuad duration (ms). */
+    durMs: number;
+    /** the minimum rest (ms) between legs. */
+    minIdle: number;
+    /** the random extra rest (ms) per leg (so the rhythm is not metronomic). */
+    jitter: number;
+}
+/**
+ * The warp-spring tuning the integrator reads (AY.W-CON2). Tokenised numeric (the
+ * `--constellation-warp-*` cohort) so a consumer retunes the warp WITHOUT editing
+ * src — read ONCE on mount via `parseFloat`, threaded onto the field.
+ *
+ * `response` is the keyframes.js `(response, dampingFraction)` model's ANGULAR
+ * PERIOD (the SwiftUI `.spring(response:)` axis): `ω₀ = 2π/response`. It is NOT a
+ * settle-duration — at ζ=1 the 2%-settle lands at `t₂ ≈ 5.83/ω₀ ≈ 0.93·response`
+ * (the `(1 + ω₀t)e^(−ω₀t)` critically-damped envelope). Documented here + in the
+ * `--constellation-warp-response` token comment so the token semantics are honest
+ * at ANY ζ (the AY.W-CON2 ω-reconcile; the engine keeps the keyframes.js convention,
+ * mints NO second ω formula).
+ */
+export interface ConstellationWarpConfig {
+    /** keyframes.js angular period (s) — `ω₀ = 2π/response`, NOT a settle-duration. */
+    response: number;
+    /** damping ratio ζ — 1 critically damped (a focal mark must NOT ring). */
+    zeta: number;
+}
+/**
+ * The gravity-well tuning (AY.W-CON2). The held-pointer pull is an inverse-square
+ * force composed into `stepField` (no new rAF). Tokenised numeric (the
+ * `--constellation-well-*` cohort) so a consumer retunes the well WITHOUT editing
+ * src. All distances are base-width px (`k`-scaled at step time).
+ */
+export interface ConstellationWellConfig {
+    /** the inverse-square pull gain (the force scale at unit distance). */
+    gain: number;
+    /** the reach (base-width px) — nodes beyond it are untouched (the O(within-reach) cost floor). */
+    reach: number;
+    /**
+     * the ARM ramp rate (1/s) — `strength` eases toward `target = 1` at this rate
+     * while HELD (the gentle bloom the token tunes). The RELEASE is NOT this rate:
+     * it is the fixed brisk {@link WELL_RELEASE_RAMP} (the field-cools invariant —
+     * not consumer-tunable, F8.2). A consumer slowing this token slows the ARM
+     * bloom only; the release stays brisk so the cool gate holds.
+     */
+    ramp: number;
+    /** the per-node speed cap (base-width px/frame) — the no-slingshot clamp. */
+    maxSpeed: number;
+    /** the singularity floor (px) — a node AT the cursor gets a bounded pull, never `∞`. */
+    soften: number;
+    /** ms the pointer is held before the well arms. */
+    holdMs: number;
+}
+/**
+ * The gravity-well live STATE (AY.W-CON2). `(x, y)` is the held pointer in
+ * canvas-local px (`-1` = inactive); `strength` is the eased pull 0→1 (ramps to
+ * `target` at `cfg.ramp`/s); `target` is the strength the ramp eases toward (1
+ * while held, 0 on release). A transient force — the field renormalises back to
+ * `speed` after release (the field-cools invariant).
+ */
+export interface ConstellationWell {
+    /** canvas-local px of the held pointer; `-1` = inactive. */
+    x: number;
+    y: number;
+    /** the eased pull strength 0→1 (ramps to `target` at `cfg.ramp`/s). */
+    strength: number;
+    /** the strength the ramp is easing toward: 1 while held, 0 on release. */
+    target: number;
+    /** the well tuning (gain/reach/ramp/maxSpeed/soften). */
+    cfg: ConstellationWellConfig;
+}
+/**
+ * The field state the component exposes to its `drawOverlay` consumer so a
+ * skin can pin itself to a real field node. `k` is the `width / BASE_WIDTH`
+ * scale, `dpr` the device-pixel ratio applied by the substrate.
+ *
+ * The focal node (AX.W17) is a FIRST-CLASS library concept: `focalIndex` names
+ * which node is focal (consumer-owned via `warpTo`), and the engine OWNS its
+ * position via the `warp` spring stepped inside `stepField`. A `drawOverlay`
+ * paints the focal mark at `field.warp.{x,y}` (the spring-eased position) —
+ * node-position mutation `drawOverlay` structurally cannot express, resolved by
+ * ONE first-class concept (warp + drift unify; no second parallel hook).
+ */
+export interface ConstellationField {
+    nodes: ConstellationNode[];
+    /** The host canvas — for `getComputedStyle` token reads in an overlay. */
+    canvas: HTMLCanvasElement | null;
+    w: number;
+    h: number;
+    k: number;
+    dpr: number;
+    /** R5-8 — SIZES draw at `kVisOf(field)`; TRUE `k` keeps positions/reach. */
+    kFloor?: number;
+    /**
+     * The designated focal node's INDEX, or `-1` when none is pinned. Re-points
+     * on each `warpTo`; node count is conserved (it is a designation, not a new
+     * node). A `drawOverlay` reads `field.warp.{x,y}` for the spring-eased mark.
+     */
+    focalIndex: number;
+    /** The per-axis warp spring the engine steps inside `stepField` (AX.W17). */
+    warp: ConstellationWarp;
+    /**
+     * The warp-spring tuning `warpStep` reads (AY.W-CON2). Optional — absent
+     * falls back to the shipped `{ response: 0.55, zeta: 1.0 }` defaults (the
+     * byte-identical HEAD spring). A tokenised override (read on mount) reaches
+     * the integrator through this member.
+     */
+    warpCfg?: ConstellationWarpConfig;
+    /**
+     * The optional auto-DRIFT cadence (AY.W-CON1). When set, `stepField`
+     * periodically re-points the warp to a random node (the wander source on the
+     * SAME spring). Absent (`undefined`) leaves the field BYTE-IDENTICAL to the
+     * pre-wander HEAD — `stepField` skips the cadence block entirely.
+     */
+    wander?: ConstellationWander;
+    /**
+     * The optional gravity-well (AY.W-CON2). When set, `stepField` composes a
+     * held-pointer inverse-square pull force (no new rAF) — `well.target → 1`
+     * while held, `→ 0` on release, the field renormalising back to `speed` once
+     * the well cools. Absent (`undefined`) leaves the field BYTE-IDENTICAL to the
+     * pre-well HEAD — `stepField` skips the force pass entirely.
+     */
+    well?: ConstellationWell;
+    /**
+     * The PINNED node designation (AZ.W-CON-GEN G1) — the index of a node `stepField`
+     * does NOT drift/bounce/steer/pull, so it HOLDS its seeded position (the flagged
+     * flagged node the consumer pins). `-1` (the default) = no pin → every node drifts
+     * (byte-identical to HEAD). A designation, NOT a new node — node count is
+     * conserved. The optional `pinnedDrift` gently wanders it around its anchor; the
+     * optional `drawEdges(…, accentIndex)` tints its incident edges.
+     */
+    pinnedIndex: number;
+    /**
+     * The optional autonomous PINNED-ANCHOR drift (AZ.W-CON-GEN G5). When set AND a
+     * node is pinned, `stepField` gently eases the pinned node around its anchor on a
+     * jittered cadence (a closed-form easeInOutQuad — no second rAF). Absent
+     * (`undefined`) → the pinned node holds dead-still at its anchor (byte-identical).
+     */
+    pinnedDrift?: ConstellationPinnedDrift;
+    /**
+     * Warp AUTO-RELEASE (AZ.W-CON-GEN G6). When `true`, `stepField` clears the warp's
+     * `targetIdx` (→ -1) once the spring has SETTLED on its target — the focal node
+     * releases the spring and rides its node's RAW drift (the identity-ride), freeing
+     * the spring for the next warp. Default `false`/undefined keeps the held-target
+     * behaviour (the warp chases its node forever — byte-identical to HEAD).
+     */
+    warpAutoRelease?: boolean;
+}
+/**
+ * The `<Constellation>` consumer prop surface (the public type a consumer types
+ * a wrapper against). The `drawOverlay` seam is the branded-skin injection — it
+ * runs AFTER the neutral passes with the live field.
+ */
+export interface ConstellationProps {
+    /** Node count. Default 64. */
+    count?: number;
+    /** Link distance in px (the falloff reach). Default 132. */
+    link?: number;
+    /** Drift speed. Default 0.16. */
+    speed?: number;
+    /**
+     * AY.W-COHERE E3 — the per-instance outer-envelope RECESSION knob (the aurora
+     * `opacityCeiling` / fourier `intensity` sibling — ONE recession vocabulary
+     * across the four live substrates). Scales the painted edge/node/web/ripple
+     * alpha OVER the mode-tuned `--constellation-alpha` base so the lattice can
+     * RECEDE behind content (0.4–0.6 in a hero). Default `1` is byte-identical to
+     * HEAD.
+     */
+    opacityCeiling?: number;
+    /** Seed for a reproducible field (number or hashed string); omit for `Math.random`. */
+    seed?: number | string;
+    /** Steer-toward-cursor + tap ripples. Default true; auto-off under reduced-motion. */
+    pointerReactive?: boolean;
+    /**
+     * Click-to-warp (AX.W17): a click warps the focal node to the nearest
+     * drifting node + springs it there. INDEPENDENT of `pointerReactive` (warp
+     * works on a non-ripple lattice). Default false; auto-off under
+     * reduced-motion (the focal mark stays put — the stated PRM policy).
+     */
+    warpOnClick?: boolean;
+    /**
+     * Auto-DRIFT (AY.W-CON1): a periodic auto-pick re-points the focal node to a
+     * random node on a jittered cadence — the wander source on the SAME warp
+     * spring (no second mechanic). `true` uses the default cadence (8–16s, the
+     * slides rhythm); `{ minIdle, jitter }` tunes it. Default OFF (absent →
+     * byte-identical to HEAD). PRM-gated by the WARP precedent (the cadence never
+     * advances under reduced-motion — the focal stays at its seed).
+     */
+    wander?: boolean | {
+        minIdle?: number;
+        jitter?: number;
+    };
+    /**
+     * Pointer-held GRAVITY-WELL (AY.W-CON2): hold the pointer and the lattice is
+     * pulled toward it (an inverse-square force on the same engine, no new rAF);
+     * release and the field cools back to `speed`. INDEPENDENT of `warpOnClick`
+     * and `pointerReactive` (a consumer can hold-to-pull on a non-ripple,
+     * non-warp lattice). `true` uses the tokenised defaults; an object tunes the
+     * gains. Default OFF (absent → byte-identical to HEAD). PRM-gated by the WARP
+     * precedent (the held-timer is not registered under reduced-motion).
+     */
+    gravityWell?: boolean | {
+        holdMs?: number;
+        gain?: number;
+        reach?: number;
+        ramp?: number;
+        maxSpeed?: number;
+        soften?: number;
+    };
+    /**
+     * PINNED node designation (AZ.W-CON-GEN G1): a node held by every step pass (it
+     * does not drift / bounce / steer / feel the well). `false`/absent → no pin;
+     * `true` → node 0; a number → that index. The flagged-node pin the consumer holds.
+     */
+    pinned?: boolean | number;
+    /**
+     * ACCENT-edge skin (AZ.W-CON-GEN G2): edges incident on the pinned (else focal)
+     * node stroke the `--constellation-accent` tint — the flagged-node tether. Default
+     * OFF (the neutral single-color pass).
+     */
+    accentEdges?: boolean;
+    /**
+     * Autonomous PINNED-ANCHOR drift (AZ.W-CON-GEN G5): the pinned node gently wanders
+     * its seeded anchor on a jittered cadence (DISTINCT from `wander`, which re-targets
+     * the warp). Default OFF (the pin holds dead-still). PRM-gated.
+     */
+    pinnedDrift?: boolean | {
+        wanderFrac?: number;
+        durMs?: number;
+        minIdle?: number;
+        jitter?: number;
+    };
+    /**
+     * Warp AUTO-RELEASE (AZ.W-CON-GEN G6): a settled warp clears its target so the
+     * focal rides its node's raw drift (the identity-ride). Default OFF (the warp holds
+     * its target forever). Read the settled signal via the `warpSettled()` expose.
+     */
+    warpAutoRelease?: boolean;
+    /**
+     * Deterministic-capture freeze (AY.W-CON3): when `true`, lays out ONE
+     * reproducible STATIC frame (no `stepField`, no ripple / warp / wander / well
+     * advance) and hands `drawOverlay` a FROZEN `now` so a phase-driven skin
+     * resolves to a fixed value. Omit to AUTO-DERIVE from `location.search`
+     * matching `export | print | freeze` (the deploy-pipeline contract); an
+     * explicit `false` forces live even under a capture URL. Set `seed` for a
+     * field stable ACROSS runs. Unifies with the reduced-motion one-static-frame
+     * path (`freeze || reducedMotion` is the single static-frame predicate).
+     */
+    freeze?: boolean;
+    class?: string;
+    /** The skin seam — paints the consumer's focal mark on the live field. */
+    drawOverlay?: (ctx: CanvasRenderingContext2D, field: ConstellationField, now: number) => void;
+}

package/dist/components/custom/constellation/index.d.ts

@@ -3,4 +3,4 @@ export { seedField, stepField, refitField, BASE_WIDTH, } from "./constellationFi
 export { DEFAULT_K_FLOOR } from "./constants";
 export { stepWell, nearestNode, readInteractionConfig, warpStep, warpTo, setWarpTarget, warpSettled, pickWanderTarget, stepPinnedDrift, makePinnedDrift, DEFAULT_WELL_CONFIG, DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_PINNED_DRIFT_FRAC, DEFAULT_PINNED_DRIFT_DUR, DEFAULT_PINNED_DRIFT_IDLE, DEFAULT_PINNED_DRIFT_JITTER, WARP_RESPONSE, WARP_ZETA, } from "./constellationInteraction";
 export { kVisOf, readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, DEFAULT_PALETTE, } from "./constellationDraw";
-export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationField";
+export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationTypes";

package/dist/components/custom/dock/DockIconButton.vue.d.ts

@@ -9,6 +9,15 @@ import { type ButtonHTMLAttributes, type Component, type HTMLAttributes } from "
  * `as="a"` swaps the host tag, `as-child` merges the dock class onto a slotted
  * child (the reka-ui Primitive idiom). `type` is emitted only on a <button>
  * host (an anchor/RouterLink carries no `type`).
+ *
+ * BB.W-LIQUIDHOVER — the pointer-anchored moving-specular gleam AUTO-ARMS via the
+ * `v-specular` directive (the tier-root delivery wrapping the ONE position-write
+ * core, `createSpecularWriter`). The prior hand-composed `useSpecularTracking` +
+ * `:style="specularStyle"` + `@pointermove="onPointerMove"` triplet RETIRED onto it:
+ * the dock control gleams pointer-following with ZERO call-site wiring. The
+ * `.dock-icon-button` `::before` (material.css) paints + lifts intensity on hover/
+ * active; the directive supplies the position. PRM-aware by construction (the wrapped
+ * core skips the write under reduce; the CSS bracket pins the catch-light static).
  */
 type __VLS_Props = {
     /** Compact variant: auto-sized instead of fixed 2.5rem square. */
@@ -21,15 +30,15 @@ type __VLS_Props = {
     asChild?: boolean;
     class?: HTMLAttributes["class"];
 };
-declare var __VLS_10: {};
+declare var __VLS_8: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_10) => any;
+    default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    type: "button" | "submit" | "reset";
+    type: "button" | "reset" | "submit";
+    compact: boolean;
     asChild: boolean;
     as: string | Component;
-    compact: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/custom/dock/DockLayerGroup.vue.d.ts

@@ -16,20 +16,28 @@ type __VLS_Props = {
     showRail?: boolean;
     /** Rail placement relative to the layer stack. */
     railPosition?: "start" | "end";
+    /**
+     * BB.W-DRAG-MORPH — pull-to-switch. When `true` (ADDITIVE, default `false`),
+     * the switcher-rail indicator becomes draggable: pull along the rail axis to
+     * the next layer chip, fling-to-nearest on release writes `activeLayer`
+     * (`useDragMorph`, consumer #2). The reka roving tabindex / Arrow keys stay.
+     */
+    draggable?: boolean;
 };
 type __VLS_ModelProps = {
     "active": string;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_32: {};
+declare var __VLS_34: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_32) => any;
+    default?: (props: typeof __VLS_34) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:active": (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:active"?: ((value: string) => any) | undefined;
 }>, {
+    draggable: boolean;
     showRail: boolean;
     railPosition: "start" | "end";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/custom/dock/DockRail.vue.d.ts

@@ -10,25 +10,26 @@ import type { DockRailItem } from "./constants";
  * dock box is INVIOLATE (R6 §"design REDIRECT" item 1) — and it PERSISTS when the
  * dock collapses (the in-pane switcher rail vanishes on collapse; this one does not).
  *
- * W-RAIL3 EVOLUTION (the third-rail redirect). The prior facility was a single
- * end-icon (one `DockIconButton` cycling `entries` through an invisible list behind
- * a chevron). The contextual facets used to mount as an in-dock `<DockLayerGroup>`,
- * which stretched the dock box ~2× (the R6-1/R6-2 inflation). This wave MOVES the
- * facets OUT of the dock onto THIS rail as the visible chips — "a floating carousel
- * almost" (the user's words). The chips ARE the facets (id + label + icon); the
- * active one is highlighted; when a context carries more chips than fit inline the
- * strip scrolls/cycles (CSS `overflow` + `scroll-snap`).
+ * BA.W-DOCK-SECTIONS — THE DIVIDER-SEAM RE-SEAT (the 4th-rail re-conception). The
+ * facets ride the rail as visible chips (the W-RAIL3 move OUT of the dock body, kept),
+ * but the rail line now co-locates with a NAMED `<DockSeparator anchor>` seam — NOT the
+ * dock edge, NOT the midline (the workaround #4 the brief forbids). The seam line crosses
+ * THROUGH the dock and overruns BOTH edges by `--dock-rail-extend-length` each side (the
+ * SYMMETRIC dual-side overrun); the chips fan FLUSH against the line (the macOS fan-out,
+ * rectilinear), and on collapse they retract INTO the rail leaving a slight protrusion
+ * stub. GlassDock measures the anchored separator's offset (`--dock-rail-seam-offset`)
+ * and the rail's CSS seats the line at it. The chips ARE the facets (id + label + icon);
+ * the active one is highlighted. Overflow routes through `<FadingScroll>` (the Batch-2
+ * primitive — the single scroll-fade port; the bespoke parallel scroll-fade is retired):
+ * the common 2-4-facet set fans flush with no scroll; a larger set scrolls under the
+ * edge fade + the embla-on-overflow momentum (the >budget arm).
  *
- * Axis-aware (the `<DockSeparator>` idiom, read via `useOptionalDockContext()`):
- *   - column dock (vertical)  → the strip hangs BELOW the dock as a horizontal row
- *     of chips on a horizontal hairline (the dock is a narrow column; a horizontal
- *     chip row reads as the carousel below it).
- *   - row dock (horizontal)   → the strip runs BELOW the dock's bottom edge as a
- *     horizontal row of chips on the connective hairline.
  * The hairline is composed from the `--border-hairline` token pair (the 0.5px
  * catch-light + under-shadow the dock + instrument-chassis already speak) — a
- * whisper, NEVER a hard `1px solid` rule (R3). The beyond-edge overrun is
- * `--dock-rail-extend-length` (a dock-scoped geometry knob, consumer-overridable).
+ * whisper, NEVER a hard `1px solid` rule (R3). The dual-side overrun is
+ * `--dock-rail-extend-length` (a dock-scoped geometry knob, consumer-overridable);
+ * the seam axis keys off the dock `orientation` (a vertical dock's rail is a
+ * horizontal line, a horizontal dock's is vertical).
  *
  * The layer-context binding (R2 — one registry, NOT a parallel state path):
  *   The chips write the consumer-owned `v-model:context` — the SAME ref the consumer

package/dist/components/custom/dock/DockSection.vue.d.ts

@@ -0,0 +1,69 @@
+import type { DockSectionDescriptor } from "./constants";
+/**
+ * <DockSection> — BA.W-DOCK-SECTIONS. The declarative tripartite section-descriptor
+ * chassis the R8-9 mandate names ("the docks COMPLETELY lack sections" + "abstract
+ * this into a re-usable component for layering"). A consumer passes ONE
+ * `sections: readonly DockSectionDescriptor[]` array and the dock body renders the
+ * three-zone gestalt — a leading `rail-core` home/brand region, named `section`
+ * groups demarcated by `<DockSeparator>`, and a trailing `nav` group — by COMPOSING
+ * the existing `<DockSeparator>` (the divider seam) over the dock's already-in-flow
+ * controls, NOT a parallel layer machine and NOT a re-mounted column-rail layer
+ * group (the W-RAIL3 inflation source).
+ *
+ * THE NO-INFLATION CONTRACT (the spec's Scope item 2). The section model returns
+ * WITHOUT the box-inflation that motivated W-RAIL3's deletion: `<DockSection>` GROUPS
+ * the controls a consumer already places (via the per-kind slots) and adds only
+ * `<DockSeparator>` seams between them. It does NOT mount a `<DockLayerGroup>` switcher
+ * rail (the prior inflator that demanded column height). A section's contextual facets
+ * (`descriptor.layers`) are surfaced to the consumer to feed the seam `<DockRail>` —
+ * the facets ride the rail OUTSIDE the dock box, never re-inflate it.
+ *
+ * DESCRIPTOR-DRIVEN (the gate's S1 bite). The render is a `v-for` over `sections`,
+ * the `kind` switching the zone — a 5-section dock renders from the array, never a
+ * hardcoded three-element literal. Each descriptor's content is the consumer's slot
+ * keyed by the descriptor `id` (so the consumer keeps authoring its real controls);
+ * the chassis owns ONLY the zone grouping + the divider rhythm + the `data-kind`
+ * marker the section.css recipe reads.
+ *
+ * The seam ANCHOR (direction (b)). The descriptor carrying `anchor: true` (or, by
+ * convention, the boundary BEFORE the trailing `nav` group / the rail-core tail) marks
+ * its leading `<DockSeparator anchor>` so the dock's `#rail` line co-locates with that
+ * divider. The chassis stamps `anchor` on the separator that precedes the FIRST
+ * post-rail-core / pre-nav boundary by default; a consumer overrides via the
+ * `anchorId` prop.
+ */
+type __VLS_Props = {
+    /**
+     * The declarative section descriptors. Rendered in order: `rail-core` leads,
+     * `section` groups follow (each preceded by a `<DockSeparator>`), `nav` trails.
+     */
+    sections: readonly DockSectionDescriptor[];
+    /**
+     * Which descriptor's LEADING `<DockSeparator>` is the rail's anchor seam
+     * (direction (b)). Defaults to the first `nav` descriptor (the user's "the nav
+     * separator on the bottom dock"); on a dock with no `nav` the first boundary
+     * after `rail-core` anchors. Pass an explicit `id` to override (the ℱ-home
+     * separator on the sidebar is the `rail-core`'s trailing seam — pass its id).
+     */
+    anchorId?: string;
+    /** Accessible label for the section group landmark. */
+    ariaLabel?: string;
+};
+declare var __VLS_7: string, __VLS_8: {
+    section: DockSectionDescriptor;
+    kind: import("./constants").DockSectionKind;
+};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_7>]?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    ariaLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/dock/DockSeparator.vue.d.ts

@@ -1,3 +1,51 @@
-declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * <DockSeparator> — AX.W45 D13-c / DK5.
+ *
+ * An orientation-aware divider that demarcates dock item GROUPS (transport |
+ * navigation | settings) for affordance hierarchy. The raw `.dock-separator`
+ * class was axis-blind — a fixed VERTICAL 1px hairline that paints a useless
+ * 1px-wide sliver in a column (vertical) dock and a single cell-sliver in a grid
+ * dock. This primitive bundles the orientation contract the bare class could not:
+ * it reads the dock `orientation`/`layout` via `useOptionalDockContext()` and the
+ * dock-root ancestor class (`.glass-dock.vertical` / `.layout-grid`) drives the
+ * PERPENDICULAR paint (dock.css) —
+ *   - row dock (horizontal, default) → a vertical 1px hairline
+ *   - column dock (vertical / rail)  → a horizontal 1px rule (cross-extent)
+ *   - grid dock (`layout="grid"`)     → a full-row section break (grid-column: 1 / -1)
+ *
+ * It is a thin oriented `<div>` (KISS); `data-orientation` is the explicit axis
+ * marker (so the perpendicular paint resolves even when used inside a
+ * `<DockLayerGroup>` that is not directly under a `.glass-dock.vertical`). It
+ * renders outside a dock too (the optional context defaults to horizontal) — a
+ * befitting-silent standalone render, not a violation.
+ *
+ * Decorative by role: `role="separator"` + `aria-orientation` give it a semantic
+ * landmark without it being interactive (it has no four-state contract — a flex
+ * gap rule, not a control).
+ *
+ * BA.W-DOCK-SECTIONS — the `anchor` prop is the seam-locator (direction (b)): an
+ * anchored separator stamps `data-rail-anchor`, which the enclosing `<GlassDock>`
+ * reads to seat the `#rail` line AT this divider's measured offset (the divider IS
+ * the rail's anchor seam — one primitive folds R8-9's section-divider model and
+ * R8-1's anchor-at-the-divider). The exposed measurable seam offset is the painted
+ * position of this element within the dock-frame; GlassDock's seam read consumes it.
+ */
+type __VLS_Props = {
+    /**
+     * BA.W-DOCK-SECTIONS — the seam-locator affordance (direction (b): the
+     * separator IS the rail's anchor). When `anchor` is set the separator stamps a
+     * `data-rail-anchor` marker so the enclosing `<GlassDock>` can read THIS
+     * divider's measured offset within the dock-frame and seat the `#rail` line at
+     * it (the divider and the rail unify into one primitive — the user's "where the
+     * dividing line is"). NO geometry side-effect on the separator itself; it is the
+     * SAME thin oriented hairline either way, just flagged as the rail's seam. A
+     * dock with at most one anchored separator is the contract (the first marked
+     * wins; the rail reads one seam offset).
+     */
+    anchor?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    anchor: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/custom/dock/DockTabButton.vue.d.ts

@@ -10,11 +10,11 @@ import { type HTMLAttributes } from "vue";
  * automatically activates when the rendered element carries
  * aria-current="page" (which RouterLink sets).
  *
- * K.W6 Lane B — when the consumer attaches `data-tier="primary"`, the
- * button composes the canonical `btn-audacious` utility (the lifted
- * disco-grain + sparkle-sweep + specular-highlight recipe at
- * `utilities.css`). `dock.css` retains the dock-local phase-tinting +
- * structural shell on top of the canonical recipe.
+ * BA.W-GLASS-CAL (H2a) — the `data-tier="primary"` auto-attach of the
+ * `btn-audacious` disco utility is REMOVED (the recipe is retired). The primary
+ * tier now reads ONLY its dock-local structural shell + the plain de-red'd glass
+ * hover register (`dock-controls/tab-button.css`); `data-tier` is still the styling
+ * hook the CSS keys off, the component no longer composes a utility class.
  */
 type __VLS_Props = {
     as?: string;