@mkbabb/glass-ui 3.9.0 → 3.10.0

package/dist/components/custom/constellation/Constellation.vue.d.ts

@@ -47,19 +47,81 @@ type __VLS_Props = {
      * method (via `defineExpose`) is the seam this prop sugars.
      */
     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 (the 2nd half of the AX.W17 "drift + warp are ONE mechanic" thesis;
+     * no second rAF, no second mechanic). `true` uses the default cadence
+     * (8–16s, the slides rhythm); `{ minIdle?, jitter? }` tunes it (ms). Default
+     * OFF — `wander` absent leaves `field.wander` undefined, byte-identical to
+     * HEAD. PRM-gated by the WARP precedent: the cadence lives inside the
+     * `!reducedMotion` step block, so under reduced-motion it never advances and
+     * the focal mark stays at its seed (NOT fire-but-freeze).
+     */
+    wander?: boolean | {
+        minIdle?: number;
+        jitter?: number;
+    };
+    /**
+     * Pointer-held GRAVITY-WELL (AY.W-CON2). Hold the pointer over the lattice and
+     * the nodes within reach are PULLED toward it (an inverse-square force on the
+     * SAME engine, no second 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
+     * `--constellation-well-*` defaults; an object overrides the gains. Default
+     * OFF — `gravityWell` absent leaves `field.well` undefined (byte-identical to
+     * HEAD; `stepField` skips the force pass). PRM-gated by the WARP precedent: the
+     * held-timer block lives inside `!reducedMotion`, so under reduced-motion the
+     * well never arms; AND the well STATE resets to neutral on the PRM-true edge
+     * (no half-ramped force frozen on).
+     */
+    gravityWell?: boolean | {
+        holdMs?: number;
+        gain?: number;
+        reach?: number;
+        ramp?: number;
+        maxSpeed?: number;
+        soften?: number;
+    };
+    /**
+     * Deterministic-capture freeze (AY.W-CON3). When `true`, the lattice lays
+     * out ONE reproducible STATIC frame and does NOT advance — seeded layout
+     * (set `seed` for a stable field ACROSS runs; an unseeded freeze still
+     * freezes but lays out a one-shot `Math.random` frame), no `stepField`, no
+     * ripple / warp / wander / well advance, and a FROZEN `now` handed to
+     * `drawOverlay` so a phase-driven skin (`(now % T) / T`) resolves to a fixed
+     * value (the pulse-ring radius is identical frame-over-frame). Omit to
+     * AUTO-DERIVE from `location.search` matching `export | print | freeze` (the
+     * deploy-pipeline contract — a consumer's pptx / print / screenshot capture
+     * gets a stable frame with zero per-consumer wiring). An explicit
+     * `:freeze="false"` forces live even under a capture URL. Unifies with the
+     * reduced-motion one-static-frame path — `freeze || reducedMotion` is the
+     * single static-frame predicate; the capture takes no input (the pointer /
+     * warp / well listeners are NOT registered under freeze).
+     */
+    freeze?: boolean;
     class?: HTMLAttributes["class"];
     /**
      * The skin seam. Runs after the neutral passes with the live field, so a
      * consumer paints its own focal mark pinned to a real node — read
      * `field.warp.{x,y}` for the spring-eased focal position when `warpOnClick`
      * is on. The branded content (a domain accent, a callout label) lives HERE,
-     * in the consumer.
+     * in the consumer. Under `freeze` it receives a FROZEN `now`, so a phase-
+     * driven mark resolves to a fixed value.
      */
     drawOverlay?: (ctx: CanvasRenderingContext2D, field: ConstellationField, now: number) => void;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     /** The live field (the low-level imperative seam — for a custom overlay). */
     field: ConstellationField;
+    /**
+     * The resolved deterministic-capture predicate (AY.W-CON3) — `true` when the
+     * lattice is laying out a frozen static frame (`freeze` prop OR a
+     * `?export|print|freeze` URL OR reduced-motion via the substrate). A read-only
+     * test/debug seam (the π freeze-live spec reads it to confirm the auto-derive
+     * fired without inferring from drift).
+     */
+    isFrozen: import("vue").ComputedRef<boolean>;
     /**
      * Imperative warp (AX.W17). Two call shapes:
      *   `warpTo(localPoint)`              — `{x, y}` already in canvas-local px
@@ -75,6 +137,16 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
         x: number;
         y: number;
     } | number, b?: number): number;
+    /**
+     * Imperatively ARM the gravity-well at a canvas-LOCAL point (AY.W-CON2) — the
+     * π-lane test seam that drives the well WITHOUT racing a real held-pointer
+     * gesture + the held-timer. Sets the well position + `target = 1` directly (the
+     * timer is bypassed; the ramp still eases `strength` over the next frames). No-op
+     * when `gravityWell` is off (no `field.well`). Returns true when the well armed.
+     */
+    holdWellAt(x: number, y: number): boolean;
+    /** Imperatively RELEASE the well (AY.W-CON2) — `target → 0`, the field cools. */
+    releaseWell(): void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -51,6 +51,98 @@ 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;
+}
+/**
+ * Auto-DRIFT cadence DEFAULTS (AY.W-CON1 source; tokenised in AY.W-CON2). The
+ * `--constellation-wander-idle`/`-wander-jitter` tokens override these on mount via
+ * `readInteractionConfig` (the SAME numeric `--constellation-*` cohort as the warp
+ * spring + the well gains); a prop `{ minIdle, jitter }` still wins over the token.
+ * The 8s/8s default rhythm re-targets the focal mark every 8–16s (the slides cadence).
+ */
+export declare const DEFAULT_WANDER_IDLE = 8000;
+export declare const DEFAULT_WANDER_JITTER = 8000;
+/**
+ * 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 +171,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
@@ -103,6 +217,46 @@ 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;
@@ -115,6 +269,23 @@ export declare const DEFAULT_PALETTE: ConstellationPalette;
  * `:root`/`.dark` color arms AND the per-mode alpha defaults in one read.
  */
 export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPalette;
