@mkbabb/glass-ui 4.2.0 → 6.0.0

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

@@ -1,407 +0,0 @@
-export interface ConstellationNode {
-    x: number;
-    y: number;
-    vx: number;
-    vy: number;
-    r: number;
-    dim: boolean;
-    /**
-     * BC.W-VIZ-CONSTELLATION — the seeded parallax DEPTH (`z ∈ [0,1]`, §6). The pointer
-     * offsets the node's SCREEN position by `parallax · z · (pointer − center)` so the flat
-     * lattice reads as having depth (the Awwwards "living network" register). Seeded in
-     * `seedField`; perturbs the GPU node-position write only (never a layout property). A
-     * field literal that omits it is treated as `z = 0.5` (the mid-plane, no parallax bias).
-     */
-    z?: number;
-}
-/**
- * BC.W-VIZ-CONSTELLATION — ONE edge of the proximity graph, the row the CPU all-pairs scan
- * (`buildEdges`) writes each frame into the instanced-lines storage buffer. `a`/`b` are the
- * two endpoint positions in canvas-local CSS px; `alpha` is the distance-falloff weight
- * (`1 − d²/reach²`, the `drawEdges` math) the segment-quad fragment multiplies; `accent`
- * (0/1) flags the accented-node tether (the flagged-node edge tint); `focus` (0/1) flags
- * the pointer-web tether (the cursor's incident edges). The WGSL/GLSL render transcribes
- * the SHAPE, never re-derives the scan (the ONE math source stays JS).
- */
-export interface ConstellationEdge {
-    ax: number;
-    ay: number;
-    bx: number;
-    by: number;
-    /** The distance-falloff weight `1 − d²/reach²` (the drawEdges math). */
-    alpha: number;
-    /** 1 when the edge is incident on the accented node (the tether tint), else 0. */
-    accent: number;
-    /** 1 when the edge is a pointer-web tether (the cursor's incident edge), else 0. */
-    focus: number;
-}
-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;
-    /**
-     * BC.W-VIZ-CONSTELLATION (§6) — the pointer-PARALLAX depth. Each node carries a seeded
-     * depth `z ∈ [0,1]`; the pointer offsets node screen positions by `parallax · z ·
-     * (pointer − center)` so the flat lattice reads as having depth (the Awwwards "living
-     * network" register). Additive default-on at a SUB-PERCEPTUAL 0.08 (a hair of depth, not
-     * a behavior break); 0 = the flat lattice. GPU-only (perturbs the node-position write,
-     * never a layout property). Frozen under reduced-motion / `freeze`.
-     */
-    parallax?: 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

