@mkbabb/glass-ui 3.9.0 → 3.10.1

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

@@ -1,5 +1,4 @@
-/** Reference width the `k` scale factor is keyed to (CSS px). */
-export declare const BASE_WIDTH = 1280;
+export { BASE_WIDTH } from "./constants";
 export interface ConstellationNode {
     x: number;
     y: number;
@@ -51,6 +50,89 @@ export interface ConstellationWarp {
     /** 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 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`
@@ -79,6 +161,28 @@ export interface ConstellationField {
     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 `<Constellation>` consumer prop surface (the public type a consumer types
@@ -92,6 +196,15 @@ export interface ConstellationProps {
     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. */
@@ -103,18 +216,50 @@ export interface ConstellationProps {
      * 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;
+    };
+    /**
+     * 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;
 }
-export declare const DEFAULT_PALETTE: ConstellationPalette;
-/**
- * Resolve the FULL neutral palette + legibility weights off a canvas's resolved
- * custom properties (AX.W17). The colors AND the alpha multipliers route through
- * the same `getComputedStyle` probe, so a dark-mode flip re-resolves BOTH the
- * `:root`/`.dark` color arms AND the per-mode alpha defaults in one read.
- */
-export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPalette;
 /**
  * Seed `count` drifting nodes inside `w × h`. `rng` is a `() => number` in
  * `[0, 1)` (the glass-ui `mulberry32`/`Math.random`); a seeded `rng` lays out a
@@ -124,6 +269,19 @@ export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPal
  * adds one, so node count is conserved).
  */
 export declare function seedField(rng: () => number, count: number, w: number, h: number, speed: number): ConstellationNode[];
+/**
+ * Re-fit the existing lattice to a NEW canvas size, proportionally, ON the
+ * size-change frame (AY.W-CON1). Without it a field seeded at a transitional
+ * size (the canvas measures mid responsive-scale — the deck slide-enter case)
+ * keeps its small-canvas positions and DRIFTS out to fill the larger box at
+ * `speed` px/frame — the visible "takes a while to expand out" lag the slides
+ * bespoke copy fixed. Scales node + warp positions by the per-axis dimension
+ * ratio; velocities are UNTOUCHED (they are base-width direction vectors
+ * `k`-scaled at step time — scaling them would HEAT the field, breaking the
+ * cool-down invariant). No-op on first layout (`prev ≤ 0`; the seed path owns
+ * it) or unchanged dims.
+ */
+export declare function refitField(field: ConstellationField, prevW: number, prevH: number): void;
 /**
  * Advance the field one step: drift + wall-bounce every node, then (if the
  * pointer is live) lean nodes within reach toward the cursor WITHOUT changing
@@ -133,58 +291,11 @@ export declare function seedField(rng: () => number, count: number, w: number, h
  * via `warpStep` INSIDE this single per-frame call (AX.W17) — NO second rAF,
  * NO `useSpring`. The warp rides the substrate's ONE parked rAF; a `dt` of `0`
  * (omitted / first frame) leaves the spring untouched.
- */
-export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number): void;
-/**
- * The nearest DRIFTING node to `(px, py)` in canvas-local px — a linear O(count)
- * min-d² scan (count 64 default — negligible; matches the O(count²) edge pass).
- * "Lattice point" = the nearest drifting NODE (the constellation has NO fixed
- * lattice). `excludeIdx` drops a node from the candidate set (the focal node
- * excludes ITSELF, so a cursor-on-focal warp no-ops). Returns `-1` if no
- * eligible node exists (empty field, or only the excluded node).
- */
-export declare function nearestNode(field: ConstellationField, px: number, py: number, excludeIdx?: number): number;
-/**
- * Advance the focal-node warp spring one `dt` (seconds). A per-axis 2nd-order
- * critically-damped integrator over `field.warp.{x,y}` toward the LIVE position
- * of `field.nodes[field.warp.targetIdx]` — re-read EACH frame, so the spring
- * CHASES a drifting target and arrives ON it (the identity-ride). No-ops when no
- * warp is active (`targetIdx < 0`). `dt` is clamped to {@link WARP_DT_CLAMP} so a
- * tab-throttle / offscreen-park-resume gap cannot teleport the mark.
  *
- *   x += v·dt ;  v += (−2ζω·v − ω²·(x − target))·dt
- *
- * Reuses the keyframes.js `(response, dampingFraction)` param model
- * (ω = 2π/response, ζ = dampingFraction) but NOT its rAF — the FORBID-useSpring
- * contract (a second rAF would defeat the parked-substrate one-path freeze).
- */
-export declare function warpStep(field: ConstellationField, dt: number): void;
-/**
- * Point the warp at a node INDEX (the live target-source seam). The focal node
- * re-points to `idx`; the spring chases `nodes[idx]`'s LIVE position FROM the
- * focal mark's CURRENT position (`warp.{x,y}`) — a continuous spring-eased path,
- * never a snap. The component seeds `warp.{x,y}` at field-center on first layout,
- * so even the first warp springs from a real start point. `idx < 0` clears the
- * warp (the focal mark is removed). Re-pointing does NOT zero the velocity, so a
- * mid-flight re-target curves smoothly toward the new node.
- */
-export declare function setWarpTarget(field: ConstellationField, idx: number): void;
-/**
- * Warp the focal node to the nearest drifting node to a canvas-LOCAL px point
- * (the `warpTo(point)` primitive). The DEGENERATE case — the click's UNCONSTRAINED
- * nearest node is already the current focal (cursor on/closest to the focal mark)
- * — NO-OPS (returns the current focal; a click on yourself does not re-warp). Any
- * OTHER click re-points to the nearest node, with the focal EXCLUDED from the
- * candidate set (you never re-warp to yourself; the next-nearest wins). Returns
- * the chosen node index, or `-1` when no eligible node exists. The component's
- * `warpTo(clientX, clientY)` sugar maps client→local px via `toLocal` first.
+ * `now` (ms; default `0` — every existing caller stays green) + `rng` (default
+ * `Math.random`) drive the optional auto-DRIFT cadence (AY.W-CON1): AFTER the
+ * warp step, if `field.wander` is set and `now > 0`, the cadence re-points
+ * `setWarpTarget` to a random node when it elapses AND the spring has settled
+ * (a click-warp in flight pre-empts the cadence — `warpSettled` reports false).
  */
-export declare function warpTo(field: ConstellationField, px: number, py: number): number;
-/** Pass 1 — hairline edges between any two nodes within `link` px (alpha falls off with distance). */
-export declare function drawEdges(ctx: CanvasRenderingContext2D, field: ConstellationField, link: number, palette: ConstellationPalette): void;
-/** Pass 2 — ambient node dots. */
-export declare function drawNodes(ctx: CanvasRenderingContext2D, field: ConstellationField, palette: ConstellationPalette): void;
-/** Pass 3 — the cursor joins the web: faint links to nodes within reach + a soft cursor node. */
-export declare function drawPointerWeb(ctx: CanvasRenderingContext2D, field: ConstellationField, link: number, palette: ConstellationPalette, pointer: ConstellationPointer | null): void;
-/** Pass 4 — tap ripples: expanding rings that fade over ~0.9s; consumed entries are spliced. */
-export declare function drawRipples(ctx: CanvasRenderingContext2D, field: ConstellationField, now: number, ripples: ConstellationRipple[], palette: ConstellationPalette): void;
+export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number, now?: number, rng?: () => number): void;

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

