@mkbabb/glass-ui 4.2.0 → 6.0.0

package/dist/components/custom/constellation/composables/useConstellation.d.ts

@@ -1,19 +0,0 @@
-import { type Ref } from "vue";
-import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
-import { type ConstellationField, type ConstellationProps } from "../constellationField";
-/** The imperative seam the SFC re-exposes via `defineExpose`. */
-export interface ConstellationExpose {
-    field: ConstellationField;
-    isFrozen: Ref<boolean>;
-    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 instanced twin). */
-    backend: () => GpuBackend;
-    warpTo(a: {
-        x: number;
-        y: number;
-    } | number, b?: number): number;
-    holdWellAt(x: number, y: number): boolean;
-    releaseWell(): void;
-    warpSettled(): boolean;
-    pinNode(idx: number): void;
-}
-export declare function useConstellation(props: ConstellationProps, hostRef: Ref<HTMLElement | null>, canvasRef: Ref<HTMLCanvasElement | null>): ConstellationExpose;

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

@@ -1,94 +0,0 @@
-import type { ConstellationPalette, ConstellationWellConfig } from "./constellationField";
-/**
- * The reference layout width (px) the field's node geometry is authored against. A
- * live canvas's `k = width / BASE_WIDTH` scales every base-width length (the well
- * reach/speed, the node spacing) so a 600px and a 1280px canvas read the same shape.
- */
-export declare const BASE_WIDTH = 1280;
-/**
- * The neutral palette FALLBACK the draw passes read when the `--constellation-*`
- * color/alpha tokens are absent (SSR / no-token mount). The fallbacks mirror the §5c
- * light-arm token defaults so a no-token mount still reads recessive-but-legible.
- *
- * `accent`/`edgeFloor`/`edgeAccentAlpha` (AZ.W-CON-GEN G3) are the ACCENT-edge skin
- * weights the optional `drawEdges(…, accentIndex)` pass reads — the flagged-node EDGE
- * tint. `accent` mirrors the `--constellation-accent` neutral library default;
- * `edgeFloor: 0` is the byte-identity (no floor by default — a consumer lifts it so a
- * distance-faded hairline clears the perceptual floor on a bright ground);
- * `edgeAccentAlpha: 0.30` is the accent-incident edge multiplier.
- */
-export declare const DEFAULT_PALETTE: ConstellationPalette;
-/**
- * Warp spring DEFAULTS — `--constellation-warp-*` tokens override these on mount.
- * `WARP_RESPONSE` is the keyframes.js angular PERIOD (s, NOT a settle-duration);
- * `WARP_ZETA = 1.0` is critically damped so a focal mark never rings/overshoots.
- */
-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;
-/**
- * Auto-DRIFT cadence DEFAULTS (AY.W-CON1 source; tokenised in AY.W-CON2). The
- * `--constellation-wander-idle`/`-wander-jitter` tokens override these on mount; 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;
-/**
- * Autonomous PINNED-ANCHOR drift cadence DEFAULTS (AZ.W-CON-GEN G5). DISTINCT from
- * `wander` (which re-targets the WARP spring among random nodes): this gently eases
- * the PINNED node (`field.pinnedIndex`) around its seeded ANCHOR on a jittered
- * cadence — the flagged point breathes its neighborhood without leaving it. The
- * `--constellation-pinned-drift-*` tokens override these on mount; a prop still wins.
- * `wanderFrac` (±0.14 of the canvas) keeps the pinned node clear of the hero type
- * even as it drifts; `durMs` is the per-leg easeInOutQuad duration; the idle/jitter
- * is the rest between legs (a long, calm rhythm, NOT a metronome).
- */
-export declare const DEFAULT_PINNED_DRIFT_FRAC = 0.14;
-export declare const DEFAULT_PINNED_DRIFT_DUR = 2600;
-export declare const DEFAULT_PINNED_DRIFT_IDLE = 6000;
-export declare const DEFAULT_PINNED_DRIFT_JITTER = 8000;
-/** R5-8 — the shipped visual-size floor: `kVisOf` === `k` for every canvas
- *  ≥ ~0.72·BASE_WIDTH ≈ 922px (incl. the 1280 export frame — byte-identical
- *  there by construction); below it the marks stop crushing sub-pixel. */
-export declare const DEFAULT_K_FLOOR = 0.72;
-/**
- * The maximum node count the points/edges buffers pre-size for (the slider cap — a count
- * above this is clamped at upload). ≫ this BOOKS the compute neighbor-bin path.
- */
-export declare const MAX_NODES = 256;
-/**
- * The per-node max degree budget — the edge buffer is pre-sized at `MAX_NODES · MAX_DEGREE`
- * so the CPU all-pairs scan never overflows it (a denser-than-degree neighborhood drops the
- * weakest edges, never re-allocates). 12 is a generous incident-edge ceiling for a
- * distance-threshold ε-proximity graph at the default link/count.
- */
-export declare const MAX_DEGREE = 12;
-/** The pre-sized edge instance budget (`MAX_NODES · MAX_DEGREE`). */
-export declare const E_MAX: number;
-/**
- * The pointer-parallax depth default (§6). Each node carries a seeded depth `z ∈ [0,1]`;
- * the pointer offsets node screen positions by `parallax · z · (pointer − center)` — a
- * cheap pointer-parallax giving the flat lattice apparent 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 (no parallax).
- */
-export declare const DEFAULT_PARALLAX = 0.08;
-/**
- * The base node radius band (CSS px) the DPR-aware SDF circle sizes within (the §1 "Node
- * size" config axis). `seedField` rolls each node's radius in `[NODE_R_MIN, NODE_R_MIN +
- * NODE_R_SPREAD)` (the prior `1.6 + rng()*1.6` band, named); the WGSL/GLSL fragment SDF
- * sizes `half = radius · uKVis · uDpr / uResolution` so the disc samples at full device
- * resolution and is AA'd by the pixel-footprint derivative — crisp at ANY DPR.
- */
-export declare const NODE_R_MIN = 1.6;
-export declare const NODE_R_SPREAD = 1.6;
-/** The hairline edge half-width (CSS px) the instanced segment-quad fragment AAs. */
-export declare const DEFAULT_LINE_WIDTH = 1;

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

