@mkbabb/glass-ui 4.2.0 → 5.0.0

package/dist/components/custom/goo-dot-matrix/GooDotMatrix.vue.d.ts

@@ -1,49 +0,0 @@
-import type { GooDotConfig } from "./constants";
-/**
- * GooDotMatrix — the metaball SDF FIELD rendered as a DOT MATRIX (BC.W-VIZ-HYBRID — the
- * hybrid of the goo blob and the dot matrix).
- *
- * The merging metaball reads as a FIELD OF DOTS that flow and merge: a regular grid of small
- * warm-cream dots fills the card, and where the gooey blob is — its core, its satellites, the
- * liquid neck stretching between them — the dots are DENSE, BIG, and BRIGHT; out at the rim
- * and beyond they thin to small and dim, then vanish. As a satellite orbits in and meatballs
- * into the body, the band of dots between them THICKENS into a connected bridge, then snaps
- * back when it absorbs — the gooey form drawn entirely in dots.
- *
- * It re-uses two SOTA primitives the codebase already owns — the goo-blob SDF FIELD
- * (byte-untouched `sceneDistG`) + the dot-matrix RENDER — joined by ONE new idea: the
- * dot-grid OUTPUT stage (`v = thickness(sceneDistG(cellCenter))` drives the dot size +
- * brightness, tixy.land applied to an SDF). Four registers, ONE field: `dot-field` (the
- * §T4 default — the smooth field-driven dot), `dot-dither` (the Bayer8 halftone),
- * `dot-lattice` / `dot-sphere` (the opt-in instanced flow/depth look).
- *
- * WebGPU-FIRST: the dot-stamp fragment over the spliced field; a WebGL2 dot-stamp fallback
- * runs the SAME field + dot grid where WebGPU is absent (born-GPU — no Canvas2D). It composes
- * `useGooDotMatrix` → the `createGpuSubstrate` picker over the ONE canvas lifecycle leaf
- * (offscreen-pause, live-PRM freeze, the shared pointer field) — it never bootstraps its own
- * context. The DEFAULT palette is the warm-cream library identity over a transparent ground;
- * the near-dark + reference reproductions are DEMO presets (presets-in-consumers). The
- * teal-on-navy is GONE entirely.
- */
-type __VLS_Props = {
-    /** The full author schema (the studio's `useConfiguratorState` model). */
-    config?: GooDotConfig;
-    /**
-     * The declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the render loop (the
-     * substrate's `manual` suspend) when `true`. Wire `<DockBackgroundToggle>`'s
-     * `@update:paused` to this `v-model`.
-     */
-    paused?: boolean;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
-    pause: () => void;
-    resume: () => void;
-    wake: () => void;
-    renderAt: (timeSec: number) => void;
-}, {}, {}, {}, 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;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/components/custom/goo-dot-matrix/composables/gooDotLattice.d.ts

@@ -1,24 +0,0 @@
-import { fibonacciDot, type Vec3 } from "../../dot-matrix";
-export { fibonacciDot, type Vec3 };
-/** A 2-vector — the NDC lattice anchor. */
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-/**
- * The §T3 deterministic SCREEN lattice anchor for instance `index` of a `cols`-wide row-major
- * grid at `pitch` NDC spacing, centred on the origin. `rows` is derived so the grid is roughly
- * square (the instance fan-out `cols × rows ≥ count`); the WGSL `gridOrigin(ii, uCols, uPitch)`
- * transcribes this EXACTLY (the round-trip parity anchor):
- *
- *   col    = index % cols
- *   row    = floor(index / cols)
- *   x      = (col - (cols-1)/2) · pitch
- *   y      = (row - (cols-1)/2) · pitch   // a square grid centred on origin
- *
- * The anchors fill a centred `cols × cols` lattice in NDC; the field is sampled AT each anchor
- * for the dot size+brightness, with an opt-in `-grad` flow displacement toward the merging core.
- */
-export declare function gridOrigin(index: number, cols: number, pitch: number): Vec2;
-/** The Register-B instance count for a `cols`-wide square lattice. */
-export declare function latticeInstanceCount(cols: number): number;

package/dist/components/custom/goo-dot-matrix/composables/gooDotSetup.d.ts