@@ -0,0 +1,102 @@
+import type { ConstellationField, ConstellationWarpConfig, ConstellationWellConfig } from "./constellationField";
+import { DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_WELL_CONFIG, WARP_RESPONSE, WARP_ZETA } from "./constants";
+export { DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_WELL_CONFIG, WARP_RESPONSE, WARP_ZETA };
+/**
+ * Read the NUMERIC interaction-tuning tokens (the warp spring + the gravity-well
+ * gains) off a canvas's resolved custom properties — ONCE on mount (AY.W-CON2),
+ * via `parseFloat`, NOT per-frame `getComputedStyle` (the hot loop stays clean).
+ * Returns `{ warp, well }` configs the field carries; every member falls back to
+ * the shipped default when the token is absent (an SSR / no-token mount reads the
+ * byte-identical spring). The tokens are PLAIN numbers (`0.55`, `12000`), immune
+ * to the W30 `light-dark()`-into-Canvas2D leak (they never reach a `fillStyle`).
+ */
+export declare function readInteractionConfig(canvas: HTMLCanvasElement): {
+    warp: ConstellationWarpConfig;
+    well: ConstellationWellConfig;
+    wander: {
+        minIdle: number;
+        jitter: number;
+    };
+};
+/**
+ * Advance the gravity-well one `dt` (AY.W-CON2). A transient held-pointer force
+ * composed inside `stepField` (NO new rAF): ease `well.strength` toward
+ * `well.target` (1 held / 0 released) at `cfg.ramp`/s; while active, add an
+ * inverse-square pull toward the held point onto each node within `cfg.reach`
+ * (the `max(d, soften)` no-singularity floor + the `cfg.maxSpeed` no-slingshot
+ * clamp); ALWAYS ease every node's |v| back toward `speed` (the field-cools
+ * invariant — so a released well re-settles). No-ops (entirely skipped) when
+ * `field.well` is undefined → the default render is byte-identical to HEAD.
+ *
+ * `dt` is clamped to {@link WARP_DT_CLAMP} (the same park-resume guard the warp
+ * uses) so a tab-throttle gap cannot slingshot the field in one giant step.
+ */
+export declare function stepWell(field: ConstellationField, k: number, speed: number, dt: number): void;
+/**
+ * The nearest DRIFTING node to `(px, py)` in canvas-local px — a linear O(count)
+ * min-d² scan (count 64 default — negligible; matches the O(count²) edge pass).
+ * "Lattice point" = the nearest drifting NODE (the constellation has NO fixed
+ * lattice). `excludeIdx` drops a node from the candidate set (the focal node
+ * excludes ITSELF, so a cursor-on-focal warp no-ops). Returns `-1` if no
+ * eligible node exists (empty field, or only the excluded node).
+ */
+export declare function nearestNode(field: ConstellationField, px: number, py: number, excludeIdx?: number): number;
+/**
+ * Advance the focal-node warp spring one `dt` (seconds). A per-axis 2nd-order
+ * critically-damped integrator over `field.warp.{x,y}` toward the LIVE position
+ * of `field.nodes[field.warp.targetIdx]` — re-read EACH frame, so the spring
+ * CHASES a drifting target and arrives ON it (the identity-ride). No-ops when no
+ * warp is active (`targetIdx < 0`). `dt` is clamped to {@link WARP_DT_CLAMP} so a
+ * tab-throttle / offscreen-park-resume gap cannot teleport the mark.
+ *
+ *   x += v·dt ;  v += (−2ζω·v − ω²·(x − target))·dt
+ *
+ * Reads `(response, ζ)` from `field.warpCfg` (the tokenised override — AY.W-CON2),
+ * falling back to the shipped `WARP_RESPONSE`/`WARP_ZETA` defaults. `ω = 2π/response`
+ * is the keyframes.js `(response, dampingFraction)` convention (the SHARED house
+ * model — `ω₀` is the angular frequency, `response` its ANGULAR PERIOD, NOT a
+ * settle-duration; at ζ=1 the 2%-settle is `t₂ ≈ 5.83/ω₀ ≈ 0.93·response`). NO
+ * second ω formula is minted (the ω-reconcile). NOT its rAF — the FORBID-useSpring
+ * contract (a second rAF would defeat the parked-substrate one-path freeze).
+ */
+export declare function warpStep(field: ConstellationField, dt: number): void;
+/**
+ * Point the warp at a node INDEX (the live target-source seam). The focal node
+ * re-points to `idx`; the spring chases `nodes[idx]`'s LIVE position FROM the
+ * focal mark's CURRENT position (`warp.{x,y}`) — a continuous spring-eased path,
+ * never a snap. The component seeds `warp.{x,y}` at field-center on first layout,
+ * so even the first warp springs from a real start point. `idx < 0` clears the
+ * warp (the focal mark is removed). Re-pointing does NOT zero the velocity, so a
+ * mid-flight re-target curves smoothly toward the new node.
+ */
+export declare function setWarpTarget(field: ConstellationField, idx: number): void;
+/**
+ * Warp the focal node to the nearest drifting node to a canvas-LOCAL px point
+ * (the `warpTo(point)` primitive). The DEGENERATE case — the click's UNCONSTRAINED
+ * nearest node is already the current focal (cursor on/closest to the focal mark)
+ * — NO-OPS (returns the current focal; a click on yourself does not re-warp). Any
+ * OTHER click re-points to the nearest node, with the focal EXCLUDED from the
+ * candidate set (you never re-warp to yourself; the next-nearest wins). Returns
+ * the chosen node index, or `-1` when no eligible node exists. The component's
+ * `warpTo(clientX, clientY)` sugar maps client→local px via `toLocal` first.
+ */
+export declare function warpTo(field: ConstellationField, px: number, py: number): number;
+/**
+ * Is the warp spring ARRIVED on its target (AY.W-CON1)? True when there is no
+ * active target (`targetIdx < 0`) OR the focal's gap to its LIVE target node is
+ * within {@link WARP_SETTLE_BAND}. A click-warp in flight (hundreds of px out)
+ * reports NOT arrived, so a user click always PRE-EMPTS the auto-drift cadence
+ * (the wander only re-targets a spring that has reached its current node). The
+ * gate is POSITION-only by design — a critically-damped spring tracking a drifting
+ * node carries a non-zero steady-state velocity forever, so a velocity term would
+ * never clear on a live field.
+ */
+export declare function warpSettled(field: ConstellationField): boolean;
+/**
+ * Pick a random eligible node index for the auto-drift re-target (AY.W-CON1) —
+ * any node EXCEPT the current `focalIndex` (so the focal actually MOVES). `rng`
+ * is the seeded `() => number` in `[0, 1)`. A degenerate field (≤1 node, or only
+ * the current focal) returns the current focal, which `setWarpTarget` no-ops
+ * cleanly (no crash, no jump).
+ */
+export declare function pickWanderTarget(field: ConstellationField, rng: () => number): number;

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