@@ -1,72 +0,0 @@
-export { BASE_WIDTH } from "./constants";
-export type * from "./constellationTypes";
-import type { ConstellationNode, ConstellationField, ConstellationPointer } from "./constellationTypes";
-/**
- * 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
- * reproducible field. Every node drifts; a focal node IS pinnable (AX.W17) — the
- * `field.focalIndex` designation + the engine-owned `warp` spring chase a node,
- * but the underlying node still drifts (warp re-points an EXISTING node, never
- * 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
- * their speed (the slow geometric drift is preserved). `k` is the scale factor.
- *
- * `dt` (seconds since the previous frame) advances the focal-node warp spring
- * 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, now?: number, rng?: () => number, pointerVel?: ConstellationPointer | null): void;
-import type { ConstellationEdge } from "./constellationTypes";
-/**
- * Scan the proximity graph and return its edge SET (the `1 − d²/reach²` distance-falloff
- * weight per pair within `reach = link·k`). `accentIndex ≥ 0` marks the edges incident on
- * that node (the flagged-node tether). Pure + node-testable; the render loop calls it each
- * frame and uploads the result to the instanced-lines storage buffer.
- *
- * `eMax` caps the result (the pre-sized buffer budget). When the scan would exceed it, the
- * WEAKEST overflow edges are dropped (a denser-than-budget neighborhood keeps its strongest
- * links — never re-allocates the GPU buffer mid-frame).
- */
-export declare function buildEdges(field: ConstellationField, link: number, accentIndex?: number, eMax?: number): ConstellationEdge[];
-/**
- * Append the POINTER-WEB tether edges to an existing edge set (the `drawPointerWeb` math
- * relocated): the cursor is a "virtual node" whose incident edges (to every node within
- * `reach`) carry `focus = 1` (the render strokes them at the focus alpha). No-op when the
- * pointer is inactive (`x < 0`). The `eMax` budget is shared with the ambient set.
- */
-export declare function appendPointerWeb(edges: ConstellationEdge[], field: ConstellationField, link: number, pointer: ConstellationPointer | null, eMax?: number): void;
-/**
- * The parallax-offset SCREEN position for a node (§6). Offsets the node by
- * `parallax · z · (pointer − center)` — a cheap pointer-parallax giving the flat lattice
- * apparent depth (deeper nodes — higher `z` — shift more, the Awwwards "living network"
- * register). When the pointer is inactive the offset is 0 (the flat lattice). Pure; the
- * render loop maps each node's `(x,y)` through this before writing the GPU position buffer.
- */
-export declare function parallaxNodePos(node: ConstellationNode, pointer: ConstellationPointer | null, w: number, h: number, parallax: number): {
-    x: number;
-    y: number;
-};

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