+/**
+ * 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;
+    };
+};
 /**
  * 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 +295,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,8 +317,53 @@ 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.
+ *
+ * `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 stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number): void;
+export declare function stepField(field: ConstellationField, k: number, speed: number, pointer: ConstellationPointer | null, dt?: number, now?: number, rng?: () => number): void;
+/**
+ * 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;
+/**
+ * Warp spring tuning DEFAULTS — gentle critically-damped (no overshoot on a focal
+ * mark). The `--constellation-warp-response`/`-zeta` tokens override these on mount
+ * via `field.warpCfg` (AY.W-CON2); these stay the byte-identical fallback.
+ *
+ * `WARP_RESPONSE` is the keyframes.js `(response, dampingFraction)` model's ANGULAR
+ * PERIOD (the SwiftUI `.spring(response:)` axis), `ω₀ = 2π/response` — 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); the shipped 0.55 settles
+ * at ≈0.51s. This is the AY.W-CON2 ω-reconcile: the engine keeps the keyframes.js
+ * `ω₀ = 2π/response` convention (the shared house model — `regen-spring-tokens.mjs`,
+ * `keyframes.d.ts:860-882`) and mints NO second ω formula; the SEMANTIC honesty
+ * (period, not settle) lives in this doc + the token comment + the settle-time unit
+ * assertion, so a consumer setting the token gets the documented behaviour at ANY ζ.
+ */
+export declare const WARP_RESPONSE = 0.55;
+export declare const WARP_ZETA = 1;
+/**
+ * Gravity-well tuning DEFAULTS (AY.W-CON2). The `--constellation-well-*` tokens
+ * override these on mount via `field.well.cfg`; these stay the fallback. SET by the
+ * §6 egg-live π readback (the field-perturbs-then-cools capture is the binding
+ * truth) — a moderate gain over a generous reach, a brisk ramp, a tight no-slingshot
+ * speed cap, and the singularity-soften floor.
+ */
+export declare const DEFAULT_WELL_CONFIG: ConstellationWellConfig;
 /**
  * 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).
@@ -154,8 +383,12 @@ export declare function nearestNode(field: ConstellationField, px: number, py: n
  *
  *   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
+ * 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;
@@ -180,6 +413,25 @@ export declare function setWarpTarget(field: ConstellationField, idx: number): v
  * `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;
 /** 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. */

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

@@ -1,3 +1,3 @@
 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, stepWell, refitField, readPalette, drawEdges, drawNodes, drawPointerWeb, drawRipples, nearestNode, readInteractionConfig, warpStep, warpTo, setWarpTarget, warpSettled, pickWanderTarget, BASE_WIDTH, DEFAULT_PALETTE, DEFAULT_WELL_CONFIG, DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, WARP_RESPONSE, WARP_ZETA, } from "./constellationField";