@@ -1,79 +0,0 @@
-import { type BlobWGPUUniformScratch } from "../../goo-blob/composables/uniformBridgeWGPU";
-import { type MetaballUniformLocations } from "../../goo-blob/composables/uploadBlobUniforms";
-import { type GooDotUniformScratch } from "./uniformBridgeWGPU";
-export declare const GOO_DOT_LABEL = "[GooDotMatrix]";
-/** The ground uniform buffer byte size — ONE vec4 (uGroundTime, aspect, pad, pad). */
-export declare const GOO_DOT_GROUND_BYTES = 16;
-/** The one-time WGPU resources the per-frame closure reads (the dot pipeline + the ground
- * pipeline (Move 4a, pass-1) + the buffers + scratch). */
-export interface GooDotWGPUResources {
-    pipeline: GPURenderPipeline;
-    bindGroup: GPUBindGroup;
-    /** Move 4a — the warm-ground pass-1 pipeline (its own minimal shader, NOT Aurora). */
-    groundPipeline: GPURenderPipeline;
-    groundBindGroup: GPUBindGroup;
-    groundBuffer: GPUBuffer;
-    groundScratch: Float32Array;
-    fieldBuffer: GPUBuffer;
-    dotBuffer: GPUBuffer;
-    fieldScratch: BlobWGPUUniformScratch;
-    dotScratch: GooDotUniformScratch;
-}
-/**
- * Build the WGPU dot-stamp pipeline + the field (binding0) / dot-grid (binding1) uniform
- * buffers + bind group + the two scratch buffers — ONCE on `setupWGPU`. The composable's
- * per-frame closure writes the scratch via the pack helpers then submits the draw.
- */
-export declare function createGooDotWGPUResources(device: GPUDevice, format: GPUTextureFormat): GooDotWGPUResources;
-/** The dot-grid uniform locations (the dot extend, beside the field locations). The N named
- * scalars are the GLSL twin of the WGSL s8–s13 lane-fields; a unit asserts count parity. */
-export interface GooDotGLUniforms {
-    mode: WebGLUniformLocation | null;
-    pix: WebGLUniformLocation | null;
-    floor: WebGLUniformLocation | null;
-    bright: WebGLUniformLocation | null;
-    min: WebGLUniformLocation | null;
-    max: WebGLUniformLocation | null;
-    pr: WebGLUniformLocation | null;
-    pm: WebGLUniformLocation | null;
-    pa: WebGLUniformLocation | null;
-    cursor: WebGLUniformLocation | null;
-    bloom: WebGLUniformLocation | null;
-    shadowGate: WebGLUniformLocation | null;
-    presenceFloor: WebGLUniformLocation | null;
-    weldLo: WebGLUniformLocation | null;
-    weldHi: WebGLUniformLocation | null;
-    time: WebGLUniformLocation | null;
-    weldSwell: WebGLUniformLocation | null;
-    weldSpecular: WebGLUniformLocation | null;
-    flowAmt: WebGLUniformLocation | null;
-    latticeSquash: WebGLUniformLocation | null;
-}
-/** The Move 4a warm-ground GL program (the WebGL2/Safari tail of pass-1). */
-export interface GooDotGroundGLResources {
-    prog: WebGLProgram;
-    vs: WebGLShader;
-    fs: WebGLShader;
-    vao: WebGLVertexArrayObject;
-    buf: WebGLBuffer;
-    uTime: WebGLUniformLocation | null;
-}
-/** The one-time GL resources the per-frame closure reads (program + VAO + the field + dot
- * locations + the Move 4a ground program). */
-export interface GooDotGLResources {
-    prog: WebGLProgram;
-    vs: WebGLShader;
-    fs: WebGLShader;
-    buf: WebGLBuffer;
-    vao: WebGLVertexArrayObject;
-    locs: MetaballUniformLocations;
-    dU: GooDotGLUniforms;
-    ground: GooDotGroundGLResources;
-}
-/**
- * Build the WebGL2 dot-stamp program + the full-quad VAO + the field uniform-location cache
- * (the SAME UNIFORM_NAMES the field GLSL declares) + the dot-grid uniform locations — ONCE on
- * `setupGL`. The composable's per-frame closure sets the dot uniforms then calls the REUSED
- * goo-blob `uploadBlobUniforms` (which writes the field + issues the draw).
- */
-export declare function createGooDotGLResources(gl: WebGL2RenderingContext): GooDotGLResources;

package/dist/components/custom/goo-dot-matrix/composables/uniformBridgeWGPU.d.ts

