@mkbabb/glass-ui 4.0.1 → 4.2.0

package/dist/components/custom/goo-filter/GooFilter.vue.d.ts

@@ -0,0 +1,22 @@
+interface GooSpec {
+    /** The filter id consumers reference (`url(#<id>)`). */
+    id: string;
+    /** feGaussianBlur stdDeviation — the alpha-bleed radius (per-scale). */
+    blur: number;
+    /** feColorMatrix A-channel slope — the threshold steepness (the gooey shoulder). */
+    slope: number;
+    /** feColorMatrix A-channel offset (negative) — the alpha cut point. */
+    offset: number;
+}
+type __VLS_Props = {
+    /**
+     * Extra bespoke `<filter>` instances beyond the library register (a consumer
+     * tuning a one-off scale). Each is the SAME graph at its own knobs.
+     */
+    extra?: GooSpec[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    extra: GooSpec[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/custom/goo-filter/index.d.ts

@@ -0,0 +1 @@
+export { default as GooFilter } from "./GooFilter.vue";

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

@@ -10,13 +10,13 @@
  * Field-count discipline (SPEC §2): resist a 13th scalar per new instrument —
  * `blend` earned its place only because highlighter genuinely needed `multiply`.
  *
- * The shipped register: PEN is the default (clean ink, grain:0 ⇒ no filter); the
- * CRAYON ships as the proven STROKE-crayon (constant-width offset passes + the
- * seeded static feTurbulence grain — `ds-crayon-handmark` verdict), i.e.
- * `ribbon:'stroke'`. The HIGHLIGHTER (BA.W-HANDMARK C-1) ENGAGES `ribbon:'hull'`
- * — the perfect-freehand variable-width slab the atlas's field delta names — so the
- * vendored pf body ships whenever the highlighter does (the budget note in the cut
- * + a `profile:budget` rebaseline).
+ * The shipped register: PEN is the default (clean ink, grain:0 ⇒ no filter, the one
+ * `ribbon:'stroke'` clean voice). The variable-width VOICES — boil (the pressured
+ * pen-line), crayon (the waxy swell), marker (the juicy core), highlighter (the wide
+ * slab) — all ENGAGE `ribbon:'hull'`, the vendored perfect-freehand body, sharing the
+ * one curvature-coupled pressure profile (ink.ts `addPressure`). pen/pencil/ring stay
+ * `ribbon:'stroke'` by intent (pen clean, pencil's dry tooth-grain is its character,
+ * ring a thin whisper). The pf body ships whenever any hull brush does.
  */
 export type BlendMode = "source-over" | "multiply" | "darken" | "screen";
 export interface TaperSpec {
@@ -88,9 +88,9 @@ export interface InkPath {
     cap?: "round" | "square" | "butt";
 }
 /**
- * The named points in the continuum. `pen` is the DEFAULT (clean ink, grain:0).
- * `crayon` is the SHIPPED stroke-crayon (ribbon:'stroke', the static grain filter);
- * `pencil`/`marker`/`highlighter` round out the spanning set.
+ * The named points in the continuum. `pen` is the DEFAULT (clean ink, grain:0,
+ * `ribbon:'stroke'`). `boil`/`crayon`/`marker`/`highlighter` engage `ribbon:'hull'`
+ * (the curvature-coupled variable-width body); `pencil`/`ring` stay clean stroke.
  */
 export declare const BRUSHES: {
     readonly pen: {
@@ -117,15 +117,15 @@ export declare const BRUSHES: {
         readonly cap: "round";
     };
     readonly boil: {
-        readonly weight: 5;
+        readonly weight: 7;
         readonly weightJitter: 0.12;
-        readonly thinning: 0.2;
+        readonly thinning: 0.55;
         readonly taper: {
-            readonly start: 12;
-            readonly end: 12;
+            readonly start: 14;
+            readonly end: 18;
             readonly ease: "out-cubic";
         };
-        readonly ribbon: "stroke";
+        readonly ribbon: "hull";
         readonly opacity: 1;
         readonly blend: "source-over";
         readonly passes: 1;
@@ -171,7 +171,7 @@ export declare const BRUSHES: {
             readonly end: 6;
             readonly ease: "linear";
         };
-        readonly ribbon: "stroke";
+        readonly ribbon: "hull";
         readonly opacity: 0.8;
         readonly blend: "source-over";
         readonly passes: 2;
@@ -217,7 +217,7 @@ export declare const BRUSHES: {
             readonly end: 10;
             readonly ease: "out-cubic";
         };
-        readonly ribbon: "stroke";
+        readonly ribbon: "hull";
         readonly opacity: 0.92;
         readonly blend: "source-over";
         readonly passes: 1;

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

@@ -28,12 +28,32 @@ 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;
 /**
- * Natural-underline morphology (BA.W-HANDMARK C-2). The procedural wobble is
- * SCALE-RELATIVE: the amplitude is a fraction of the rendered word width (a long
- * word and a short word wobble in proportion, not the viewBox-stretched-constant
- * the fork's GlassUnderline shipped). The period count is IRREGULAR — a seeded
- * pick in [PERIODS_MIN, PERIODS_MAX] — so two seeds differ in hump count, never
- * identical twins.
+ * 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).
  */
-export declare const PERIODS_MIN = 2;
-export declare const PERIODS_MAX = 4;
+/** φ — 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

@@ -30,6 +30,39 @@ 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).
  *
@@ -41,7 +74,7 @@ export interface ShapeGeom {
  * 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` (BA.W-HANDMARK C-2) routes the underline through the procedural
+ * `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.
  */

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

@@ -19,7 +19,7 @@
  */
 export { default as HandMark, default as InkMark } from "./HandMark.vue";
 export { BRUSHES, resolveBrush, lerpBrush, type Brush, type BrushName, type BlendMode, type TaperSpec, type StampFn, type InkPath, } from "./brush";
-export { shapeGeom, serialize, boilLines, VB_W, VB_H, UNDERLINE_GAP, type ShapeGeom, } from "./geometry";
+export { shapeGeom, serialize, boilLines, naturalUnderlinePoints, VB_W, VB_H, UNDERLINE_GAP, type ShapeGeom, } from "./geometry";
 export { ink, type SVGFragment } from "./ink";
 export { grainFilter, hasGrain } from "./texture";
 export { getStroke, getStrokePoints, getSvgPathFromStroke, type StrokeOptions, type InputPoint, } from "./freehand";

package/dist/components/custom/icon-chip/types.d.ts

@@ -71,6 +71,16 @@ export interface IconChipProps {
      * untouched. Default `false` (byte-identical to the reference register).
      */
     saturated?: boolean;
+    /**
+     * The QUIET glass register (BD.W-GLASS-ATOM-REGISTER cross-link). The DEFAULT
+     * chip keeps its loud `in srgb` brand-overlay plate (AW.W26 fence); this opt-in
+     * routes the chip through the shared `.glass-atom` warm-glass capsule instead —
+     * a transmissive lozenge with the warm floor + the `--glass-blur-quiet` backdrop
+     * + the keyed rim, tinted by `--glass-fill-tint` toward the event hue. Two
+     * registers, exactly like Badge: loud brand pop (default) vs quiet glass lens
+     * (opt-in). Default `false`.
+     */
+    glass?: boolean;
     /**
      * Entrance choreography — composes the shipped `vReveal` directive. A numeric
      * value is the `--d` stagger index; `true` is index 0. PRM-gated by `vReveal`'s

package/dist/components/custom/labeled-field/LabeledField.vue.d.ts

@@ -67,16 +67,35 @@ type __VLS_Props = {
      * (often raw-config-key) label. Default `false` (standalone behavior).
      */
     hideLabel?: boolean;
+    /**
+     * BC.W-CONTROL-SMOOTH move C (kf-G3) — lay the field on the HORIZONTAL axis
+     * (label beside control, not above) for dense inline forms. ADDITIVE +
+     * default `false`: a bare `<LabeledField>` is byte-identical to HEAD (the
+     * stacked label-over-control layout). Pairs with the `#action` slot — a
+     * horizontal labeled control carrying a trailing action affordance is the
+     * REQ-sec20 horizontal-action case the kf-G3 row booked.
+     */
+    horizontal?: boolean;
 };
 declare var __VLS_7: {
     errorId: string;
     controlId: string;
     labelledBy: string;
-}, __VLS_9: {};
+}, __VLS_9: {
+    controlId: string;
+}, __VLS_11: {
+    errorId: string;
+    controlId: string;
+    labelledBy: string;
+}, __VLS_13: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_7) => any;
 } & {
-    error?: (props: typeof __VLS_9) => any;
+    action?: (props: typeof __VLS_9) => any;
+} & {
+    default?: (props: typeof __VLS_11) => any;
+} & {
+    error?: (props: typeof __VLS_13) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/custom/metric-stack/MetricRow.vue.d.ts

@@ -72,6 +72,20 @@ export interface MetricRowProps {
      * this to their active-row gating (e.g. the metric being sampled).
      */
     active?: boolean;
+    /**
+     * BC.W-CONTROL-CUSTOM (CP1, the speedtest-AX `data-protagonist` fold) —
+     * marks this row as the ONE focal/protagonist metric per surface. When
+     * `true`, the value lifts to the emphasis register (the heavier
+     * `--metric-row-value-weight-emphasis` rung) and a `data-protagonist`
+     * attribute lands on the row so a consumer can re-tint the focal metric.
+     *
+     * This is the ONE focal emphasis event per surface (the W-SUFFUSE
+     * one-color-event proportion) — exactly one row per <MetricStack> should
+     * be the protagonist. The magnitude stays a `--metric-row-*` token read
+     * with a fallback, so a `:root`/per-row override of the emphasis weight
+     * cascades. A bare (`protagonist`-unset) row is byte-identical.
+     */
+    protagonist?: boolean;
     class?: HTMLAttributes["class"];
 }
 declare var __VLS_1: {}, __VLS_8: {}, __VLS_10: {}, __VLS_12: {}, __VLS_14: {}, __VLS_16: {};
@@ -94,6 +108,7 @@ declare const __VLS_base: import("vue").DefineComponent<MetricRowProps, {}, {},
     iconSize: number;
     digitCount: number;
     colorTinted: boolean;
+    protagonist: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/custom/pager-dots/PagerDots.vue.d.ts

@@ -12,6 +12,14 @@ export interface PagerDotsProps {
     windowFit?: number;
     /** Encapsulate the rail in the glass pager pill chassis. Default true. */
     ring?: boolean;
+    /**
+     * The ARIA register. `"tabs"` (default, byte-identical) is the carousel
+     * panel-nav register (`role="tablist"`/`role="tab"` + `aria-selected`);
+     * `"group"` is the full-viewport deck PRESENTATION register
+     * (`role="group"`/`aria-current`) the `<DeckPager>` selects. ONE windowing
+     * oracle, two aria registers — the `pagerWindow` math is NEVER re-forked.
+     */
+    pattern?: "tabs" | "group";
     /** Accessible name for the rail group. */
     ariaLabel?: string;
     /** Additional classes for the rail root. */
@@ -32,6 +40,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {},
     "onUpdate:active"?: ((value: number) => any) | undefined;
 }>, {
     orientation: "horizontal" | "vertical";
+    pattern: "tabs" | "group";
     ariaLabel: string;
     ring: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/custom/pager-dots/index.d.ts

@@ -1,2 +1,4 @@
 export { default as PagerDots } from "./PagerDots.vue";
 export type { PagerDotsProps } from "./PagerDots.vue";
+export { pagerWindow } from "./pagerWindow";
+export type { PagerWindow } from "./pagerWindow";

package/dist/components/custom/pager-dots/pagerWindow.d.ts

@@ -0,0 +1,9 @@
+export interface PagerWindow {
+    /** The 0-based slide indices to render as dots. */
+    shown: number[];
+    /** The window is clipped at the start (a dimmed leading edge dot). */
+    clippedStart: boolean;
+    /** The window is clipped at the end (a dimmed trailing edge dot). */
+    clippedEnd: boolean;
+}
+export declare function pagerWindow(total: number, activeIndex: number, fit: number): PagerWindow;

package/dist/components/custom/paper-backdrop/PaperBackdrop.vue.d.ts

@@ -13,6 +13,24 @@ export interface PaperBackdropProps {
     opacity?: number | string;
     /** Override turbulence frequency (advisory only — swaps the texture var). */
     frequency?: PaperBackdropFrequency;
+    /**
+     * BD.W-PAGE-FIELD — mount the WARM COLORFUL FIELD plane beneath the grain.
+     * When set, a `.paper-field` cel plane (amber→terracotta→sand at FIELD
+     * lightness, drifting on the compositor) paints UNDER the grain, so every
+     * glass surface over it reads transmissive/warm instead of gray. The grain
+     * rides ON TOP at its multiply opacity — one backdrop, two stacked planes.
+     * Opt-in (presets-in-consumers demo-chassis contract); the library glass
+     * primitive is UNCHANGED.
+     */
+    field?: boolean;
+    /**
+     * The warm route hue request (any degree). The field CLAMPS it to the warm
+     * band [25,95] IN THE CSS, so a cool/teal value cannot paint cool. Wire
+     * `warmFieldHue(category)` here per route.
+     */
+    fieldHue?: number | string;
+    /** The field rung intensity (0.85 ground / 1.0 vivid hero / 0 = neutral). */
+    fieldIntensity?: number | string;
     /** Additional class names. */
     class?: HTMLAttributes["class"];
 }

package/dist/components/custom/paper-grid/PaperGrid.vue.d.ts

@@ -0,0 +1,42 @@
+import type { PaperGridConfig } from "./constants";
+/**
+ * PaperGrid — a liquid AA-grid: evenly-spaced LARGER lines on a slowly breathing
+ * curl-flow sheet.
+ *
+ * A calm engineering-graph-paper grid (evenly-spaced, LARGE cells, a crisp fine rule with
+ * a bolder major rule every 5 cells) drawn on a slowly breathing liquid sheet — adjacent
+ * lines bow and flow TOGETHER as if the grid is ruled on a gently rippling pond, never a
+ * per-line jitter. WebGPU-FIRST: a pure fullscreen fragment pass (the aurora/concentric
+ * shape-class) computes the grid at a curl-warped coordinate per pixel via the Ben Golus
+ * derivative-AA distance function (constant device-pixel-crisp lines, the CSS-blur kill),
+ * the Iñigo Quílez domain warp (the "liquid"), and the Bridson divergence-free curl flow
+ * (WHY it's liquid not noise). It composes `usePaperGrid` → the `createGpuSubstrate` picker
+ * over the ONE canvas lifecycle leaf (offscreen-pause, live-PRM freeze, consumer-owned DPR)
+ * — it never bootstraps its own context.
+ *
+ * The DEFAULT line ink is the warm-cream `--foreground` library identity (resolved live at
+ * mount); the demo themes it through a PRESET (presets-in-consumers — never a library
+ * token). The grid suffuses over the page (transparent ground) — teal-on-navy is gone.
+ */
+type __VLS_Props = {
+    /** The full author schema (the studio's `useConfiguratorState` model). */
+    config?: PaperGridConfig;
+    /**
+     * 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/paper-grid/composables/paperGrid.d.ts

@@ -0,0 +1,105 @@
+/** A 2-vector. */
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+/** The curl central-difference epsilon (matches `flow.glsl.ts` / `flow.wgsl.ts`). */
+export declare const CURL_EPS = 0.012;
+/** A 3-octave scalar fbm potential (the host noise basis the curl operator wraps). */
+export declare function potentialFBM(p: Vec2): number;
+/** The 2D curl of the scalar fbm potential (the JS twin of `curlFBM`). */
+export declare function curlFBM(p: Vec2): Vec2;
+/**
+ * The Ben Golus derivative-AA grid line coverage at `g` (grid space). `targetWidth` is the
+ * desired line half-width in GRID UNITS (the caller passes `lineWidthPx / minorPitchPx` so
+ * the line is N device-pixels wide); `uvDeriv` is the per-axis screen-space derivative of
+ * `g` (in the shaders `length(vec2(dFdx(g), dFdy(g)))`; in JS the caller passes it
+ * analytically so the path is reproducible). Returns line coverage [0..1].
+ *
+ * The Golus pipeline (transcribed by the WGSL/GLSL EXACTLY):
+ *   gridUV   = 1 − |fract(g)·2 − 1|                 (triangle wave: 0 at line, 1 at center)
+ *   drawW    = clamp(targetWidth, uvDeriv, 0.5)
+ *   lineAA   = uvDeriv·1.5
+ *   grid2    = smoothstep(drawW+lineAA, drawW−lineAA, gridUV)
+ *   grid2   *= clamp(targetWidth/drawW, 0, 1)        (preserve thin-line intensity)
+ *   grid2    = mix(grid2, targetWidth, clamp(uvDeriv·2−1, 0, 1))   (Moiré suppression)
+ *   line     = max(grid2.x, grid2.y)
+ */
+export declare function gridCoverage(g: Vec2, targetWidth: number, uvDeriv: Vec2): number;
+/**
+ * The complete paper-grid sample at a domain `uv` (the round-trip anchor). Composes the
+ * warp + the bulge + the two-tier Golus coverage EXACTLY as the WGSL/GLSL `fs_main` does,
+ * returning the premultiplied-alpha (the page reads through the troughs). `uvDeriv` is the
+ * FIXED analytic per-axis derivative (JS has no fragment derivatives); the shaders compute
+ * it from `dpdx`/`dpdy`. Returns `{ line, alpha }` — the line coverage + the global alpha.
+ */
+export interface PaperGridSampleParams {
+    /** The grid scale (view / minorPitch → LARGER cells = smaller scale). */
+    gridScale: number;
+    /** The traveling-wave front direction. */
+    waveDir: Vec2;
+    /** The crest-band spatial frequency. */
+    waveK: number;
+    /** The front speed (ω). */
+    waveOmega: number;
+    /** The crest-band width. */
+    waveSigma: number;
+    /** Max per-cell twist angle at the crest (rad). */
+    twistMax: number;
+    /** Max per-cell shear at the crest. */
+    shearMax: number;
+    /** The spring-eased envelope amplitude (0..1; PRM snaps to 0). */
+    amp: number;
+    /** The cursor in GRID space. */
+    cursor: Vec2;
+    /** The cursor-swirl peak twist (rad). */
+    bulgeStrength: number;
+    bulgeRadius: number;
+    /** +1 repel, −1 attract (signs the swirl). */
+    bulgeMode: number;
+    /** 1 = cursor swirl on. */
+    interactive: number;
+    /** Golus target half-widths in grid units (minor + major). */
+    targetWidth: number;
+    targetWidthMajor: number;
+    /** How many minor cells per major rule. */
+    majorEvery: number;
+    minorAlpha: number;
+    majorAlpha: number;
+    /** The GLOBAL subtlety knob (suffusion → tiny). */
+    fieldAlpha: number;
+    /** The FIXED per-axis derivative (the JS round-trip; shaders use dpdx/dpdy). */
+    uvDeriv: Vec2;
+    /** The filled-FACE opacity (0 → the face evaporates → byte-identical to HEAD). */
+    faceAlpha?: number;
+    /** The slope-shade ∇H Lambert gain. */
+    faceReliefGain?: number;
+    /** The volume-preserving squash (the inset retreats at the crest). */
+    squashK?: number;
+    /** The base inset-square coverage. */
+    baseInset?: number;
+    /** The fixed cel key-light direction. */
+    lightDir?: Vec2;
+}
+/** The face-shade scalars the FACE composite reads (the numeric-parity witness — FOLD B/C/D). */
+export interface PaperGridFace {
+    /** The crest envelope at the pre-twist driver cc (FOLD A). */
+    env: number;
+    /** The sheet height at the driver cc (= env; the named leaf scalar). */
+    h: number;
+    /** The Lambert slope-shade [0,1] against the fixed key-light. */
+    shade: number;
+    /** The squashed inset-square face coverage [0,1]. */
+    faceCov: number;
+    /** The composited face alpha (FOLD D — face·faceAlpha·fieldAlpha, NO h-term). */
+    faceA: number;
+    /** The ramp parameter mix(shade, h) keying the multi-stop warm-divergent ink (FOLD B). */
+    rampT: number;
+}
+export declare function samplePaperGrid(uv: Vec2, t: number, p: PaperGridSampleParams): {
+    line: number;
+    alpha: number;
+    face: PaperGridFace;
+};
+/** The grid scale from the view + minor pitch (LARGER cells = smaller scale). */
+export declare function gridScaleFor(viewExtentPx: number, minorPitchPx: number): number;

package/dist/components/custom/paper-grid/composables/paperGridGLSetup.d.ts

@@ -0,0 +1,18 @@
+import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
+import type { PaperGridConfig } from "../constants";
+import { type Vec2 } from "./paperGrid";
+export interface PaperGridGLSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: PaperGridConfig;
+    getCursor: () => Vec2;
+    /** The spring-eased traveling-wave envelope amplitude (0..1; PRM → 0). */
+    getAmp: () => number;
+    shouldContinue: () => boolean;
+    /**
+     * The per-frame pointer hook — usePaperGrid advances the shared pointer field + derives
+     * the transient cursor here (the no-own-rAF discipline). ZERO own rAF.
+     */
+    onFrame?: (timeSec: number) => void;
+}
+/** Build the `setupGL(gl)` callback the `createGpuSubstrate` WebGL2 path invokes. */
+export declare function createPaperGridGLSetup(deps: PaperGridGLSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

package/dist/components/custom/paper-grid/composables/paperGridWGPUSetup.d.ts

@@ -0,0 +1,21 @@
+import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
+import type { PaperGridConfig } from "../constants";
+import type { Vec2 } from "./paperGrid";
+export interface PaperGridWGPUSetupDeps {
+    canvas: HTMLCanvasElement;
+    config: PaperGridConfig;
+    /** The transient pointer cursor in GRID space — re-read each frame (the cursor swirl). */
+    getCursor: () => Vec2;
+    /** The spring-eased traveling-wave envelope amplitude (0..1; PRM → 0). */
+    getAmp: () => number;
+    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
+    shouldContinue: () => boolean;
+    /**
+     * The per-frame pointer hook — usePaperGrid advances the shared `usePointerVelocityField`
+     * here (the no-own-rAF discipline: the renderer's frame loop FEEDS `tick(delta)`) and
+     * derives the transient cursor. ZERO own rAF.
+     */
+    onFrame?: (timeSec: number) => void;
+}
+/** Build the paper-grid `setupWGPU(device, context, format)` callback. */
+export declare function createPaperGridWGPUSetup(deps: PaperGridWGPUSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

package/dist/components/custom/paper-grid/composables/uniformBridgeWGPU.d.ts

@@ -0,0 +1,16 @@
+import type { PaperGridConfig } from "../constants";
+import type { Vec2 } from "./paperGrid";
+export declare const PAPER_GRID_UNIFORM_BYTES = 224;
+export interface PaperGridUniformScratch {
+    buffer: ArrayBuffer;
+    f32: Float32Array;
+}
+export declare function createPaperGridScratch(): PaperGridUniformScratch;
+/**
+ * Pack the paper-grid uniforms in place. `viewExtentPx` is the canvas backing-store extent
+ * the grid scale derives from (so the cell pitch is honest in device px); `cursor` is the
+ * transient pointer in GRID space (the renderer derives it from `usePointerVelocityField`);
+ * `aspect` corrects the domain x. The line ink resolves the warm `--foreground` identity
+ * (the demo themes it via a preset, never a token edit).
+ */
+export declare function packPaperGridUniforms(scratch: PaperGridUniformScratch, config: PaperGridConfig, timeSec: number, aspect: number, viewExtentPx: number, cursor: Vec2, amp: number): PaperGridUniformScratch;

package/dist/components/custom/paper-grid/composables/usePaperGrid.d.ts

@@ -0,0 +1,31 @@
+import { type Ref } from "vue";
+import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
+import type { PaperGridConfig } from "../constants";
+export interface UsePaperGridOptions {
+    config: PaperGridConfig;
+    /** `"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 PaperGridHandle {
+    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 GLSL 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 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 paper-grid renderer on `canvasRef`. The WebGPU primary + the WebGL2 fallback are
+ * BOTH pure fullscreen fragment passes evaluating the SAME liquid grid (the ONE math source
+ * `paperGrid.ts`), so the picker is the only seam. Returns the uniform lifecycle handle.
+ */
+export declare function usePaperGrid(canvasRef: Ref<HTMLCanvasElement | null>, options: UsePaperGridOptions): PaperGridHandle;