@@ -1,3 +1,5 @@
 export { default as Constellation } from "./Constellation.vue";
-export { seedField, stepField, readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, nearestNode, warpStep, warpTo, setWarpTarget, BASE_WIDTH, DEFAULT_PALETTE, } from "./constellationField";
-export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationProps, } from "./constellationField";
+export { seedField, stepField, refitField, BASE_WIDTH, } from "./constellationField";
+export { stepWell, nearestNode, readInteractionConfig, warpStep, warpTo, setWarpTarget, warpSettled, pickWanderTarget, DEFAULT_WELL_CONFIG, DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, WARP_RESPONSE, WARP_ZETA, } from "./constellationInteraction";
+export { readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, DEFAULT_PALETTE, } from "./constellationDraw";
+export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationProps, } from "./constellationField";

package/dist/components/custom/controls/DarkModeToggle.vue.d.ts

@@ -13,11 +13,22 @@ type __VLS_Props = {
      * @default false
      */
     disableTransitions?: boolean;
+    /**
+     * Opt-in slow-ECLIPSE register: a LONG-PRESS (vs the normal click) flips
+     * the mode through an indulgent, stretched sun↔moon cross-fade — the
+     * `--toggle-eclipse-duration` (≈1600ms) over the default 750ms. The bare
+     * `@click` flip is UNCHANGED (the default-path canary). Under
+     * `prefers-reduced-motion: reduce` the long-press flips INSTANTLY (no
+     * eclipse). Default false — the toggle behaves exactly as before.
+     * @default false
+     */
+    eclipse?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     size: DarkModeToggleSize;
     passive: boolean;
     disableTransitions: boolean;
+    eclipse: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,111 +1,3 @@
-type DockDensity = "compact" | "comfortable" | "spacious" | "audacious";
-interface DockCommonProps {
-    fitContent?: boolean;
-    position?: "fixed" | "inline" | "sticky";
-    alwaysExpanded?: boolean;
-    /**
-     * Corner treatment.
-     *   `"pill"`    — the stadium silhouette (default).
-     *   `"rounded"` — a finite rounded radius (`--radius-xl`).
-     *   `"card"`    — the AW.W3b big-dock card shell: a finite concentric
-     *                 radius (`--dock-card-radius`, default `--radius-3xl`)
-     *                 ABOVE 2xl, below pill — does NOT collapse to a stadium.
-     *                 Collapsed it returns to a pill; the pill↔card swap
-     *                 morphs on the `--dock-motion-resize` spring. AX.W56's
-     *                 squircle policy applies `corner-shape:
-     *                 var(--corner-shape-bigdock)` here under `@supports
-     *                 (corner-shape: superellipse(2))` — the big-dock is the ONE
-     *                 surface where the superellipse reads (cards/pills stay
-     *                 round); the border-radius arc is the cross-engine contract.
-     *
-     * `"pill"`/`"rounded"` previously bound ONLY under the vertical rail
-     * variant — on a horizontal dock the prop silently no-op'd. AW.W3b adds
-     * the horizontal-root shape rules (closing that documented-but-dead prop),
-     * so `shape` now paints on a horizontal dock too.
-     */
-    shape?: "pill" | "rounded" | "card";
-    /**
-     * Layout axis of the dock. `"horizontal"` (default) lays items out
-     * left-to-right and animates `width`; `"vertical"` lays items out
-     * top-to-bottom and animates `height`. IGNORED under `variant="rail"` /
-     * `"instrument-strip"` (those force vertical by construction).
-     */
-    orientation?: "horizontal" | "vertical";
-    /**
-     * Density controls dock padding, gaps, layer height, and inherited
-     * dock control sizing. Root CSS variables can override each density.
-     */
-    density?: DockDensity;
-    /**
-     * Overflow strategy when the expanded content exceeds the dock's
-     * axis cap (`--dock-max-inline-size` horizontally,
-     * `--dock-max-block-size` vertically). The ONE knob governing every
-     * overflow behaviour (AT.W7-dock-a clean break — collapsed from the
-     * prior `wrap` boolean + `overflow` pair + `containerName` clip-lift,
-     * which all touched overflow divergently).
-     *   `"grow"`   — content grows to fit then overflows visibly past
-     *                the cap (the default; nothing clips or scrolls).
-     *   `"wrap"`   — expanded content wraps to multiple rows via CONTENT-DRIVEN
-     *                intrinsic flex-wrap (the `.dock-overflow-wrap` recipe). The
-     *                dock shrink-wraps to content and caps that intrinsic width
-     *                at `max-inline-size: var(--dock-max-inline-size)`, so the row
-     *                reflows to N rows EXACTLY when its intrinsic width exceeds
-     *                the cap — at ANY viewport width — and collapses to one row
-     *                when it fits (no viewport breakpoint). The wrapped multi-row silhouette lifts
-     *                onto the card/floating shadow tier as the dock expands.
-     *                HORIZONTAL-ONLY: a vertical rail grows-to-fit + clamps via
-     *                `--dock-max-block-size` (its own overflow story), so the
-     *                `.dock-overflow-wrap` class is not emitted for a vertical
-     *                orientation.
-     *   `"scroll"` — the dock becomes the scroll port. Horizontal docks
-     *                scroll the active layer on the inline axis
-     *                (`.dock-scroll-x`); vertical rails scroll on the
-     *                block axis (`.dock-scroll-y`), keeping the
-     *                `max-block-size` cap. The rounded pill masks the
-     *                scroll edge; the scrollbar is hidden. The axis is
-     *                chosen automatically from `orientation`.
-     */
-    overflow?: "grow" | "wrap" | "scroll";
-    /**
-     * When set, the dock root establishes an inline-size container query
-     * subject (`container-type: inline-size; container-name: <value>`) so
-     * descendants can query the named container via `@container <value>
-     * (...)` rules. ORTHOGONAL to the `overflow` clip: opting into a
-     * container subject does NOT silently change the dock's clip shell
-     * (AT.W7-dock-a — the prior clip-lift was folded out; use
-     * `overflow="wrap"` to allow multi-line content).
-     *
-     * T.B audit §1.3 cornerstone: the cluster's container subject must
-     * live on the dock primitive, never on a descendant whose intrinsic
-     * size the dock relies on.
-     */
-    containerName?: string;
-}
-interface DockVariantProps extends DockCommonProps {
-    variant?: "dock";
-    /** Idle-collapse delay in ms (default 2000). DOCK-ONLY — a rail never collapses. */
-    collapseDelay?: number;
-    /** Start in the collapsed state (default true). DOCK-ONLY — a rail is always expanded. */
-    startCollapsed?: boolean;
-    /**
-     * In-cap arrangement. `"linear"` (default) lays the active layer out as a
-     * linear row/column. `"grid"` makes the active layer a self-wrapping tile
-     * grid (Launchpad/Stage-Manager track symmetry — `auto-fill` columns of
-     * `--dock-tile-min`). ORTHOGONAL to `overflow` (the OVER-cap strategy):
-     * `layout` is the IN-cap arrangement.
-     *
-     * Hard contract: a `layout="grid"` dock is `alwaysExpanded` (a 2D panel
-     * does not read as a collapsible pill, and no width morph means no
-     * per-frame grid reflow). The canonical pairing is
-     * `shape="card" layout="grid"` (the props stay independent — no
-     * auto-implication of `shape`). DOCK-ONLY — the grid is a horizontal big-dock
-     * arrangement, never a rail's.
-     */
-    layout?: "linear" | "grid";
-}
-interface DockRailProps extends DockCommonProps {
-    variant: "rail" | "instrument-strip";
-}
 declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_14: {};
 type __VLS_Slots = {} & {
     persistent?: (props: typeof __VLS_1) => any;
@@ -118,7 +10,7 @@ type __VLS_Slots = {} & {
 } & {
     collapsed?: (props: typeof __VLS_14) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<DockVariantProps | DockRailProps, {
+declare const __VLS_base: import("vue").DefineComponent<import("./composables/useDockShellProps").DockVariantProps | import("./composables/useDockShellProps").DockRailProps, {
     expanded: import("vue").Ref<boolean, boolean>;
     isPinned: import("vue").Ref<boolean, boolean>;
     isHeld: import("vue").ComputedRef<boolean>;
@@ -127,7 +19,7 @@ declare const __VLS_base: import("vue").DefineComponent<DockVariantProps | DockR
     collapse: () => void;
     keepOpen: () => void;
     release: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DockVariantProps | DockRailProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./composables/useDockShellProps").DockVariantProps | import("./composables/useDockShellProps").DockRailProps> & Readonly<{}>, {}, {}, {}, {}, 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;

package/dist/components/custom/dock/composables/dockMorphContext.d.ts

@@ -1,4 +1,40 @@
 import type { Ref } from "vue";
+/**
+ * AX.W02 — ONE morph orchestrator per dock. The dock is a single morph stack
+ * whose active "layer" is `(expandedState × activePane)`: the outer
+ * collapse↔expand swap and the inner `<DockLayerGroup>` pane swaps are
+ * transitions in the SAME group — ONE spring, ONE scalar (`--dock-morph-t`,
+ * established by W01), ONE clock. No second engine.
+ *
+ * Re-derived from first principles on W01's settled single-scalar substrate:
+ *  - `--dock-morph-t` is written to the `.glass-dock` root and INHERITS to every
+ *    descendant (dock.css `@property … inherits:true`), so ONE spring writing
+ *    that one scalar drives EVERY registered container's size calc at once.
+ *  - Each morphing container carries its OWN `--dock-morph-from`/`--dock-morph-to`
+ *    px span (the allowed one-time FLIP measurement) and interpolates it against
+ *    the shared scalar — `from + (to − from) · t`. So a simultaneous
+ *    collapse + pane-swap reads as one continuous spring: the box, the nested
+ *    stack, and every child stagger ramp on the same `t`.
+ *
+ * The orchestrator OWNS one `SpringProgress`. The OUTER collapse↔expand pair
+ * registers as a target; a NESTED `<DockLayerGroup>` registers a SECOND target
+ * instead of minting its own `useLayerTransition` engine. A re-toggle mid-flight
+ * re-bases the live solver onto the new span from its current velocity (the iOS
+ * interruptible-physics contract W01 keeps), so even an interrupted morph stays
+ * one continuous trajectory.
+ *
+ * This is the dock-flavored first instance of the general `MorphGroup` /
+ * `GlassEffectContainer` facility (the iOS-26 Liquid-Glass corpus, facet 26 —
+ * the `provideMorphGroup` two-part seam: a per-element driver + a provide/inject
+ * orchestrator). AX.W42 generalizes it; W02 establishes the seam it builds on.
+ *
+ * LIGHT-surface only: `SpringProgress` owns its own rAF via `.play(onFrame)` and
+ * carries no static value.js edge — never import `AnimationGroup` / `./engine`
+ * (that pulls value.js into the dock bundle).
+ *
+ * The `DOCK_SPRING` tuning this orchestrator drives is the ONE authority shared with
+ * `useLayerTransition` — it lives in `../constants` (the feature-dir constants home).
+ */
 export interface DockMorphGroupRegistration {
     /** The container element owning this group's grid-stacked panes. */
     containerEl: Ref<HTMLElement | null>;

package/dist/components/custom/dock/composables/useDockMorphWindow.d.ts

@@ -0,0 +1,15 @@
+import { type Ref } from "vue";
+/** The morph-window handlers the GlassDock SFC wires. */
+export interface DockMorphWindow {
+    markTransitioning: () => void;
+    onDockTransitionDone: (event: TransitionEvent) => void;
+    clearTransitionTimer: () => void;
+}
+/**
+ * Own the `isTransitioning` flag's morph-window lifecycle. `markTransitioning`
+ * (every `visualExpanded` flip) bumps a private generation so any in-flight
+ * morph's pending timer / `transitionend` self-cancels (the A→B→A no-skip /
+ * no-queue invariant); `onDockTransitionDone` resolves the flag on a resize-morph
+ * property finishing. Clears its timer on unmount.
+ */
+export declare function useDockMorphWindow(dockEl: Ref<HTMLElement | null>, isTransitioning: Ref<boolean>): DockMorphWindow;