@@ -1,45 +0,0 @@
-import type { GooDotConfig } from "../constants";
-/** The total dot-grid uniform-buffer byte size (16-aligned — 6 vec4 lanes). */
-export declare const GOO_DOT_UNIFORM_BYTES = 96;
-export declare const WELD_LO = 0.1;
-export declare const WELD_HI = 0.45;
-/** The dot-mode int the shader branches on (0 = smooth field dot, 1 = Bayer dither). */
-export declare function dotModeFor(variant: GooDotConfig["variant"]): number;
-/** The repel/attract sign for a pointer mode (repel pushes out, attract pulls in). */
-export declare function pointerModeSign(mode: GooDotConfig["pointerMode"]): number;
-/** The transient dot-cursor + liquid-field state the renderer writes per-frame (closed over,
- * never the config). The cursor push (Move 3 shadow offset, the cursor swell) AND the
- * liquid-lattice clock (Move 4b twinkle + squash) ride here so the per-frame pack reads ONE
- * transient struct. */
-export interface GooDotPointerState {
-    /** Field-uv cursor [-0.5, 0.5] (0,0 = canvas center). */
-    x: number;
-    y: number;
-    /** 1 while the pointer is over the host, 0 at rest (decays the influence). */
-    active: number;
-    /** The accel-burst brightness/scale bloom 0..1 (the flick term, the velocity tell). */
-    bloom: number;
-    /** The live sim clock (s) for the φ-twinkle breathing — the field's `breath`/`hash21` phase. */
-    timeSec: number;
-    /** The volume-preserving lattice squash (Move 4b): the X scale on the pulse + a fast drag;
-     * the shader applies `1/squash` on Y so the cell area ≈ 1 (a liquid lean, not a balloon). */
-    latticeSquash: number;
-}
-/** A fresh resting dot-cursor state. */
-export declare function restingDotPointer(): GooDotPointerState;
-export interface GooDotUniformScratch {
-    buffer: ArrayBuffer;
-    f32: Float32Array;
-}
-export declare function createGooDotScratch(): GooDotUniformScratch;
-/**
- * Pack the per-frame dot-grid uniforms in place. `resolutionPx` drives the cell grid;
- * `pointer` carries the §T7 dot-cursor influence (parallax/swell/bloom). The field lanes are
- * packed SEPARATELY by the goo-blob `packBlobWGPUUniforms` into binding0 — this module owns
- * ONLY the dot-grid lanes (the extend).
- */
-export declare function packGooDotUniforms(scratch: GooDotUniformScratch, config: GooDotConfig, resolutionPx: {
-    w: number;
-    h: number;
-}, dpr: number, pointer: GooDotPointerState): GooDotUniformScratch;
-export { restingDotPointer as restingPointer };

package/dist/components/custom/goo-dot-matrix/composables/useGooDotMatrix.d.ts

@@ -1,31 +0,0 @@
-import { type Ref } from "vue";
-import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
-import type { GooDotConfig } from "../constants";
-export interface UseGooDotMatrixOptions {
-    config: GooDotConfig;
-    /** `"capture"` → renderAt-only (the deterministic π capture path). Default `"live"`. */
-    mode?: "live" | "capture";
-}
-/** The uniform handle a consumer wires its lifecycle against (backend-agnostic). */
-export interface GooDotMatrixHandle {
-    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 fallback). */
-    readonly backend: GpuBackend;
-    /** Park the loop (the WCAG-2.2.2 pause seam — `DockBackgroundToggle` wires this). */
-    pause: () => void;
-    /** Re-arm the loop. */
-    resume: () => void;
-    /** Re-arm a parked loop on demand (a pointer/setter that re-introduced motion). */
-    wake: () => void;
-    /** Draw one frame out-of-loop (capture / thumbnail). */
-    renderAt: (timeSec: number) => void;
-    /** The live `prefers-reduced-motion: reduce` state. */
-    readonly reducedMotion: boolean;
-    /** Tear down the renderer + release GPU/GL resources. */
-    dispose: () => void;
-}
-/**
- * Mount the goo-dot-matrix renderer on `canvasRef`. The WebGPU primary runs the dot-stamp
- * fragment over the byte-untouched goo-blob field; the WebGL2 fallback runs the SAME dot-stamp
- * (the ONE field, the ONE dot-grid output). Returns the uniform lifecycle handle.
- */
-export declare function useGooDotMatrix(canvasRef: Ref<HTMLCanvasElement | null>, options: UseGooDotMatrixOptions): GooDotMatrixHandle;

package/dist/components/custom/goo-dot-matrix/constants.d.ts

