@mkbabb/glass-ui 4.2.0 → 6.0.0

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

@@ -0,0 +1,423 @@
+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 painted node position only (never field geometry). 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 for the Canvas2D line pass. `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 renderer consumes the row
+ * directly and never re-derives the scan.
+ */
+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. It perturbs only the painted node position,
+     * never field geometry. 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;
+    /** Decorative 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. Enabling it gives the host a named keyboard/pointer button
+     * contract; Enter/Space targets the field center through the same warp owner.
+     */
+    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). Enabling it
+     * gives the host a named keyboard/pointer button contract; keyboard press/release
+     * drives the same well target as pointer hold/release.
+     */
+    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;
+    /**
+     * The interactive-BACKGROUND feed (BI.W-CONSTELLATION-DEDUPE). A full-bleed
+     * `pointer-events:none` background constellation cannot listen for its own
+     * pointer, so it reads the route chassis's ONE window pointer broadcaster
+     * (`useRoutePointer`, provided by the route chassis) and feeds a SUBTLE pointer
+     * WELL — the attractor/engagement over the shared field, projected by
+     * `constellationWellMapping` and applied by the KEPT per-node well integrator
+     * (`constellationWell.ts`, byte-frozen — the pointer feeds it, it does not
+     * replace it). The background influence is subtle (~2–6%, longer half-life);
+     * the canvas STAYS `pointer-events:none` (the broadcaster is the source). Default
+     * OFF — a foreground demo owns its own host listeners; only a background sets this.
+     */
+    backgroundInteractive?: 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/constellation/index.d.ts

@@ -0,0 +1,6 @@
+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, DEFAULT_PALETTE, } from "./constellationRender";
+export type { ConstellationNode, ConstellationEdge, ConstellationRipple, ConstellationPointer, ConstellationPalette, ConstellationField, ConstellationWarp, ConstellationWarpConfig, ConstellationWander, ConstellationWell, ConstellationWellConfig, ConstellationPinnedDrift, ConstellationProps, } from "./constellationTypes";

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

@@ -0,0 +1,32 @@
+type DarkModeToggleSize = "sm" | "md" | "lg" | "control" | "dock";
+type __VLS_Props = {
+    /**
+     * 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;
+    disableTransitions: boolean;
+    eclipse: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/controls/dark-mode-toggle.css

@@ -0,0 +1 @@
+@layer components { .dark-mode-toggle-button { width: var(--dark-mode-toggle-size, 2.25rem); height: var(--dark-mode-toggle-size, 2.25rem); min-width: var(--dark-mode-toggle-size, 2.25rem); min-height: var(--dark-mode-toggle-size, 2.25rem); max-width: var(--dark-mode-toggle-size, 2.25rem); max-height: var(--dark-mode-toggle-size, 2.25rem); aspect-ratio: 1; padding: var(--dark-mode-toggle-padding, 0.375rem); transition: opacity var(--dock-motion-standard), background-color var(--dock-motion-standard), box-shadow var(--dock-motion-fast); & > svg { width: 100%; height: 100%; max-width: 100%; max-height: 100%; } &:hover, &:focus { background: var(--surface-tint-10); opacity: 1; outline: none; } &:focus-visible { box-shadow: var(--dock-ring); } &[data-size="sm"] { --dark-mode-toggle-size: 1.75rem; --dark-mode-toggle-padding: 0.25rem; } &[data-size="md"] { --dark-mode-toggle-size: 2.25rem; --dark-mode-toggle-padding: 0.375rem; } &[data-size="lg"] { --dark-mode-toggle-size: 2.75rem; --dark-mode-toggle-padding: 0.5rem; } &[data-size="control"] { --dark-mode-toggle-size: var(--control-size, 2.25rem); --dark-mode-toggle-padding: var(--control-icon-padding, 0.375rem); } } .dark-mode-toggle-button[data-size="dock"], .glass-dock .dark-mode-toggle-button:not([data-size="sm"]):not([data-size="lg"]):not( [data-size="control"] ) { --dark-mode-toggle-size: var(--dock-control-size, var(--size-icon-btn)); --dark-mode-toggle-padding: calc( ( var(--dock-control-size, var(--size-icon-btn)) - var(--dock-control-glyph-size, var(--dock-icon-glyph, 1.25rem)) ) / 2 ); } .glass-dock .dark-mode-toggle-button:not([data-size="sm"]):not([data-size="lg"]):not( [data-size="control"] ) > svg { width: var(--dock-control-glyph-size, var(--dock-icon-glyph, 1.25rem)); height: var(--dock-control-glyph-size, var(--dock-icon-glyph, 1.25rem)); } }

package/dist/components/data-table/DataTable.vue.d.ts

@@ -0,0 +1,94 @@
+import type { DataTableColumn, DataTableRowAttrs, DataTableRowRef, DataTableSort } from "./types";
+declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<({
+        columns: DataTableColumn<T>[];
+        rows: T[];
+        total: number;
+        pageSize: number;
+        isLoading?: boolean;
+        rowKey?: string;
+        getRowId?: (row: T) => PropertyKey | null | undefined;
+        role?: "grid";
+        ariaLabel?: string;
+        ariaColCount?: number;
+        ariaRowCount?: number;
+        getRowAttrs?: DataTableRowAttrs<T>;
+        rowRef?: DataTableRowRef<T>;
+        tabbableRowId?: PropertyKey | null;
+        sort?: DataTableSort;
+        /** Enables the controlled single-row selection contract. */
+        selectable?: boolean;
+        /** Stable identity of the selected row when `selectable` is true. */
+        selectedRowId?: PropertyKey | null;
+        infinite?: boolean;
+        hasMore?: boolean;
+        /**
+         * When true, the table collapses to a stacked card-per-row
+         * projection once its own container measures below
+         * `cardBreakpoint`. A dense multi-column table has no responsive
+         * story at narrow widths — a horizontal-scroll wrapper leaves
+         * half the columns invisible. The card projection keeps every
+         * field reachable: the first column becomes the card header
+         * (with the row-actions menu docked beside it), every other
+         * column renders as a label/value pair below. At/above the
+         * breakpoint the unchanged tabular layout renders.
+         */
+        responsive?: boolean;
+        /**
+         * Container-width (CSS px) below which `responsive` swaps to the
+         * card projection. Container-driven (not viewport-driven) so a
+         * table inside a narrow column collapses at any viewport width.
+         */
+        cardBreakpoint?: number;
+        class?: string;
+    } & {
+        page: number;
+    }) & {
+        onSelect?: ((row: T) => any) | undefined;
+        "onUpdate:page"?: ((value: number) => any) | undefined;
+        "onUpdate:sort"?: ((sort: DataTableSort) => any) | undefined;
+        "onUpdate:selectedRowId"?: ((id: PropertyKey) => any) | undefined;
+        "onLoad-more"?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        'row-actions'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        'row-context-menu'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        'row-actions'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        'row-context-menu'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        'row-actions'?: (props: {
+            row: T;
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        sentinel?: (props: {}) => any;
+    };
+    emit: (((evt: "select", row: T) => void) & ((evt: "update:sort", sort: DataTableSort) => void) & ((evt: "update:selectedRowId", id: PropertyKey) => void) & ((evt: "load-more") => void)) & ((event: "update:page", value: number) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/data-table/index.d.ts

@@ -0,0 +1,2 @@
+export { default as DataTable } from "./DataTable.vue";
+export type { DataTableColumn, DataTableSort, DataTableProps, DataTableRowAttrs, DataTableRowRef, } from "./types";

package/dist/components/data-table/types.d.ts

@@ -0,0 +1,81 @@
+import type { Component, HTMLAttributes } from "vue";
+export interface DataTableColumn<T = any> {
+    /** Unique key matching a property on the row object */
+    key: string;
+    /** Display label for the column header */
+    label: string;
+    /** Optional formatter for cell values */
+    formatter?: (value: any, row: T) => string;
+    /** Optional custom component to render in the cell. Receives `value` and `row` props. */
+    component?: Component;
+    /** Whether this column is sortable */
+    sortable?: boolean;
+    /** Text alignment */
+    align?: "left" | "center" | "right";
+    /** Additional CSS classes for the column cells */
+    class?: string;
+    /** Additional CSS classes for the header cell */
+    headerClass?: string;
+}
+export interface DataTableSort {
+    key: string;
+    direction: "asc" | "desc";
+}
+/** Caller-owned bindings for a mounted data row. */
+export type DataTableRowAttrs<T> = (row: T, index: number) => HTMLAttributes | undefined;
+/** Receives each mounted row element and `null` when that row leaves the DOM. */
+export type DataTableRowRef<T> = (element: HTMLElement | null, row: T, index: number) => void;
+export interface DataTableProps<T = any> {
+    /** Column definitions */
+    columns: DataTableColumn<T>[];
+    /** Row data to display */
+    rows: T[];
+    /** Total number of rows across all pages (for pagination display) */
+    total: number;
+    /** Current page number (1-indexed) */
+    page: number;
+    /** Number of rows per page */
+    pageSize: number;
+    /** Whether data is currently loading */
+    isLoading?: boolean;
+    /** Unique key field on each row (defaults to "_id") */
+    rowKey?: string;
+    /** Optional resolver for stable unique row identities. Takes precedence over rowKey. */
+    getRowId?: (row: T) => PropertyKey | null | undefined;
+    /** Opt into grid semantics on the native table projection. */
+    role?: "grid";
+    /** Accessible name applied to the native table projection. */
+    ariaLabel?: string;
+    /** Logical column count applied to the native table projection. */
+    ariaColCount?: number;
+    /** Native-table logical row count, including any header row. */
+    ariaRowCount?: number;
+    /**
+     * Attributes and handlers for each caller-windowed row. `aria-rowindex`
+     * applies only to the native-table projection and is omitted from cards.
+     */
+    getRowAttrs?: DataTableRowAttrs<T>;
+    /** Mounted row element callback for measurement or focus. */
+    rowRef?: DataTableRowRef<T>;
+    /** Stable id of the sole mounted row placed in the tab order. */
+    tabbableRowId?: PropertyKey | null;
+    /** Current sort state */
+    sort?: DataTableSort;
+    /** Enables controlled single-row selection and row keyboard activation. */
+    selectable?: boolean;
+    /** Stable identity of the selected row when selection is enabled. */
+    selectedRowId?: PropertyKey | null;
+    /** When true, hides pagination and shows infinite scroll sentinel */
+    infinite?: boolean;
+    /** Whether more data is available (for infinite scroll mode) */
+    hasMore?: boolean;
+    /**
+     * When true, the table collapses to a stacked card-per-row
+     * projection once its container measures below `cardBreakpoint` —
+     * the responsive story for a dense multi-column table at narrow
+     * widths. At/above the breakpoint the tabular layout renders.
+     */
+    responsive?: boolean;
+    /** Container-width (CSS px) below which `responsive` swaps to cards. Defaults to 640. */
+    cardBreakpoint?: number;
+}

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

@@ -0,0 +1,4 @@
+/** 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/deck/index.d.ts

@@ -0,0 +1,7 @@
+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 { default as DeckPager } from "./DeckPager.vue";
+export { CONTROL_SELECTOR } from "./constants";
+export type { PagerWindow } from "../pager-dots/pagerWindow";