@@ -1,141 +0,0 @@
-import type { ConstellationField, ConstellationPinnedDrift, ConstellationWarpConfig, ConstellationWellConfig } from "./constellationField";
-import { DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_WELL_CONFIG, WARP_RESPONSE, WARP_ZETA, DEFAULT_PINNED_DRIFT_FRAC, DEFAULT_PINNED_DRIFT_DUR, DEFAULT_PINNED_DRIFT_IDLE, DEFAULT_PINNED_DRIFT_JITTER } from "./constants";
-export { DEFAULT_WANDER_IDLE, DEFAULT_WANDER_JITTER, DEFAULT_WELL_CONFIG, WARP_RESPONSE, WARP_ZETA };
-export { DEFAULT_PINNED_DRIFT_FRAC, DEFAULT_PINNED_DRIFT_DUR, DEFAULT_PINNED_DRIFT_IDLE, DEFAULT_PINNED_DRIFT_JITTER, };
-/**
- * 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;
-    };
-};
-export { stepWell } from "./constellationWell";
-/**
- * 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;
-/**
- * Build the cold `ConstellationPinnedDrift` state (AZ.W-CON-GEN G5) the field carries
- * when `pinnedDrift` is on. The anchor is seeded LATER (on the first sized frame, off
- * the pinned node's layout position) — here it is `(0,0)` until `stepPinnedDrift`
- * stamps it on the first armed leg. The token-read re-points the un-overridden
- * cadence members on mount (the same prop-over-token layering as the well/wander).
- */
-export declare function makePinnedDrift(override?: {
-    wanderFrac?: number;
-    durMs?: number;
-    minIdle?: number;
-    jitter?: number;
-}): ConstellationPinnedDrift;
-/**
- * Advance the autonomous PINNED-ANCHOR drift one frame (AZ.W-CON-GEN G5). DISTINCT
- * from `wander` (warp re-target): this gently eases the PINNED node around its seeded
- * ANCHOR within `wanderFrac` of the canvas, on a jittered cadence, via a closed-form
- * easeInOutQuad over `now` (no integrator, no second rAF — it rides `stepField`'s ONE
- * per-frame call). No-ops (skipped) when there is no `field.pinnedDrift`, no pinned
- * node, or `now <= 0` (the default unit callers stay green) — so an absent
- * `pinnedDrift` is byte-identical to HEAD.
- *
- * The anchor is captured ON the first armed frame off the pinned node's CURRENT
- * position (its seeded rest), so a consumer that re-anchors the pin (a resize re-fit)
- * gets a fresh anchor on the next leg. Each leg eases from the node's current point to
- * a fresh point within `wanderFrac` of the anchor over `durMs`; between legs the node
- * rests at the leg's end, the next leg arming after `minIdle + rng()*jitter`.
- */
-export declare function stepPinnedDrift(field: ConstellationField, now: number, rng: () => number): void;
-/** The flick-burst threshold (the shared usePointerVelocityField `burst` 0..1) above which
- *  a fast flick fires the focal warp + a transient ripple (a slow drag never fires). */
-export declare const BURST_FIRE_THRESHOLD = 0.45;
-/**
- * Fire a focal BURST off a flick (the §E "reads velocity AND acceleration" mandate). A high
- * `burst` (from the shared `usePointerVelocityField`, the eased flick impulse) warps the
- * focal node toward the cursor (the warp spring snaps it) AND drops an expanding ripple at
- * the focal — the lattice "snaps the focal toward the cursor and drops an expanding ring"
- * (the WGSL ripple instance / the accent-ring overlay). A slow drag (`burst` below the
- * threshold) never fires (a steady hover is the gentle gather, not a snap). Returns true
- * when a burst fired. Composes the EXISTING `warpTo` + the ripple list — no new mechanic,
- * no second rAF (the warp rides the substrate's ONE clock); PRM is enforced by the CALLER
- * (the shared field's `tick(0)` zeroes `burst` under reduce, so this never fires).
- */
-export declare function fireBurst(field: ConstellationField, pointer: {
-    x: number;
-    y: number;
-}, burst: number, ripples: {
-    x: number;
-    y: number;
-    start: number;
-}[]): boolean;

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

@@ -1,25 +0,0 @@
-import type { ConstellationField, ConstellationPalette } from "./constellationField";
-import { DEFAULT_PALETTE } from "./constants";
-/** R5-8 — the visual-SIZE draw scale: `max(k, kFloor)`. The instanced disc/segment
- *  geometry sizes on this; positions/reach stay on TRUE `field.k`. Exported so a
- *  consumer skin floors its own marks on the same axis. */
-export declare function kVisOf(field: ConstellationField): number;
-export { DEFAULT_PALETTE };
-/**
- * Resolve the FULL neutral palette + legibility weights off a canvas's resolved custom
- * properties (the `--constellation-*` set). 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. SSR-safe
- * (returns the warm-cream defaults with no `window`).
- */
-export declare function readPalette(canvas: HTMLCanvasElement): ConstellationPalette;
-/**
- * Parse a CSS color string (the `--constellation-*` hsl/hex literals the palette carries)
- * into a linear-ish premultiplied-ready RGBA in `[0,1]` for the GPU uniform write. A small
- * sRGB parser: it reads `#rgb`/`#rrggbb`/`#rrggbbaa`, `rgb()/rgba()`, and `hsl()/hsla()` —
- * the forms the `--constellation-*` token authoring uses (PLAIN-hsl per arm). The shader
- * outputs premultiplied alpha over the transparent clear, so the render loop multiplies the
- * `a` into the uniform color at upload (kept here so there is ONE color parse seam). Falls
- * back to opaque warm-ink on an unparseable value (never a NaN garbage write).
- */
-export declare function parseColorRGBA(input: string): [number, number, number, number];