@@ -1,115 +0,0 @@
-import type { OklchStop } from "../../../composables/color";
-import { type BlobConfig } from "../goo-blob";
-/** The four render registers — the §T4 `variant` axis (default `dot-field`). */
-export type GooDotVariant = "dot-field" | "dot-dither" | "dot-lattice" | "dot-sphere";
-/** Pointer interaction mode — repel pushes dots off the field, attract pulls them in. */
-export type GooDotPointerMode = "repel" | "attract";
-/** The warm ground modes — `"warm"` paints a living warm-amber gradient pass-1 BEHIND the
- * dots in the SAME GL context (the §3 colourful ground, an opaque field to read over);
- * `"transparent"` skips the ground pass (the library composable default — the dots ride the
- * consumer's own host, e.g. the global `[data-paper-field]` backdrop). */
-export type GooDotFieldGround = "warm" | "transparent";
-/**
- * Compile-time dot-stamp cell cap (px) — the device-px cell SIZE the fragment quantizes the
- * grid to; mirrors the §T1 `uDotPixelSize` band (a floor so a tiny cell never hangs the
- * fragment over a huge grid). Register-A only.
- */
-export declare const MIN_DOT_PIXEL_SIZE = 4;
-/**
- * The full author schema — the studio's `useConfiguratorState` model. The FIELD atoms are
- * REUSED from the goo-blob `BlobConfig` (the metaball field is the byte-untouched goo half),
- * and the DOT-RENDER atoms are ADDED (the §T1/§T2/§T3 dot-grid output). A NEW schema (no
- * prior `goo-dot-matrix`, no MIGRATION row).
- */
-export interface GooDotConfig {
-    /** Which render register — `dot-field` (default) | `dot-dither` | `dot-lattice` | `dot-sphere`. */
-    variant: GooDotVariant;
-    /**
-     * The metaball FIELD config — the byte-untouched goo-blob field atoms (geometry, the
-     * smin membrane, the satellites, the warm-cream palette). The hybrid READS the field
-     * `sceneDistG`/`thickness` off this; it does not rebuild the math.
-     */
-    field: BlobConfig;
-    /**
-     * The dot-grid CELL size in device px (Register A — §T1 `uDotPixelSize`). Larger cells →
-     * coarser dots. Floored at `MIN_DOT_PIXEL_SIZE` so the fragment never over-grids.
-     */
-    dotPixelSize: number;
-    /** Dot radius MIN (the rim/outside dot, fraction of the cell, §T1 `uDotMin`). */
-    dotMin: number;
-    /** Dot radius MAX (the core dot, fraction of the cell, §T1 `uDotMax`). */
-    dotMax: number;
-    /** The field floor at which the meniscus rise begins (§T1 `uFieldFloor`). */
-    fieldFloor: number;
-    /** The dim-outside brightness floor (the dots dim at the rim, §T1 `uDotBrightFloor`). */
-    dotBrightFloor: number;
-    /**
-     * The φ-banded PRESENCE FLOOR (BD.W-GOODOT-LIQUID-FIELD Move 1, `uPresenceFloor`). The
-     * base-lattice opacity the field NEVER drops below — the dot is always present and the
-     * metaball MODULATES it (it never gates it). At `0` the read is byte-identical to the old
-     * `step()` discard (the calm escape hatch); the default fills the card corner-to-corner.
-     */
-    presenceFloor: number;
-    /**
-     * The NECK-RIDGE swell (Move 2, `uWeldSwell`). At a weld (the shallow-gradient membrane
-     * where two bodies meet) the dot radius swells by `1 + weldSwell·weld`. Pinned so the
-     * swelled rim dot stays a sub-cell ROUND circle (`dotMax·(1+weldSwell) < 1`), never a
-     * clipped square (the √φ cell-clip ceiling).
-     */
-    weldSwell: number;
-    /**
-     * The NECK-RIDGE specular (Move 2, `uWeldSpecular`). A MULTIPLICATIVE HDR brightness pop on
-     * the weld dots (`bright *= 1 + weldSpecular·weld`) — it can exceed the core ceiling so the
-     * waist is the BRIGHTEST band in the field a beat before the bodies fuse.
-     */
-    weldSpecular: number;
-    /**
-     * The liquid-lattice flow (Move 4b, `uFlowAmt`). The cell sample advects down the field
-     * gradient toward the forming core (`sampleUv -= normalize(scene.yz)·flowAmt·core`) so the
-     * lattice migrates INTO the goo rather than sitting screen-locked. A real net-new lane.
-     */
-    flowAmt: number;
-    /** The dot-color ramp (resolved via the ColorResolver; default warm technicolor). */
-    palette: OklchStop[];
-    /** The ground color (default transparent so the glass card / paper-field shows through). */
-    background: OklchStop | "transparent";
-    /**
-     * The §3 warm GROUND pass (Move 4a, `fieldGround`). `"warm"` draws a living warm-amber
-     * gradient pass-1 behind the dots in the SAME context (an opaque field to read over, the
-     * cartoon shadow's casting surface); `"transparent"` skips it (the library composable
-     * default — the dots ride the consumer's own host).
-     */
-    fieldGround: GooDotFieldGround;
-    /** Pointer parallax + repel + accel-burst (the §T7 dot-cursor influence). */
-    interactive: boolean;
-    /** repel ↔ attract (the dot-influence direction). */
-    pointerMode: GooDotPointerMode;
-    /** The pointer influence radius (NDC; the §T7 `pointerRadius`). */
-    pointerRadius: number;
-    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
-    respectReducedMotion: boolean;
-}
-/**
- * The warm TECHNICOLOR identity palette (the library default — warm-fire/amber/gold, NEVER
- * teal/cyan). A 3-stop liquid ramp the read maps CORE→NECK→RIM (the `tone = 1 - fCell` sample,
- * so stop[0] is the deep CORE, stop[2] the base-lattice RIM):
- *
- *   CORE — hot butter-gold (`fCell→1`, the bright cream membrane at the body core),
- *   NECK — molten coral (the weld climax, the fattest+brightest dots at the merge waist),
- *   RIM  — deep amber (`fCell≈floor`, the resting base lattice — it carries chroma, never gray).
- *
- * BD.W-GOODOT-LIQUID-FIELD Move 3 — the near-mono cream-on-cream identity (ΔL 0.08 ΔC 0.04,
- * invisible separation) re-graded to real chroma (C_core ≥ 0.13, the no-gray warm floor cleared
- * with room). A consumer themes it mono-warm-white-on-near-black through a PRESET, never a token
- * edit (presets-in-consumers — the library identity sharpens as a token evolution).
- */
-export declare const WARM_IDENTITY_PALETTE: OklchStop[];
-/**
- * The shipped warm-identity default — the §T6 default table: the Register-A field-driven dot
- * stamp over the byte-untouched goo-blob field (the cream metaball), warm technicolor dots that
- * FILL the card corner-to-corner (the presence floor), the weld a ridge of the fattest+brightest
- * coral dots, over a transparent ground (the composable default — the dots ride the consumer's
- * own host). The demo turns the warm ground ON; the near-dark reference is a DEMO preset
- * (presets-in-consumers).
- */
-export declare const DEFAULT_GOO_DOT_CONFIG: GooDotConfig;