@@ -1,6 +0,0 @@
-export { default as Constellation } from "./Constellation.vue";
-export { seedField, stepField, refitField, buildEdges, appendPointerWeb, parallaxNodePos, BASE_WIDTH, } from "./constellationField";
-export { DEFAULT_K_FLOOR, DEFAULT_PARALLAX, MAX_NODES, MAX_DEGREE, E_MAX, } 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, fireBurst, BURST_FIRE_THRESHOLD, } from "./constellationInteraction";
-export { kVisOf, readPalette, parseColorRGBA, DEFAULT_PALETTE, } from "./constellationRender";
-export type { ConstellationNode, ConstellationEdge, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationTypes";

package/dist/components/custom/constellation/shaders/constellation-lines.glsl.d.ts

@@ -1,2 +0,0 @@
-export declare const CONSTELLATION_LINES_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n// per-instance edge rows \u2014 vertexAttribDivisor(1).\nlayout(location = 0) in vec4 aAB;  // (a.x, a.y, b.x, b.y)\nlayout(location = 1) in vec4 aW;   // (alpha, accent, focus, _pad)\n\nuniform vec2 uResolution;\nuniform float uDpr;\nuniform float uKVis;\nuniform float uLineWidth;\n\nout float vLineCoord;\nout float vAlpha;\nout float vAccent;\nout float vFocus;\n\nvoid main() {\n  vec2 quad[6] = vec2[6](\n    vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),\n    vec2(-1.0,  1.0), vec2(1.0, -1.0), vec2(1.0,  1.0)\n  );\n  vec2 alongQuad = quad[gl_VertexID];\n\n  vec2 a = aAB.xy;\n  vec2 b = aAB.zw;\n  vec2 dir = normalize(b - a + vec2(1e-6, 0.0));\n  vec2 ortho = vec2(-dir.y, dir.x);\n  // accent tether reads a touch heavier (1.1\u00D7).\n  float halfWPx = uLineWidth * uKVis * uDpr * 0.5 * mix(1.0, 1.1, aW.y);\n  vec2 p = mix(a, b, alongQuad.x * 0.5 + 0.5) + ortho * alongQuad.y * halfWPx;\n\n  vec2 ndc = vec2(\n    p.x / max(uResolution.x, 1.0) * 2.0 - 1.0,\n    1.0 - p.y / max(uResolution.y, 1.0) * 2.0\n  );\n\n  gl_Position = vec4(ndc, 0.0, 1.0);\n  vLineCoord = alongQuad.y;\n  vAlpha = aW.x;\n  vAccent = aW.y;\n  vFocus = aW.z;\n}\n";
-export declare const CONSTELLATION_LINES_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\nuniform vec4 uLine;     // premultiplied-ready rgba\nuniform vec4 uAccent;\nuniform float uAlphaGlobal;       // --constellation-alpha\nuniform float uOpacityCeiling;\nuniform float uEdgeAlpha;\nuniform float uEdgeFocusAlpha;\nuniform float uEdgeAccentAlpha;\nuniform float uEdgeFloor;\n\nin float vLineCoord;\nin float vAlpha;\nin float vAccent;\nin float vFocus;\nout vec4 fragColor;\n\nvoid main() {\n  float aaBand = 0.6;\n  float cross = 1.0 - smoothstep(1.0 - aaBand, 1.0, abs(vLineCoord));\n  if (cross <= 0.0) { discard; }\n\n  float dim = uAlphaGlobal * uOpacityCeiling;\n  vec4 col = uLine;\n  float weight = (uEdgeAlpha * vAlpha + uEdgeFloor) * dim;\n  if (vAccent > 0.5) {\n    col = uAccent;\n    weight = uEdgeAccentAlpha * vAlpha * dim;\n  } else if (vFocus > 0.5) {\n    col = uLine;\n    weight = uEdgeFocusAlpha * uAlphaGlobal * uOpacityCeiling * vAlpha;\n  }\n\n  float a = col.a * weight * cross;\n  if (a <= 0.0) { discard; }\n  fragColor = vec4(col.rgb * a, a);\n}\n";

package/dist/components/custom/constellation/shaders/constellation-lines.wgsl.d.ts

@@ -1 +0,0 @@
-export declare const CONSTELLATION_LINES_WGSL = "\nstruct Edge {\n  // vec4 0: (a.x, a.y, b.x, b.y)\n  ab: vec4<f32>,\n  // vec4 1: (alpha, accent, focus, _pad)\n  w: vec4<f32>,\n};\n\nstruct ConstellationUniforms {\n  // u0: (resolution.x, resolution.y, dpr, kVis)\n  u0: vec4<f32>,\n  // u1: (time, lineWidth, opacityCeiling, alpha)\n  u1: vec4<f32>,\n  // uEdge: (edgeAlpha, edgeFocusAlpha, edgeAccentAlpha, edgeFloor)\n  uEdge: vec4<f32>,\n  uNode: vec4<f32>,\n  uNodeDim: vec4<f32>,\n  uLine: vec4<f32>,\n  uAccent: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConstellationUniforms;\n@group(0) @binding(1) var<storage, read> edges: array<Edge>;\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) lineCoord: f32,  // [-1,1] cross-line \u2192 fragment AA\n  @location(1) alpha: f32,      // distance-falloff weight\n  @location(2) accent: f32,     // accent flag (the flagged-node tether tint)\n  @location(3) focus: f32,      // focus flag (the pointer-web tether)\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vIdx: u32,\n  @builtin(instance_index) iIdx: u32,\n) -> VSOut {\n  var QUAD = array<vec2<f32>, 6>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),\n    vec2<f32>(-1.0,  1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0,  1.0),\n  );\n  let alongQuad = QUAD[vIdx];\n\n  let e = edges[iIdx];\n  let a = e.ab.xy;\n  let b = e.ab.zw;\n  let res = u.u0.xy;\n  let dpr = u.u0.z;\n  let kVis = u.u0.w;\n  let lineW = u.u1.y;\n\n  // Screen-space segment direction + orthogonal (the half-width offset axis).\n  let dir = normalize(b - a + vec2<f32>(1e-6, 0.0));\n  let ortho = vec2<f32>(-dir.y, dir.x);\n  // Lerp along the segment (alongQuad.x \u2208 [-1,1] \u2192 [0,1]); offset by ortho \u00D7 half-width.\n  // The accent tether reads a touch heavier (1.1\u00D7 the neutral width).\n  let halfWPx = lineW * kVis * dpr * 0.5 * mix(1.0, 1.1, e.w.y);\n  let p = mix(a, b, alongQuad.x * 0.5 + 0.5) + ortho * (alongQuad.y) * halfWPx;\n\n  // px (y-down) \u2192 clip (y-up).\n  let ndc = vec2<f32>(\n    p.x / max(res.x, 1.0) * 2.0 - 1.0,\n    1.0 - p.y / max(res.y, 1.0) * 2.0,\n  );\n\n  var out: VSOut;\n  out.pos = vec4<f32>(ndc, 0.0, 1.0);\n  out.lineCoord = alongQuad.y;\n  out.alpha = e.w.x;\n  out.accent = e.w.y;\n  out.focus = e.w.z;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // Cross-line AA \u2014 a smoothstep on |lineCoord| so the hairline edge is crisp.\n  let aaBand = 0.6;\n  let cross = 1.0 - smoothstep(1.0 - aaBand, 1.0, abs(in.lineCoord));\n  if (cross <= 0.0) { discard; }\n\n  let dim = u.u1.w * u.u1.z; // alpha \u00B7 opacityCeiling\n  // Resolve the edge class: accent tether \u00B7 focus pointer-web \u00B7 neutral ambient.\n  var col = u.uLine;\n  var weight = (u.uEdge.x * in.alpha + u.uEdge.w) * dim; // edgeAlpha\u00B7falloff + edgeFloor\n  if (in.accent > 0.5) {\n    col = u.uAccent;\n    weight = u.uEdge.z * in.alpha * dim; // edgeAccentAlpha\n  } else if (in.focus > 0.5) {\n    col = u.uLine;\n    weight = u.uEdge.y * u.u1.w * u.u1.z * in.alpha; // edgeFocusAlpha \u00B7 alpha \u00B7 ceiling\n  }\n\n  let a = col.a * weight * cross;\n  if (a <= 0.0) { discard; }\n  return vec4<f32>(col.rgb * a, a);\n}\n";

package/dist/components/custom/constellation/shaders/constellation-points.glsl.d.ts

@@ -1,2 +0,0 @@
-export declare const CONSTELLATION_POINTS_VERT_GLSL = "#version 300 es\nprecision highp float;\n\n// per-instance node row (x, y, radius, dim) \u2014 vertexAttribDivisor(1).\nlayout(location = 0) in vec4 aNode;\n\nuniform vec2 uResolution;\nuniform float uDpr;\nuniform float uKVis;\n\nout vec2 vUv;   // [-1,1] billboard-local \u2192 fragment SDF coord\nout float vDim;\n\nvoid main() {\n  // Two-triangle quad corners (the SAME order as the WGSL QUAD).\n  vec2 quad[6] = vec2[6](\n    vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0),\n    vec2(-1.0,  1.0), vec2(1.0, -1.0), vec2(1.0,  1.0)\n  );\n  vec2 corner = quad[gl_VertexID];\n\n  vec2 centerPx = aNode.xy;\n  // px (y-down) \u2192 clip (y-up).\n  vec2 centerNdc = vec2(\n    centerPx.x / max(uResolution.x, 1.0) * 2.0 - 1.0,\n    1.0 - centerPx.y / max(uResolution.y, 1.0) * 2.0\n  );\n  // half-extent: radius\u00B7kVis CSS px \u2192 backing-store px (\u00B7dpr) \u2192 NDC half (\u00B72/res).\n  // (half is a GLSL reserved word \u2014 name it halfExt.)\n  float radPx = aNode.z * uKVis * uDpr;\n  vec2 halfExt = vec2(\n    radPx / max(uResolution.x, 1.0) * 2.0,\n    radPx / max(uResolution.y, 1.0) * 2.0\n  );\n\n  gl_Position = vec4(centerNdc + corner * halfExt, 0.0, 1.0);\n  vUv = corner;\n  vDim = aNode.w;\n}\n";
-export declare const CONSTELLATION_POINTS_FRAG_GLSL = "#version 300 es\nprecision highp float;\n\nuniform vec4 uNode;      // premultiplied-ready rgba\nuniform vec4 uNodeDim;\nuniform float uOpacityCeiling;\n\nin vec2 vUv;\nin float vDim;\nout vec4 fragColor;\n\nvoid main() {\n  // SDF: distance to the unit-circle edge (0 at the rim, neg inside).\n  float d = length(vUv) - 1.0;\n  // fwidth(d) \u2014 the pixel footprint, the resolution-independent AA width.\n  float aa = max(fwidth(d), 1e-4);\n  float coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage <= 0.0) { discard; }\n  vec4 col = mix(uNode, uNodeDim, vDim);\n  float a = col.a * coverage * uOpacityCeiling;\n  fragColor = vec4(col.rgb * a, a); // premultiplied\n}\n";

package/dist/components/custom/constellation/shaders/constellation-points.wgsl.d.ts

@@ -1 +0,0 @@
-export declare const CONSTELLATION_POINTS_WGSL = "\n// \u2500\u2500 Node storage row + uniforms (the typed-struct source-of-truth \u2014 uniformBridgeWGPU.ts) \u2500\u2500\nstruct Node {\n  // (pos.x, pos.y, radius, dim)\n  data: vec4<f32>,\n};\n\nstruct ConstellationUniforms {\n  // u0: (resolution.x, resolution.y, dpr, kVis)\n  u0: vec4<f32>,\n  // u1: (time, lineWidth, opacityCeiling, alpha)\n  u1: vec4<f32>,\n  // uEdge: (edgeAlpha, edgeFocusAlpha, edgeAccentAlpha, edgeFloor)\n  uEdge: vec4<f32>,\n  // colours (premultiplied-ready rgba)\n  uNode: vec4<f32>,\n  uNodeDim: vec4<f32>,\n  uLine: vec4<f32>,\n  uAccent: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u: ConstellationUniforms;\n@group(0) @binding(1) var<storage, read> nodes: array<Node>;\n\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,   // [-1,1] billboard-local \u2192 fragment SDF coord\n  @location(1) dim: f32,        // 0 = full node, 1 = dim node\n};\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vIdx: u32,\n  @builtin(instance_index) iIdx: u32,\n) -> VSOut {\n  // Two-triangle quad corners in billboard-local space.\n  var QUAD = array<vec2<f32>, 6>(\n    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),\n    vec2<f32>(-1.0,  1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0,  1.0),\n  );\n  let corner = QUAD[vIdx];\n\n  let node = nodes[iIdx].data;\n  let res = u.u0.xy;\n  let dpr = u.u0.z;\n  let kVis = u.u0.w;\n\n  // center: node px \u2192 clip space (y-flip \u2014 px is y-down, clip is y-up).\n  let centerPx = node.xy;\n  let centerNdc = vec2<f32>(\n    centerPx.x / max(res.x, 1.0) * 2.0 - 1.0,\n    1.0 - centerPx.y / max(res.y, 1.0) * 2.0,\n  );\n  // half-extent: radius\u00B7kVis in CSS px \u2192 backing-store px (\u00B7dpr) \u2192 NDC half (\u00B72/res).\n  // (the DPR-aware crispness leg \u2014 the disc samples at device resolution.)\n  // (half is a WGSL reserved keyword \u2014 name it halfExt.)\n  let radPx = node.z * kVis * dpr;\n  let halfExt = vec2<f32>(radPx / max(res.x, 1.0) * 2.0, radPx / max(res.y, 1.0) * 2.0);\n\n  var out: VSOut;\n  out.pos = vec4<f32>(centerNdc + corner * halfExt, 0.0, 1.0);\n  out.uv = corner;\n  out.dim = node.w;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  // SDF: distance to the unit-circle edge in billboard-local space (0 at the rim, neg inside).\n  let d = length(in.uv) - 1.0;\n  // fwidth(d) = |dpdx(d)| + |dpdy(d)| \u2014 the pixel footprint of the SDF, the resolution-\n  // independent AA width (~1px band at ANY DPR/zoom/size).\n  let aa = max(fwidth(d), 1e-4);\n  let coverage = 1.0 - smoothstep(-aa, aa, d);\n  if (coverage <= 0.0) { discard; }\n  let col = mix(u.uNode, u.uNodeDim, in.dim);\n  let a = col.a * coverage * u.u1.z;  // \u00B7opacityCeiling\n  // premultiplied-alpha output.\n  return vec4<f32>(col.rgb * a, a);\n}\n";

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

@@ -1,34 +0,0 @@
-type DarkModeToggleSize = "sm" | "md" | "lg" | "control" | "dock";
-type __VLS_Props = {
-    passive?: boolean;
-    /**
-     * Button size. `sm` = 28px, `md` = 36px (default), `lg` = 44px.
-     * `control` follows generic control CSS variables; `dock` follows
-     * GlassDock sizing variables.
-     */
-    size?: DarkModeToggleSize;
-    /**
-     * When true, CSS transitions on `<html>` and all descendants are
-     * temporarily suppressed during dark mode toggle to prevent jank.
-     * @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/deck/composables/useDeckSpring.d.ts

@@ -1,22 +0,0 @@
-/** The deck spring preset, re-exported from the colocated constants for consumers
-    sampling the same `(response, ζ)` row. */
-export { DECK_SPRING } from "../constants";
-/**
- * Count-up easing. Defaults to a monotone cubic-out so a still render (or a failed
- * engine chunk) is always faithful; replaced in-place with the engine's
- * `springTimingFunction(.smooth)` once keyframes.js resolves. Callers read
- * `deckEase.fn` each frame, so the swap is picked up live with no re-wiring.
- */
-export declare const deckEase: {
-    fn: (t: number) => number;
-};
-/**
- * Swap `deckEase.fn` to the engine's matching JS easing once keyframes.js resolves.
- * Idempotent. No-op off-DOM (SSR / export tooling) and a silent no-op if the engine
- * chunk fails — the count-up keeps its monotone cubic fallback.
- *
- * The slide transition needs no JS write: `--spring-deck: var(--spring-smooth)`
- * (glass-ui's `.smooth` `linear()` token) resolves the declarative half at first
- * paint.
- */
-export declare function installDeckSpring(): void;

package/dist/components/custom/deck/constants.d.ts

@@ -1,14 +0,0 @@
-/** SwiftUI `.smooth` — the deck's slide-transition + count-up curve: a calm settle
-    with a barely-there micro-overshoot, the right cadence for a content deck (the
-    page change reads as a settle, not a bounce). It is the SAME family the
-    `--spring-smooth` token derives from (`springLinearStops()` output), so the deck
-    inherits the constellation's iOS curve instead of forking a third easing
-    vocabulary — `--spring-deck: var(--spring-smooth)`. */
-export declare const DECK_SPRING: {
-    readonly response: 0.5;
-    readonly dampingFraction: 0.85;
-};
-/** The focused-control selector the keyboard handler tests: when a control (button
-    / link / field) is focused, Space + digit jumps reach that control's native
-    activation instead of being stolen for navigation (the C6 correctness fix). */
-export declare const CONTROL_SELECTOR = "button, a, input, textarea, select, [role=button]";

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

@@ -1,8 +0,0 @@
-export { useDeck } from "./composables/useDeck";
-export type { DeckCore, UseDeckOptions } from "./composables/useDeck";
-export { useDeckKeyboard, handleDeckKey } from "./composables/useDeckKeyboard";
-export type { DeckMoves, DeckKeyOptions, UseDeckKeyboardOptions, } from "./composables/useDeckKeyboard";
-export { installDeckSpring, deckEase, DECK_SPRING, } from "./composables/useDeckSpring";
-export { default as DeckPager } from "./DeckPager.vue";
-export { CONTROL_SELECTOR } from "./constants";
-export type { PagerWindow } from "../pager-dots/pagerWindow";

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

@@ -1,46 +0,0 @@
-/**
- * <DockBackgroundToggle> — the WCAG 2.2.2 (Pause, Stop, Hide), Level A pause/play
- * control for a continuously-running AV background (Aurora / GooBlob).
- *
- * WCAG 2.2.2 is OBLIGATORY for any auto-starting, >5s, non-essential motion and
- * the control must be available to ALL users — it is NOT gated behind
- * `prefers-reduced-motion` (which the substrate handles separately via the G1
- * freeze). This is the USER-driven stop control any user can reach.
- *
- * Binding contract (KISS — it binds an EXISTING renderer seam, adds no parallel
- * pause path): the consumer holds the paused state and wires it to the renderer's
- * `pause()`/`resume()`. The toggle is a thin `v-model:paused` control over a
- * `<DockIconButton>` host (the dock is the natural home for a background control):
- *
- * ```vue
- * <script setup>
- * const blob = ref<InstanceType<typeof GooBlob>>();
- * const paused = ref(false);
- * watch(paused, (p) => (p ? blob.value?.pause() : blob.value?.resume()));
- * <\/script>
- * <DockBackgroundToggle v-model:paused="paused" />
- * ```
- *
- * The control reflects state via `aria-pressed` (pressed ⇒ paused) and swaps the
- * Pause↔Play glyph + the accessible label, so a screen reader announces both the
- * action and the current state.
- */
-type __VLS_Props = {
-    /** Whether the background is currently paused (the controlled state). */
-    paused?: boolean;
-    /** Accessible label when RUNNING (the action: pause). */
-    pauseLabel?: string;
-    /** Accessible label when PAUSED (the action: play/resume). */
-    playLabel?: string;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:paused": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:paused"?: ((value: boolean) => any) | undefined;
-}>, {
-    paused: boolean;
-    pauseLabel: string;
-    playLabel: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

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

@@ -1,30 +0,0 @@
-import { type ButtonHTMLAttributes, type HTMLAttributes } from "vue";
-import { type DropdownMenuTriggerProps } from "reka-ui";
-/**
- * <DockDropdownTrigger> — variable-width DropdownMenu trigger for use inside GlassDock.
- *
- * Emits the SHARED `.dock-trigger` recipe (BD.W-DOCK-CORE A8 — the unified dock
- * overlay-trigger family: select/dropdown/popover are byte-identical geometry + style +
- * baseline alignment). Interactive styling is owned by dock-controls/triggers.css; the
- * hover-scale is OFF across the family so portaled content anchors smoothly.
- *
- * Consumers provide the button content (icon + text + optional chevron)
- * via the default slot.
- */
-type __VLS_Props = DropdownMenuTriggerProps & {
-    type?: ButtonHTMLAttributes["type"];
-    class?: HTMLAttributes["class"];
-};
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    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<{}>, {}, {}, {}, {}, 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;
-    };
-};