+export type { ConstellationNode, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationProps, } from "./constellationField";

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

@@ -12,9 +12,10 @@ import { type HTMLAttributes } from "vue";
  *
  * 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.
+ * disco-grain + specular-highlight recipe at `utilities.css`; the
+ * sparkle-sweep star was excised at D6 — the gold identity now rides the
+ * `--gold-rim` gilt edge). `dock.css` retains the dock-local
+ * phase-tinting + structural shell on top of the canonical recipe.
  */
 type __VLS_Props = {
     as?: string;

package/dist/components/custom/expandable-container/ExpandableContainer.vue.d.ts

@@ -6,6 +6,20 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     expandLabel?: string;
     /** Accessible name for the collapse (exit fullscreen) button. */
     collapseLabel?: string;
+    /**
+     * Opt into the `gl-expand` plate → fullscreen MORPH (D6.c M7). When set,
+     * the inline plate and the teleported fullscreen surface share ONE
+     * `view-transition-name` (this prop, suffixed by an app-unique `useId()`
+     * so two ExpandableContainers on a page never collide their groups — the
+     * proof:vt-names mandate), and the open/close toggle is wrapped in
+     * `startViewTransition` so the plate's rect MORPHS to the fullscreen rect
+     * (and back) instead of jump-cutting. A passed string namespaces the pair
+     * (e.g. `"chart"`); pass an empty string for a bare `useId()` name.
+     * Omitted (default) ⇒ NO view-transition-name, the legacy instant toggle —
+     * byte-identical to the pre-M7 behaviour. PRM + unsupported engines take
+     * `startViewTransition`'s instant fallback (the open/close still runs).
+     */
+    viewTransitionName?: string;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -21,6 +35,20 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     expandLabel?: string;
     /** Accessible name for the collapse (exit fullscreen) button. */
     collapseLabel?: string;
+    /**
+     * Opt into the `gl-expand` plate → fullscreen MORPH (D6.c M7). When set,
+     * the inline plate and the teleported fullscreen surface share ONE
+     * `view-transition-name` (this prop, suffixed by an app-unique `useId()`
+     * so two ExpandableContainers on a page never collide their groups — the
+     * proof:vt-names mandate), and the open/close toggle is wrapped in
+     * `startViewTransition` so the plate's rect MORPHS to the fullscreen rect
+     * (and back) instead of jump-cutting. A passed string namespaces the pair
+     * (e.g. `"chart"`); pass an empty string for a bare `useId()` name.
+     * Omitted (default) ⇒ NO view-transition-name, the legacy instant toggle —
+     * byte-identical to the pre-M7 behaviour. PRM + unsupported engines take
+     * `startViewTransition`'s instant fallback (the open/close still runs).
+     */
+    viewTransitionName?: string;
 } & {
     /**
      * Two-way `open` model so consumers can drive fullscreen externally
@@ -31,6 +59,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
 }> & Readonly<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
+    viewTransitionName: string;
     buttonPosition: "left" | "right";
     expandLabel: string;
     collapseLabel: string;

package/dist/components/custom/fourier-field/FourierField.vue.d.ts

@@ -32,6 +32,12 @@ type __VLS_Props = {
     seed?: string;
     /** When true, paint ONE static deterministic best-frame and never animate (the capture/export lever). Default false. */
     freeze?: boolean;
+    /** Outer loudness envelope (the Aurora `opacityCeiling` shape). Scales the
+     *  resolved `peakAlpha`/`headGlowAlpha` at the PAINT layer (a per-LAYER
+     *  multiply, not a uniform CSS opacity). Default 1 (the bundle's resting
+     *  loudness); clamped [0, 2] — the field's ~2 upper bound lets a hero push
+     *  brighter than the recessed default without runaway. */
+    intensity?: number;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/components/custom/fourier-field/index.d.ts

@@ -1,2 +1,26 @@
+import type { ColorResolver } from "../../../composables/color";
 export { default as FourierField } from "./FourierField.vue";
-export { comp, evalFourier, positionsAt, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";
+export { comp, positionsAt, makeEllipticSpectrum, type BasisComponent, type EllipticSpectrumOptions, } from "./math";
+/** The configuration-BUNDLE axis — `hero` (epicycles on, fewer harmonics) vs
+ *  `final` (epicycles off, denser). Not a recolour of one curve; one engine,
+ *  two presets. */
+export type FourierFieldVariant = "hero" | "final";
+/** The props a consumer forwards when wrapping `<FourierField>` (the seeded
+ *  inverse-DFT epicycle background; ships via `/fourier-field`). Mirrors the
+ *  component's inline `defineProps` shape (an SFC cannot export its inline
+ *  props type). */
+export interface FourierFieldProps {
+    /** Configuration bundle. Default `hero`. */
+    variant?: FourierFieldVariant;
+    /** Base CSS color (a `var()`/`light-dark()` token resolves against the host). */
+    color: string;
+    /** REQUIRED color seam — resolves a concrete color to a gamma-sRGB [r,g,b] triple in [0,1]. */
+    colorResolver: ColorResolver;
+    /** Extra seed mixed into the spectrum PRNG for a unique-but-reproducible curve. Default "". */
+    seed?: string;
+    /** Paint ONE static deterministic best-frame and never animate (the capture lever). Default false. */
+    freeze?: boolean;
+    /** Outer loudness envelope (the Aurora `opacityCeiling` shape). Scales the
+     *  resolved `peakAlpha`/`headGlowAlpha` at the paint layer. Default 1; clamped [0, 2]. */
+    intensity?: number;
+}

package/dist/components/custom/fourier-field/math.d.ts

@@ -15,17 +15,12 @@ export interface BasisComponent {
  * coefficient `(re, im)`, deriving the polar `amplitude`/`phase`.
  */
 export declare function comp(index: number, re: number, im: number): BasisComponent;
-/**
- * Sum `c_k * exp(2*pi*i*k*t)` — the curve point at parameter `t`. `maxTerms`
- * truncates the series (the partial-sum read). Returns the complex value as
- * `[re, im]` (the curve's `[x, y]` before view-fit).
- */
-export declare function evalFourier(components: BasisComponent[], t: number, maxTerms?: number): [number, number];
 /**
  * The epicycle chain at parameter `t`: the running tip of each phasor stacked on
  * the last, starting at the origin. `positions[0]` is `[0, 0]`; the final entry
- * is the curve point ({@link evalFourier} at the same `t`). `maxCircles`
- * truncates the chain (draw fewer arms than the spectrum carries).
+ * is the curve point — the inverse-DFT sum `Σ c_k * exp(2*pi*i*k*t)` at the same
+ * `t`. `maxCircles` truncates the chain (draw fewer arms than the spectrum
+ * carries).
  */
 export declare function positionsAt(components: BasisComponent[], t: number, maxCircles?: number): [number, number][];
 /** Tuning for {@link makeEllipticSpectrum}. */

package/dist/components/custom/goo-blob/GooBlob.vue.d.ts

@@ -1,4 +1,3 @@
-import type { ColorResolver } from "../../../composables/color";
 import type { BlobMood, BlobConfig } from "./types";
 /**
  * GooBlob — a gooey metaball creature on a WebGL2 canvas.
@@ -8,23 +7,22 @@ import type { BlobMood, BlobConfig } from "./types";
  * satellite system drive the motion. The renderer composes the `useWebGLCanvas`
  * substrate — it never bootstraps its own context.
  *
- * Color is resolved through an INJECTED `colorResolver` seam (DEC-AT-2): the blob
- * paints the GAMMA-sRGB triple it returns. The prop is REQUIRED — pass
- * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` (or your own) so a
- * `lab()`/`oklch()`/`hsl()`/hex string resolves correctly. A missing resolver
- * throws (the loud failure, not a silent gray).
+ * Color is resolved INTERNALLY through the `/color` leaf (`cssToOklch →
+ * oklchToGammaRgb`): the blob paints the GAMMA-sRGB triple of the `color` prop. A
+ * `lab()`/`oklch()`/`hsl()`/hex string resolves correctly; a `var(--token)` is
+ * un-wrapped to a concrete string by the SFC's `resolveTokenColor` leaf BEFORE the
+ * renderer sees it (the DOM-free renderer contract).
  *
- * Config is resolved with the SAME loud discipline as the resolver: either
+ * Config is resolved with a loud discipline: either
  * `provide(BLOB_CONFIG_KEY, cfg)` from an ancestor OR pass an explicit `config`
  * prop. A mount with NEITHER throws — there is no silent reactive-defaults
  * synthesis. A consumer that genuinely wants the stock tuning passes
  * `BLOB_CONFIG_DEFAULTS` explicitly.
  */
 type __VLS_Props = {
-    /** Base CSS color string (any form the `colorResolver` understands). */
+    /** Base CSS color string (a `var()`/`oklch()`/`lab()`/`hsl()`/hex form; resolved
+     *  internally through the `/color` leaf to a gamma-sRGB triple). */
     color: string;
-    /** REQUIRED color seam — resolves `color` to a gamma-sRGB [r,g,b] triple in [0,1]. */
-    colorResolver: ColorResolver;
     /**
      * REQUIRED unless an ancestor `provide(BLOB_CONFIG_KEY, …)` supplies it.
      * The metaball tuning. Pass `BLOB_CONFIG_DEFAULTS` for the stock look.

package/dist/components/custom/goo-blob/composables/useMetaballRenderer.d.ts

@@ -1,5 +1,4 @@
 import { type Ref } from "vue";
-import type { ColorResolver } from "../../../../composables/color";
 import type { BlobConfig } from "../types";
 import type { BlobMoodSystem } from "./useBlobMood";
 import type { BlobPointer } from "./useBlobPointer";
@@ -24,23 +23,13 @@ export interface UseMetaballRendererOptions {
     pointer: BlobPointer;
     satellites: BlobSatelliteSystem;
     config: BlobConfig;
-    /**
-     * The injected color seam (DEC-AT-2). Resolves a CONCRETE CSS color string to a
-     * GAMMA-sRGB triple in [0,1] fed straight into the shader's base-color uniform —
-     * the faithful AU.W7 lift paints gamma. REQUIRED: a no-resolver mount throws (the
-     * loud failure, not a silent gray) instructing the consumer to pass
-     * `defaultBlobColorResolver` from `@mkbabb/glass-ui/color` (or their own). The
-     * renderer is DOM-FREE: it never un-wraps a `var(--token)` — the SFC's
-     * `resolveTokenColor` leaf does that BEFORE handing strings here (inv-K-3 seam).
-     */
-    colorResolver: ColorResolver;
 }
 /**
  * The GooBlob WebGL renderer — composes the `useWebGLCanvas` substrate (AU.W6).
  *
  * This module owns ONLY the metaball-specific concerns: compiling the shader,
  * building the quad + uniform cache, and uploading the per-frame uniforms derived
- * from the mood / pointer / satellite systems and the injected color resolver. The
+ * from the mood / pointer / satellite systems and the resolved base color. The
  * generic WebGL2 lifecycle — context creation, the suspend/resume model, the
  * demand-driven rAF loop, the tab-visibility owner, the ResizeObserver, and the
  * webglcontextlost/restored robustness — lives in the substrate; this renderer
@@ -48,8 +37,11 @@ export interface UseMetaballRendererOptions {
  * `setup`/`frame`/`shouldContinue`/`resize`/`teardown` callbacks. It does NOT call
  * `getContext("webgl2")` itself (the single-bootstrap contract).
  *
- * Colors arrive ALREADY resolved to a gamma-sRGB triple via the injected
- * `colorResolver`; the value.js 1×1-canvas DOM probe is gone (the seam replaces it).
+ * Color is resolved INTERNALLY through the `/color` leaf (`cssToOklch →
+ * oklchToGammaRgb`) — the GAMMA-sRGB triple fed straight into the base-color uniform
+ * (the faithful AU.W7 lift paints gamma). The renderer is DOM-FREE: it never un-wraps
+ * a `var(--token)` — the SFC's `resolveTokenColor` leaf does that BEFORE handing
+ * concrete strings here (inv-K-3 seam); the value.js 1×1-canvas DOM probe is gone.
  */
 export declare function useMetaballRenderer(options: UseMetaballRendererOptions): {
     pause: () => void;

package/dist/components/custom/goo-blob/index.d.ts

@@ -1,5 +1,5 @@
 export { default as GooBlob } from "./GooBlob.vue";
-export type { BlobMood, BlobMerge, BlobQuality, MoodParams, MetaballSource, BlobConfig, SatellitePhase, SatelliteInternal, } from "./types";
+export type { BlobMood, BlobMerge, BlobQuality, MoodParams, MetaballSource, BlobConfig, BlobGeometry, BlobSatelliteTiming, BlobMembrane, BlobColor, BlobSurface, BlobInteraction, SatellitePhase, SatelliteInternal, } from "./types";
 export { BLOB_CONFIG_DEFAULTS, BLOB_CONFIG_KEY } from "./types";
 export { useBlobMood, type BlobMoodSystem } from "./composables/useBlobMood";
 export { useBlobPointer, type BlobPointer } from "./composables/useBlobPointer";