package/dist/components/custom/goo-dot-matrix/index.d.ts

@@ -1,5 +0,0 @@
-export { default as GooDotMatrix } from "./GooDotMatrix.vue";
-export { useGooDotMatrix, type GooDotMatrixHandle, type UseGooDotMatrixOptions, } from "./composables/useGooDotMatrix";
-export { type GooDotConfig, type GooDotVariant, type GooDotPointerMode, type GooDotFieldGround, DEFAULT_GOO_DOT_CONFIG, WARM_IDENTITY_PALETTE, MIN_DOT_PIXEL_SIZE, } from "./constants";
-export { gridOrigin, latticeInstanceCount, fibonacciDot, type Vec2, type Vec3, } from "./composables/gooDotLattice";
-export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/goo-dot-matrix/shaders/goo-dot.frag.d.ts

@@ -1,13 +0,0 @@
-/** The spliced goo-blob field GLSL (decls + sceneDistG/breath/samplePaletteOklch). */
-export declare const GOO_DOT_FIELD_GLSL: string;
-/**
- * The full-quad vertex shader — the BYTE-IDENTICAL metaball.vert convention (the `aPosition`
- * attrib name + `vUv = aPosition·0.5+0.5`), so the goo-blob `uploadBlobUniforms` draw path
- * (the SHARED field upload — `gl.drawArrays(TRIANGLES, 0, 6)` over the `aPosition` quad) is
- * REUSED wholesale for the field lanes; the dot-grid uniforms are set beside it.
- */
-export declare const GOO_DOT_VERT_GLSL = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition * 0.5 + 0.5;\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}";
-/** The Register-A dot-stamp fragment — the GLSL twin of the WGSL `fs_main`. */
-export declare const GOO_DOT_FRAG_GLSL: string;
-export declare const GOO_DOT_GROUND_VERT_GLSL = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition * 0.5 + 0.5;\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}";
-export declare const GOO_DOT_GROUND_FRAG_GLSL = "#version 300 es\nprecision highp float;\nin vec2 vUv;\nout vec4 fragColor;\nuniform float uGroundTime;\nvoid main() {\n  float d1 = 0.5 + 0.5 * sin(uGroundTime * 0.11 + vUv.x * 2.1);\n  float d2 = 0.5 + 0.5 * sin(uGroundTime * 0.07 - vUv.y * 1.7 + 1.3);\n  vec3 amber = vec3(0.99, 0.86, 0.62);\n  vec3 coral = vec3(0.95, 0.62, 0.42);\n  vec3 deep  = vec3(0.86, 0.50, 0.30);\n  vec3 g = mix(deep, coral, d1);\n  vec3 rgb = mix(g, amber, d2 * (1.0 - vUv.y) * 0.8);\n  fragColor = vec4(rgb, 1.0);\n}";

package/dist/components/custom/goo-dot-matrix/shaders/goo-dot.wgsl.d.ts

@@ -1,4 +0,0 @@
-/** The spliced goo-blob field (struct + bindings + sceneDistG/breath/samplePaletteOklch). */
-export declare const GOO_DOT_FIELD_WGSL: string;
-export declare const GOO_DOT_WGSL: string;
-export declare const GOO_DOT_GROUND_WGSL = "\nstruct GroundUniforms {\n  // g0: (uGroundTime, uGroundAspect, _pad, _pad)\n  g0: vec4<f32>,\n};\n@group(0) @binding(0) var<uniform> gu: GroundUniforms;\n\nstruct GVSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\n@vertex\nfn vs_main(@builtin(vertex_index) vi: u32) -> GVSOut {\n  var p = vec2<f32>(-1.0, -1.0);\n  if (vi == 1u) { p = vec2<f32>(3.0, -1.0); }\n  else if (vi == 2u) { p = vec2<f32>(-1.0, 3.0); }\n  var out: GVSOut;\n  out.pos = vec4<f32>(p, 0.0, 1.0);\n  out.uv = p * 0.5 + 0.5;\n  return out;\n}\n\n@fragment\nfn fs_main(in: GVSOut) -> @location(0) vec4<f32> {\n  let t   = gu.g0.x;\n  let uv  = in.uv;\n  // Two slow warm drifts \u2014 the centroid moves so the ground is LIVING (G3c).\n  let d1  = 0.5 + 0.5 * sin(t * 0.11 + uv.x * 2.1);\n  let d2  = 0.5 + 0.5 * sin(t * 0.07 - uv.y * 1.7 + 1.3);\n  let amber = vec3<f32>(0.99, 0.86, 0.62);   // warm gold high\n  let coral = vec3<f32>(0.95, 0.62, 0.42);   // molten coral mid\n  let deep  = vec3<f32>(0.86, 0.50, 0.30);   // deep amber low\n  let g     = mix(deep, coral, d1);\n  let rgb   = mix(g, amber, d2 * (1.0 - uv.y) * 0.8);\n  return vec4<f32>(rgb, 1.0);\n}";

