@mkbabb/glass-ui 3.13.0 → 4.0.0

package/dist/components/custom/configurator/Configurator.vue.d.ts

@@ -3,14 +3,14 @@ import { type ConfiguratorDensity } from "./density";
 /**
  * Scroll behavior for the controls column.
  *
- * - `auto`   — overflow-y-auto with `.scroll-fade-y` mask; controls scroll
- *              when their intrinsic height exceeds the host. Default.
- * - `always` — controls always render scroll affordance (mask + thin
- *              scrollbar). Use when authors want a fixed-height studio
- *              regardless of content.
- * - `never`  — controls do not scroll; host grows to content height. Use
- *              for popover/sheet hosts that already manage their own
- *              overflow.
+ * - `auto`   — the controls column renders a <FadingScroll axis="y"> scroll-port
+ *              (sharp at rest, feathered while overflowing); controls scroll when
+ *              their intrinsic height exceeds the host. Default.
+ * - `always` — same <FadingScroll> scroll-port + thin scrollbar. Use when
+ *              authors want a fixed-height studio regardless of content.
+ * - `never`  — controls do not scroll; host grows to content height. Renders a
+ *              plain div (no FadingScroll). Use for popover/sheet hosts that
+ *              already manage their own overflow.
  */
 export type ConfiguratorScrollMode = "auto" | "always" | "never";
 /**
@@ -106,6 +106,17 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
         }) => any;
     } & {
         default?: (props: {}) => any;
+    } & {
+        controls?: (props: {
+            layers: readonly {
+                id: string;
+                label: string;
+            }[] | undefined;
+            activeLayer: string | undefined;
+            selectLayer: (id: string) => void;
+        }) => any;
+    } & {
+        default?: (props: {}) => any;
     } & {
         footer?: (props: {
             reset: () => void;

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

@@ -1,90 +1,12 @@
-import { type HTMLAttributes } from "vue";
-import { type ConstellationField } from "./constellationField";
-/**
- * Constellation — a slow, geometric proximity-graph lattice on a Canvas2D
- * surface. Nodes drift + bounce; near nodes link with distance-falloff
- * hairlines; the web leans toward the cursor and taps ripple. It composes the
- * `useCanvas2D` substrate, so it inherits the offscreen / tab-hidden /
- * reduced-motion freeze for free (no hand-rolled RAF-park).
- *
- * The lattice ships NEUTRAL. A branded skin (a focal ring, a callout label) is
- * the consumer's `drawOverlay(ctx, field, now)` pass — it runs AFTER the four
- * neutral passes and receives the live field so it can pin itself to a real
- * node. Zero deck-domain content lives in the component.
- *
- * Palette reads the FULL `--constellation-*` legibility set off the canvas (the
- * node/node-dim/line colors + the edge-alpha multipliers + the field-yields-to-
- * type `--constellation-alpha` knob; neutral fallbacks), so a consumer override
- * or a dark-mode flip re-tints AND re-weights the lattice (AX.W17).
- *
- * The focal node + click-to-warp (AX.W17) is a first-class engine concept: with
- * `warpOnClick`, a click warps the focal node to the nearest drifting node via a
- * critically-damped spring stepped INSIDE the substrate's single rAF (no
- * `useSpring`, no second rAF). The consumer paints the focal mark at
- * `field.warp.{x,y}` in its `drawOverlay`.
- */
-type __VLS_Props = {
-    /** Node count. Default 64. */
-    count?: number;
-    /** Link distance in px (the falloff reach). Default 132. */
-    link?: number;
-    /** Drift speed. Default 0.16. */
-    speed?: number;
-    /**
-     * AY.W-COHERE E3 — the per-instance outer-envelope RECESSION knob (the
-     * aurora `opacityCeiling` / fourier `intensity` sibling — the SAME prop NAME
-     * the other live substrates carry, so the four-substrate recession contract is
-     * ONE vocabulary). The painted edge/node/web/ripple alpha scales by this value
-     * OVER the mode-tuned `--constellation-alpha` base, so a constellation hero can
-     * RECEDE behind content (StoryHero sets 0.4–0.6) exactly as its aurora + fourier
-     * siblings do. Default `1` is byte-identical to HEAD (the draw-alpha trace is
-     * unchanged — the default-OFF canary). NOT a second token: `--constellation-alpha`
-     * stays the mode recession base, this is the per-instance loudness envelope.
-     */
-    opacityCeiling?: number;
-    /**
-     * Seed for a REPRODUCIBLE field. A `number` or `string` (hashed) seeds the
-     * shared `mulberry32`; omit for a fresh `Math.random` field each mount.
-     */
-    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 and SPRINGS it there (critically damped, chasing the LIVE
-     * target). INDEPENDENT of `pointerReactive`. Default false; auto-off under
-     * reduced-motion (the focal mark stays put). Sugars the exposed `warpTo(...)`.
-     */
-    warpOnClick?: boolean;
-    /**
-     * Auto-DRIFT (AY.W-CON1). A periodic auto-pick re-points the focal node to a
-     * RANDOM node on a jittered cadence — the wander source on the SAME warp
-     * spring (the 2nd half of the AX.W17 "drift + warp are ONE mechanic" thesis;
-     * no second rAF, no second mechanic). `true` uses the default cadence
-     * (8–16s, the slides rhythm); `{ minIdle?, jitter? }` tunes it (ms). Default
-     * OFF — `wander` absent leaves `field.wander` undefined, byte-identical to
-     * HEAD. PRM-gated by the WARP precedent: the cadence lives inside the
-     * `!reducedMotion` step block, so under reduced-motion it never advances and
-     * the focal mark stays at its seed (NOT fire-but-freeze).
-     */
-    wander?: boolean | {
-        minIdle?: number;
-        jitter?: number;
-    };
-    /**
-     * Pointer-held GRAVITY-WELL (AY.W-CON2). Hold the pointer over the lattice and
-     * the nodes within reach are PULLED toward it (an inverse-square force on the
-     * SAME engine, no second rAF); release and the field cools back to `speed`.
-     * INDEPENDENT of `warpOnClick` and `pointerReactive` (a consumer can
-     * hold-to-pull on a non-ripple, non-warp lattice). `true` uses the tokenised
-     * `--constellation-well-*` defaults; an object overrides the gains. Default
-     * OFF — `gravityWell` absent leaves `field.well` undefined (byte-identical to
-     * HEAD; `stepField` skips the force pass). PRM-gated by the WARP precedent: the
-     * held-timer block lives inside `!reducedMotion`, so under reduced-motion the
-     * well never arms; AND the well STATE resets to neutral on the PRM-true edge
-     * (no half-ramped force frozen on).
-     */
-    gravityWell?: boolean | {
+import { type ConstellationProps } from "./constellationField";
+declare const __VLS_export: import("vue").DefineComponent<ConstellationProps, import("./composables/useConstellation").ConstellationExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ConstellationProps> & Readonly<{}>, {
+    link: number;
+    speed: number;
+    count: number;
+    opacityCeiling: number;
+    pointerReactive: boolean;
+    warpOnClick: boolean;
+    gravityWell: boolean | {
         holdMs?: number;
         gain?: number;
         reach?: number;
@@ -92,129 +14,19 @@ type __VLS_Props = {
         maxSpeed?: number;
         soften?: number;
     };
-    /**
-     * PINNED node designation (AZ.W-CON-GEN G1). A pinned node is HELD by every step
-     * pass — it does NOT drift, bounce, steer toward the cursor, or feel the
-     * gravity-well, so it stays at its seeded position (the flagged node a
-     * consumer pins). `false`/absent → no pin (every node drifts, byte-identical to
-     * HEAD); `true` → node 0 (the canonical flagged node); a number → that index. The
-     * `accentEdges` prop tints its incident edges; the `pinnedDrift` prop gently
-     * wanders it around its anchor. The `pinNode(idx)` expose re-points it imperatively.
-     */
-    pinned?: boolean | number;
-    /**
-     * ACCENT-edge skin (AZ.W-CON-GEN G2). When `true`, edges incident on the PINNED
-     * (else the FOCAL) node stroke the `--constellation-accent` tint at the
-     * `--constellation-edge-accent-alpha` weight — the flagged-node tether — while
-     * every other edge keeps the neutral register. Default OFF (the single-color
-     * neutral pass, byte-identical to HEAD). Reads the accent off the resolved palette.
-     */
-    accentEdges?: boolean;
-    /**
-     * Autonomous PINNED-ANCHOR drift (AZ.W-CON-GEN G5). When set AND a node is pinned,
-     * the pinned node gently eases around its seeded anchor within `wanderFrac`
-     * (default ±0.14 of the canvas) on a jittered cadence (a closed-form easeInOutQuad
-     * stepped inside the substrate's single rAF — no second rAF). DISTINCT from
-     * `wander` (which re-targets the warp among random nodes): this breathes the ONE
-     * pinned node around its rest. `true` uses the default cadence; an object tunes it.
-     * Default OFF — the pinned node holds dead-still (byte-identical). PRM-gated by the
-     * WARP precedent (the drift lives inside `!isStatic`; under reduce the pin holds).
-     */
-    pinnedDrift?: boolean | {
+    wander: boolean | {
+        minIdle?: number;
+        jitter?: number;
+    };
+    pinned: boolean | number;
+    accentEdges: boolean;
+    pinnedDrift: boolean | {
         wanderFrac?: number;
         durMs?: number;
         minIdle?: number;
         jitter?: number;
     };
-    /**
-     * Warp AUTO-RELEASE (AZ.W-CON-GEN G6). When `true`, a warp that has SETTLED on its
-     * target clears its `targetIdx` — 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` keeps the held-target behaviour (the warp chases its node
-     * forever — byte-identical to HEAD). Read the settled signal via the
-     * `warpSettled()` expose.
-     */
-    warpAutoRelease?: boolean;
-    /**
-     * Deterministic-capture freeze (AY.W-CON3). When `true`, the lattice lays
-     * out ONE reproducible STATIC frame and does NOT advance — seeded layout
-     * (set `seed` for a stable field ACROSS runs; an unseeded freeze still
-     * freezes but lays out a one-shot `Math.random` frame), no `stepField`, no
-     * ripple / warp / wander / well advance, and a FROZEN `now` handed to
-     * `drawOverlay` so a phase-driven skin (`(now % T) / T`) resolves to a fixed
-     * value (the pulse-ring radius is identical frame-over-frame). Omit to
-     * AUTO-DERIVE from `location.search` matching `export | print | freeze` (the
-     * deploy-pipeline contract — a consumer's pptx / print / screenshot capture
-     * gets a stable frame with zero per-consumer wiring). An explicit
-     * `:freeze="false"` forces live even under a capture URL. Unifies with the
-     * reduced-motion one-static-frame path — `freeze || reducedMotion` is the
-     * single static-frame predicate; the capture takes no input (the pointer /
-     * warp / well listeners are NOT registered under freeze).
-     */
-    freeze?: boolean;
-    class?: HTMLAttributes["class"];
-    /**
-     * The skin seam. Runs after the neutral passes with the live field, so a
-     * consumer paints its own focal mark pinned to a real node — read
-     * `field.warp.{x,y}` for the spring-eased focal position when `warpOnClick`
-     * is on. The branded content (a domain accent, a callout label) lives HERE,
-     * in the consumer. Under `freeze` it receives a FROZEN `now`, so a phase-
-     * driven mark resolves to a fixed value.
-     */
-    drawOverlay?: (ctx: CanvasRenderingContext2D, field: ConstellationField, now: number) => void;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
-    /** The live field (the low-level imperative seam — for a custom overlay). */
-    field: ConstellationField;
-    /**
-     * The resolved deterministic-capture predicate (AY.W-CON3) — `true` when the
-     * lattice is laying out a frozen static frame (`freeze` prop OR a
-     * `?export|print|freeze` URL OR reduced-motion via the substrate). A read-only
-     * test/debug seam (the π freeze-live spec reads it to confirm the auto-derive
-     * fired without inferring from drift).
-     */
-    isFrozen: import("vue").ComputedRef<boolean>;
-    /**
-     * Imperative warp (AX.W17). Two call shapes:
-     *   `warpTo(localPoint)`              — `{x, y}` already in canvas-local px
-     *                                        (the lower primitive).
-     *   `warpTo(clientX, clientY)`        — client coords, mapped via the
-     *                                        deck-scale `toLocal` (the sugar
-     *                                        `warpOnClick` calls internally).
-     * The focal node re-points to the nearest drifting node + springs there.
-     * Returns the chosen node index, or -1 on a degenerate no-op. No-op under
-     * reduced-motion (the spring does not advance while the substrate is frozen).
-     */
-    warpTo(a: {
-        x: number;
-        y: number;
-    } | number, b?: number): number;
-    /**
-     * Imperatively ARM the gravity-well at a canvas-LOCAL point (AY.W-CON2) — the
-     * π-lane test seam that drives the well WITHOUT racing a real held-pointer
-     * gesture + the held-timer. Sets the well position + `target = 1` directly (the
-     * timer is bypassed; the ramp still eases `strength` over the next frames). No-op
-     * when `gravityWell` is off (no `field.well`). Returns true when the well armed.
-     */
-    holdWellAt(x: number, y: number): boolean;
-    /** Imperatively RELEASE the well (AY.W-CON2) — `target → 0`, the field cools. */
-    releaseWell(): void;
-    /**
-     * The warp settled signal (AZ.W-CON-GEN G6) — `true` when the warp spring has
-     * ARRIVED on its target (no active warp, OR the focal's gap to its live target is
-     * within the settle band). A consumer polls this to know if a click-warp / wander
-     * re-target is still in flight (the `isSettled` read). A read-only seam over the
-     * engine `warpSettled`.
-     */
-    warpSettled(): boolean;
-    /**
-     * Imperatively PIN a node (AZ.W-CON-GEN G1) — re-points `field.pinnedIndex` to
-     * `idx` so that node is HELD by every step pass (it stops drifting and holds its
-     * current position). `idx < 0` clears the pin (every node drifts again). The
-     * pinned node's incident edges tint accent under `accentEdges`; it wanders its
-     * anchor under `pinnedDrift` (the cadence re-anchors on its next armed leg).
-     */
-    pinNode(idx: number): void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    warpAutoRelease: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -0,0 +1,26 @@
+import { type Ref } from "vue";
+import { type ConstellationField, type ConstellationProps } from "../constellationField";
+/** The imperative seam the SFC re-exposes via `defineExpose`. */
+export interface ConstellationExpose {
+    field: ConstellationField;
+    isFrozen: Ref<boolean>;
+    warpTo(a: {
+        x: number;
+        y: number;
+    } | number, b?: number): number;
+    holdWellAt(x: number, y: number): boolean;
+    releaseWell(): void;
+    warpSettled(): boolean;
+    pinNode(idx: number): void;
+}
+/**
+ * Drive a `<Constellation>` instance. `props` is the REACTIVE (defaulted) prop
+ * surface — the per-frame live-read props (`pointerReactive`/`opacityCeiling`/
+ * `accentEdges`/`drawOverlay`) are read off `props.x` INSIDE the render loop so a
+ * bound `:opacity-ceiling` updates without a remount (the Vue 3.5 reactive-prop
+ * read; the SFC `defineProps` destructure transform does not reach a composable
+ * argument, so the live reads stay on `props`). `hostRef`/`canvasRef` are the SFC
+ * template refs. Returns the imperative expose object the SFC spreads into
+ * `defineExpose`.
+ */
+export declare function useConstellation(props: ConstellationProps, hostRef: Ref<HTMLElement | null>, canvasRef: Ref<HTMLCanvasElement | null>): ConstellationExpose;