package/dist/components/custom/handmark/composables/useHandMark.d.ts

@@ -1,89 +0,0 @@
-/**
- * useHandMark.ts — the headless reactive core (L2/L3/L4; SPEC §9).
- * ─────────────────────────────────────────────────────────────────────────────
- * Sits between the props and the SFC template so a future React/web-component skin
- * reuses L1–L4. It orchestrates: resolve brush → shapeGeom → ink → animation. It
- * owns NO DOM (the SFC anchors/measures/mounts the filter); it owns the reactive
- * pipeline + the draw-on / boil state machine.
- *
- * Two draw-on mechanisms, picked by a FIELD (never an instrument `if`):
- *   - clean ink (no grain): `stroke-dashoffset` on `pathLength="1"` — the slides
- *     recipe, geometry-agnostic, compositor-cheap, no filter to re-raster.
- *   - grained ink (crayon): a `clip-path: inset()` WIPE — the filter rasters ONCE
- *     and the reveal mutates only the clip (`ds-crayon-handmark §5.1`). NEVER
- *     dashoffset under a filter (it would re-raster the graph per frame — the Δ4
- *     gate).
- *
- * PRM: every draw-on collapses to instant (finished static state); boil no-ops
- * (`useLineBoil.start()` early-returns under reduced motion).
- */
-import { type Ref } from "vue";
-import { type Brush, type BrushName } from "../brush";
-/**
- * The boil clock surface the SFC binds — the `useLineBoil` return shape, declared
- * structurally over glass-ui's OWN `Ref` (pencil-boil ships a nested `@vue`, so its
- * `Ref` symbol differs; the no-op stub is built with this `ref`, hence the surface
- * is named here rather than `ReturnType<typeof useLineBoil>`).
- */
-export interface BoilClock {
-    currentFrame: Ref<number>;
-    start: () => void;
-    stop: () => void;
-}
-import { type ShapeGeom } from "../geometry";
-import { type SVGFragment } from "../ink";
-import type { HandAnimation, HandMarkProps, HandShape, MarkBox } from "../types";
-export interface UseHandMarkInput {
-    brush: BrushName | Partial<Brush>;
-    shape: HandShape;
-    color: string;
-    seed: number;
-    overrides?: Partial<Brush>;
-    animation: HandAnimation;
-    boilFps: number;
-    boilFrames: number;
-    roughness: number | null;
-    segments: number | null;
-    jagged: boolean;
-    /** NATURAL underline morphology (C-2) — procedural off the house-seeded engine. */
-    natural: boolean;
-    box: MarkBox | null;
-    path: string | null;
-    filterId: string;
-    /**
-     * The MEASURED text baseline as a fraction of the `.hm` box height (text-mode
-     * underline anchor). `null` until the SFC measures it (ResizeObserver +
-     * `document.fonts.ready`) — geometry falls back to the legacy constant for that
-     * one pre-measure frame. Ignored in positioned (`box`) mode.
-     */
-    baselineFrac: number | null;
-}
-/**
- * Normalise raw HandMarkProps (with their defaults applied) into the core input.
- * `baselineFrac` is the SFC's MEASURED text baseline (text-mode underline anchor) —
- * passed in (not a prop) because it is a runtime measurement, `null` until measured.
- */
-export declare function normalizeProps(props: HandMarkProps, filterId: string, baselineFrac?: number | null): UseHandMarkInput;
-export interface HandMarkCore {
-    /** the resolved effective brush vector. */
-    brush: Ref<Brush>;
-    /** the static base geometry (boil re-perturbs THIS). */
-    baseGeom: Ref<ShapeGeom>;
-    /** the live SVG fragment (paths + filter defs). */
-    fragment: Ref<SVGFragment>;
-    /** the live `d` (escape-hatch path > boiled geometry > static base). */
-    pathD: Ref<string>;
-    /** does the brush emit a grain filter? (drives the draw-on mechanism). */
-    grained: Ref<boolean>;
-    /** the draw-on mechanism for this mark: dashoffset (pen) | clip (crayon). */
-    drawKind: Ref<"dashoffset" | "clip">;
-    /** does this animation draw on at all? */
-    draws: Ref<boolean>;
-    /** does this animation boil? */
-    boils: Ref<boolean>;
-    /** the boil clock (a real `useLineBoil` only when the mark boils; else a no-op stub). */
-    boil: BoilClock;
-    /** arm/disarm boil (draw-then-boil holds it until the draw finishes). */
-    boilArmed: Ref<boolean>;
-}
-export declare function useHandMark(input: Ref<UseHandMarkInput>): HandMarkCore;

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

@@ -1,59 +0,0 @@
-/**
- * constants.ts — the marking-space geometry constants (the colocation home).
- * ─────────────────────────────────────────────────────────────────────────────
- * The hand-mark family's named geometry constants live here (the AY.W-COLOCATE
- * convention's `constants.ts` home). geometry.ts + the SFC re-read them by name.
- */
-/** Marking-space width (the 0..100 × 0..40 viewBox; `preserveAspectRatio="none"`). */
-export declare const VB_W = 100;
-/** Marking-space height. */
-export declare const VB_H = 40;
-/**
- * The hairline gap, as a fraction of the `.hm` box, between the MEASURED text
- * baseline and the underline centerline. The underline rides just under the real
- * glyph bottoms — a hand mark sits a few % of cap-height below the baseline, never
- * through it (the E1 occlusion root: a constant `y=32` strikethroughs tight-leading
- * display type because 80% of a `line-height:1.02` box IS the baseline).
- */
-export declare const UNDERLINE_GAP = 0.06;
-/**
- * The highlighter LOW-SEAT band (BA.W-HANDMARK C-1(a)). A real highlighter rides
- * the low two-thirds of the line — the ink sits on the baseline and rises to
- * ~x-height — NOT the box vertical center the fork shipped. The band centerline
- * seats at `baselineFrac − HIGHLIGHT_RISE` (raised off the baseline by ~half a
- * lowercase x-height) so the wide slab (weight 26) covers x-height down to the
- * baseline. Expressed as a fraction of the `.hm` box, parallel to UNDERLINE_GAP.
- */
-export declare const HIGHLIGHT_RISE = 0.22;
-/** Pre-measure fallback for the highlight band's low seat (null baselineFrac). */
-export declare const HIGHLIGHT_FALLBACK_FRAC = 0.66;
-/**
- * The boil voice — φ-incommensurate fractal value-noise (the masthead morphology).
- * ─────────────────────────────────────────────────────────────────────────────
- * The boil centerline is a 1-D fractal value-noise displacement off the HOUSE
- * `mulberry32`, NOT a seeded sinusoid. A sinusoid (the prior body) self-correlates
- * into a near-period — it reads as a spell-check squiggle and a clean sine fails any
- * honest non-periodicity discriminator (a sine's extrema are near-uniformly spaced).
- * The value-noise sums octaves at φ-stepped frequencies (mutually irrational → the
- * sum NEVER closes into a period); each octave's amplitude decays by 1/φ. The result
- * is a hump-to-hump-IRREGULAR hand line whose inter-extremum spacing-CV is the honest
- * teeth (measured: ~0.41 at the paint's segment count, ~0.71 resampled at RES=64,
- * over 400 seeds — vs the prior sinusoid's ~0.14; a clean separation either side of a
- * 0.30 floor). The amplitude is SCALE-RELATIVE (a fraction of the rendered span), so
- * a long word and a short word wobble in proportion. FILTER-FREE — the wander lives
- * in the control points + the hull width, never a feTurbulence.
- *
- * Constants pinned against a 400-seed spacing-CV spike (NOT the seed-overfit autocorr
- * peak the prior gate keyed — autocorr cannot separate smooth low-frequency value-
- * noise from a sinusoid at any resolution).
- */
-/** φ — the per-octave frequency step (mutually irrational → never periodic). */
-export declare const NOISE_PHI = 1.618033988749895;
-/** octave count of the fractal value-noise sum. */
-export declare const NOISE_OCTAVES = 4;
-/** base octave frequency (humps across the unit span); octave k rides F0·φ^k. */
-export declare const NOISE_F0 = 2.5;
-/** displacement amplitude as a fraction of the rendered span (scale-relative). */
-export declare const NOISE_AMP_FRAC = 0.05;
-/** endpoint-only cosine taper width (the ends settle to baseline; the BODY stays irregular). */
-export declare const NOISE_EDGE = 0.12;

package/dist/components/custom/handmark/geometry.d.ts

@@ -1,85 +0,0 @@
-/**
- * geometry.ts — SEMANTIC shape → pencil-boil centerlines (L1, pure; SPEC §3).
- * ─────────────────────────────────────────────────────────────────────────────
- * A shape is a pure mapper: (semantic target) → L1 geometry. The renderer never
- * knows what it drew — it sees only `Point[]`. Adding a shape = adding one switch
- * arm; nothing downstream changes (texture + animation are shape-blind). This is
- * the generality lever (Brush ⟂ Path).
- *
- * The marking coordinate space is 0..100 × 0..40, with `preserveAspectRatio="none"`
- * so the <svg> stretches to the slotted word box (the SPEC §6.2 width-invariance
- * contract). Two usage modes:
- *   - text mode (box == null): use the full viewBox (single-line underline/strike)
- *   - positioned mode (box = {x,y,w,h}): map an explicit rect (circle a datum)
- *
- * The circle arm rides pencil-boil 0.4.x's `ellipsePoints` (the hand-circle
- * overshoot ring — the sole upstream geometry delta this component required).
- *
- * THE SEED RECONCILE (BA.W-HANDMARK [S2]): the wobble centerlines are seeded from
- * the HOUSE prng leaf (`src/utils/prng.ts` mulberry32 + hashString — the AV.W14
- * single-source). The family FEEDS pencil-boil a house-derived integer seed; glass-
- * ui code imports ZERO `mulberry32` from pencil-boil (its internal mulberry32 stays
- * inside its OWN perturb math). ONE seed leaf, the house identity.
- */
-import { type WobbleOptions } from "@mkbabb/pencil-boil";
-import { UNDERLINE_GAP, VB_H, VB_W } from "./constants";
-import type { HandShape, MarkBox } from "./types";
-export { VB_W, VB_H, UNDERLINE_GAP };
-/** A shape maps to one or more centerlines (open polylines) or one closed ring. */
-export interface ShapeGeom {
-    lines: [number, number][][];
-    closed: boolean;
-}
-/**
- * The boil voice — φ-incommensurate fractal value-noise (RE-INVENT; the masthead
- * morphology). A 1-D fractal value-noise DISPLACEMENT off the HOUSE `mulberry32`,
- * NOT a seeded sinusoid (the prior body self-correlated into a near-period — a spell-
- * check squiggle):
- *
- *   disp(t) = Σ_{k=0..OCT-1} aₖ · vnoiseₖ(t·fₖ + φₖ)   normalised by Σaₖ
- *     fₖ = NOISE_F0 · φ^k   (φ mutually-irrational steps → the sum NEVER closes
- *                            into a period — the non-periodicity mechanism)
- *     aₖ = (1/φ)^k          (per-octave decay)
- *     φₖ = seeded per-octave phase (house mulberry32)
- *     vnoiseₖ = seeded lattice value-noise, smootherstep-faired
- *
- * The four atlas axes:
- *   - amplitude SCALES with the rendered span (`(x2−x1) × NOISE_AMP_FRAC`), not a
- *     viewBox-stretched constant (a long word and a short word wobble in proportion);
- *   - the hump-to-hump spacing is IRREGULAR (the φ-incommensurate octave sum — the
- *     honest non-periodicity teeth, spacing-CV ~0.41 at the paint count vs the prior
- *     sinusoid's ~0.14, over 400 seeds);
- *   - the non-uniform body gives the pf hull a pressure-taper-friendly point stream;
- *   - the seed is the HOUSE mulberry32 (determinism + per-seed variation), ZERO
- *     pencil-boil `mulberry32` import.
- *
- * ENDPOINT anchor (NOT a body-wide envelope): a narrow cosine taper at the very ends
- * only (`NOISE_EDGE`), so the ends settle to baseline (no draw-on pop) while the BODY
- * amplitude stays irregular hump-to-hump (the prior `sin(π·t)` envelope made the body
- * amplitude smooth-and-uniform — the clean-envelope tell). FILTER-FREE: the wander is
- * in the control points + the hull width, never a feTurbulence.
- *
- * EXPORTED so the measuring gate samples the REAL emitted point-set (never a symbol-
- * presence regex — the W-GATE-TRUTH-AUDIT discipline).
- */
-export declare function naturalUnderlinePoints(x1: number, y: number, x2: number, seed: number, segments: number): [number, number][];
-/**
- * Semantic shape → { lines, closed } in the marking space (or a positioned box).
- *
- * The text-mode underline anchors to a MEASURED baseline: `baselineFrac` is the
- * slotted word's alphabetic baseline as a fraction of the `.hm` box height (the SFC
- * measures it via ResizeObserver + `document.fonts.ready`). The underline y is then
- * `VB_H × (baselineFrac + UNDERLINE_GAP)` — never the old hardcoded `32` (80% of the
- * box), which struck through tight-leading headings. `null` ⇒ not yet measured: fall
- * back to the legacy `VB_H − 8` constant so first paint (and jsdom/SSR) still renders
- * a line, replaced the instant the measure lands.
- *
- * `natural` routes the underline through the φ-incommensurate value-noise
- * `naturalUnderlinePoints` morphology instead of pencil-boil's `wobbleLinePoints`
- * (the masthead `boil` voice); the default underline keeps the pencil-boil line.
- */
-export declare function shapeGeom(shape: HandShape, opts: WobbleOptions, box?: MarkBox | null, baselineFrac?: number | null, natural?: boolean): ShapeGeom;
-/** Boil one geometry: re-perturb the CACHED centerlines (anchored → no draw-on pop). */
-export declare function boilLines({ lines, closed }: ShapeGeom, amount: number, seed: number): [number, number][][];
-/** Serialize centerlines → one SVG `d` (multi-line shapes concat with a space). */
-export declare function serialize(lines: [number, number][][], jagged?: boolean): string;