@mkbabb/glass-ui 4.1.0 → 5.0.0

package/dist/components/custom/aurora/composables/atoms.d.ts

@@ -1,142 +0,0 @@
-/**
- * AX.W10 — the aurora "atoms of control" door: the ONE consumer-facing surface
- * over the ~28-field author schema. `AuroraConfig` is the INTERNAL author schema
- * (the full escape hatch a preset author types against); `resolveAtoms` is the
- * SIMPLIFIED door the live config UI + every consumer drives.
- *
- * The atoms are the user's named control elements (§2.7) — COLOR, ZONES, NOISE,
- * MEDIUM(+texture), MOTION — ≤7 intuitive knobs, each normalized and total
- * (Burley's "Principled" 5-rule discipline: intuitive, few, normalized, robust for
- * EVERY combination). Each atom maps to a co-varying cluster of config fields so one
- * knob moves the entangled axes together (a single COLOR-energy knob co-varies
- * saturation + valueVariance + breath + the warm/cool temperature, because moving any
- * one alone reads as a defect).
- *
- * Contract (machine-asserted by proof:aurora-atoms-roundtrip):
- *   - TOTAL — every atom combination (incl. out-of-range/adversarial inputs) produces
- *     a VALID in-range `AuroraConfig` respecting every `budget.ts` cap (no NaN, no
- *     out-of-range field). Clamp/saturate, never garbage.
- *   - DEFAULT-PRESERVING — `resolveAtoms(DEFAULT_ATOMS)` deep-equals
- *     `DEFAULT_AURORA_CONFIG` (the wispy-sky default survives the door).
- *
- * Mechanism: clone `DEFAULT_AURORA_CONFIG` and apply ONLY the atoms that are PRESENT
- * as clamped overrides. An absent atom keeps the default's value, so the empty atom
- * set (`DEFAULT_ATOMS`) resolves to exactly the wispy-sky default by construction.
- */
-import { type AuroraConfig, type AuroraMedium, type OklchStop } from "../constants/presets";
-import { type AuroraHarmony } from "./color";
-/** The motion atom — the three motion registers. */
-export type AuroraMotionAtom = "still" | "breathing" | "drifting";
-/**
- * The ZONES arrangement character — selects the nuclei placement prior. NOT a bare
- * integer count: the same count reads as a different field per arrangement.
- * - `scattered` — radial-ish spread off the centre (loose, atmospheric).
- * - `composed`  — the rule-of-thirds prior (the deliberate, balanced field).
- * - `centred`   — a tight central cluster (one dominant glow, calm).
- */
-export type AuroraZoneArrangement = "scattered" | "composed" | "centred";
-/** The ZONES atom — a count + an arrangement character (default `composed`). */
-export interface AuroraZones {
-    /** 1..MAX_NUCLEI — the number of color zones (nuclei). Clamped. */
-    count: number;
-    /** The placement prior. Default `composed` (rule-of-thirds). */
-    arrangement?: AuroraZoneArrangement;
-}
-/**
- * The MEDIUM atom — the painterly medium + (only for a TEXTURED medium) its dominant
- * texture amount. `amount` is STRUCTURALLY ABSENT for `smooth`: a smooth medium has
- * no dominant texture knob, so the door does not offer/accept one (no silent-inert
- * arm). For a textured medium `amount` (0..1) drives the medium's signature knob.
- */
-export type AuroraMediumAtom = {
-    kind: "smooth";
-} | {
-    kind: Exclude<AuroraMedium, "smooth">;
-    amount?: number;
-};
-/**
- * The interactivity atom — ONLY the wired axes ship. `light` (cursor-as-light) and
- * `scroll` (scroll-coupled palette/breath) are wired downstream
- * (`frameLoop.ts`/`useAurora.ts`); the declared-but-unwired `flow`/`wake` axes are
- * EXCISED from the shipped atom shape (no declared-but-dead axis — excise-or-wire).
- */
-export interface AuroraInteractivityAtom {
-    /** cursor drives the impasto light direction (cursor-as-light + idle orbit). */
-    light?: boolean;
-    /** palette/breath progress couples to scroll (via useScrollProgress). */
-    scroll?: boolean;
-}
-/**
- * The Tier-1 atoms of control (≤7) — the user's named control elements. EVERY atom is
- * OPTIONAL; an absent atom keeps the wispy-sky default for the fields it would drive,
- * so `DEFAULT_ATOMS` (the empty set) resolves to `DEFAULT_AURORA_CONFIG`.
- */
-export interface AuroraAtoms {
-    /** A seed color (CSS string or an OklchStop anchor) → drives the derived palette. */
-    seed?: string | OklchStop;
-    /** The hue scheme across the derived ramp. Default `analogous` (when a seed is set). */
-    harmony?: AuroraHarmony;
-    /**
-     * 0..1 — the color ENERGY knob. One scalar co-varies the entangled chroma/value
-     * cluster: saturation, valueVariance, breath, AND the warm-light/cool-shadow
-     * temperature on the derived palette. 0 = calm/muted, 1 = vivid/charged. A
-     * continuous curve, not a 3-point named LUT.
-     */
-    colorEnergy?: number;
-    /** The color zones (nuclei) — a count + an arrangement character. */
-    zones?: AuroraZones;
-    /**
-     * 0..1 — the NOISE knob. One scalar fans to the organic-boundary cluster:
-     * warpAmount (how much the zones distort), warpScale (the distortion frequency),
-     * warpMode (smooth fBm → cellular as it climbs), and noiseOctaves (detail). 0 =
-     * clean isotropic zones, 1 = turbulent organic edges.
-     */
-    noise?: number;
-    /** The painterly medium + (textured mediums only) its dominant texture amount. */
-    medium?: AuroraMediumAtom;
-    /** still | breathing | drifting — the three motion registers. */
-    motion?: AuroraMotionAtom;
-    /** The pointer/scroll interactivity axes (default OFF). Only `light`/`scroll` ship. */
-    interactivity?: AuroraInteractivityAtom;
-}
-/**
- * The default atoms — the EMPTY set. `resolveAtoms(DEFAULT_ATOMS)` deep-equals the
- * wispy-sky `DEFAULT_AURORA_CONFIG` (machine-asserted). The user explicitly asked the
- * default to be preserved; the empty-atom pass-through is how the door honors it.
- */
-export declare const DEFAULT_ATOMS: AuroraAtoms;
-/**
- * The deterministic nuclei prior for `count` zones under an `arrangement` character.
- * ONE home for the rule-of-thirds prior (the AW duplicated prior pair is gone). Total:
- * clamps `count` to `[1, MAX_NUCLEI]`; every arrangement yields a valid in-range nuclei
- * array.
- *
- * - `composed`  — the rule-of-thirds anchor table (the deliberate balanced field).
- * - `scattered` — a golden-angle (φ⁻¹) low-discrepancy spread off-centre (loose).
- * - `centred`   — a tight cluster around the centre (one dominant glow).
- */
-export declare function nucleiPrior(count: number, arrangement?: AuroraZoneArrangement): AuroraConfig["nuclei"];
-/**
- * Expand the ≤7 Tier-1 atoms into a full, valid, in-range `AuroraConfig`. A PURE,
- * TOTAL function: clones the BASE config and applies ONLY the present atoms as clamped
- * overrides, so the empty atom set resolves to exactly the base and every atom
- * combination yields a config respecting every `budget.ts` cap.
- *
- * `base` defaults to the wispy-sky `DEFAULT_AURORA_CONFIG` (so `resolveAtoms(DEFAULT_ATOMS)`
- * deep-equals it — the machine-asserted default-preserving contract). A consumer that
- * REFINES a richer config (the live atoms studio seeding FROM the active preset) passes the
- * preset config as `base`, so the ~21 non-atom fields the ≤7-knob projection does NOT carry
- * (the hero's stroke params, the per-preset palette specifics beyond the seed) SURVIVE the
- * atom touch — the first atom edit refines the preset rather than clobbering it to the
- * wispy-sky default (the W-AUR-STUDIO D4 atoms-trap fix).
- */
-export declare function resolveAtoms(atoms?: AuroraAtoms, base?: AuroraConfig): AuroraConfig;
-/**
- * Project a full `AuroraConfig` back onto the ≤7 Tier-1 atoms. The minimal recovered
- * set is seed / colorEnergy / zones-count / noise / medium(+amount) / motion; `harmony`
- * and `zones.arrangement` take their door defaults (not recoverable — lossy by design).
- * `configToAtoms(resolveAtoms(a))` recovers the energy/noise/medium/motion/zone-count
- * axes of `a` within the projection's resolution (the round-trip the seed-from-preset
- * fix needs + the gate asserts).
- */
-export declare function configToAtoms(cfg: AuroraConfig): AuroraAtoms;

package/dist/components/custom/aurora/composables/color.d.ts

@@ -1,93 +0,0 @@
-import { type ColorHarmony, type OklchStop } from "../../../../composables/color";
-export { cssToOklch, oklchStopToHex, oklchToLinear, } from "../../../../composables/color";
-export type { OklchStop } from "../../../../composables/color";
-export type { ColorHarmony } from "../../../../composables/color";
-/**
- * Pack up to `maxStops` OklchStops into linear-sRGB triples. When `out` is
- * provided the buffer is filled in place (no allocation) — the runtime owns a
- * single buffer reused on every config update so a slider drag does not churn
- * the GC. Unused slots are zero-filled; the shader clamps via `uStopCount`.
- */
-export declare function flattenPalette(stops: OklchStop[], maxStops?: number, out?: Float32Array): Float32Array;
-/**
- * Derive a cheap CSS `linear-gradient` from an Aurora palette — the static
- * first-frame placeholder painted under the WebGL canvas while the runtime
- * arms (see `useAurora`'s deferred init / Aurora.vue's placeholder element).
- *
- * The shader interpolates the same OKLCh stops in linear sRGB; here we render
- * each stop as a gamma-sRGB hex so the browser's gradient compositor produces
- * a visually-adjacent approximation with zero JS and zero GPU on first paint.
- * A diagonal axis (135deg) reads as atmospheric depth rather than a flat band.
- *
- * Single-stop palettes degrade to a flat fill; an empty palette yields
- * `transparent` so the placeholder is simply invisible (the canvas still
- * fades in over it once armed).
- */
-export declare function paletteToCssGradient(stops: OklchStop[]): string;
-export declare function hexToOklchStop(hex: string): OklchStop;
-/**
- * Harmony schemes for {@link deriveAurora} — the PUBLIC alias of the shared
- * `ColorHarmony` vocabulary hoisted to the `/color` leaf (AW.W11.b). The blob and
- * aurora derive from this ONE union; aurora keeps the `AuroraHarmony` name for
- * surface preservation. See `ColorHarmony` for the per-scheme semantics.
- */
-export type AuroraHarmony = ColorHarmony;
-/**
- * Eased L/C journey shapes for the derived ramp. `bell` (the W5 default for chroma)
- * peaks the chroma in the mids and desaturates the extremes — the painterly
- * "saturated body, calm edges" curve. `linear` is the prior monotone falloff
- * (the named pre-W5 branch — NOT a back-compat alias, a first-class choice).
- */
-export type DeriveEasing = "linear" | "sine" | "bell";
-export interface DeriveAuroraOptions {
-    /** Number of stops to produce. Default 4; clamped to [2, MAX_STOPS]. */
-    stopCount?: number;
-    /** Hue scheme across the ramp. Default "analogous". */
-    harmony?: AuroraHarmony;
-    /** Total L travel across the ramp, in OKLCh L units. Default ~0.32. */
-    lightnessSpread?: number;
-    /** C multiplier at the pale apex (toward 1 = no falloff). Default ~0.85. */
-    chromaFalloff?: number;
-    /** Hue walk in degrees for analogous; ignored by monochrome. Default ~28. */
-    hueSpread?: number;
-    /** L-ramp easing across the band. Default `linear` (monotone ascent). */
-    lightnessEasing?: DeriveEasing;
-    /** C-ramp easing. Default `bell` (peak in the mids — the W5 painterly default). */
-    chromaEasing?: DeriveEasing;
-    /**
-     * Warm-light / cool-shadow temperature coupling (0..1). A hue delta that warms
-     * the lights and cools the shadows — the single most-cited painting rule, the
-     * fold that makes the oil/oil-pastel mediums read as mixed paint. Default 0.
-     */
-    temperatureShift?: number;
-    /**
-     * BC.W-VIZ-AURORA (A7) — the additive DERIVE-path hue-EXCLUSION axis (the
-     * speedtest-AX cross-repo fold). Named OKLCh hue bands (each `[startDeg, endDeg]`,
-     * wrap-around supported via `start > end`) that EVERY derived stop's hue must fall
-     * OUTSIDE. The mechanism that makes "teal-on-navy is GONE" enforceable in the DERIVE
-     * path, not just the static default — a consumer deriving a palette FROM any seed
-     * can never re-introduce a purged band (e.g. `avoidHues: [[170, 200]]` excludes the
-     * teal arc by construction). The exclusion RE-ROUTES the walked hue to the nearest
-     * band EDGE (preserving L/C — no chroma flatten); it is NOT a post-hoc desaturate.
-     * Additive + default-unset → byte-identical derive (the `WarpMode`-additive-widen
-     * precedent: `proof:aurora-atoms-roundtrip` stays GREEN by construction).
-     */
-    avoidHues?: readonly (readonly [number, number])[];
-}
-/**
- * Seed ONE color into a harmonious, gamut-safe N-stop aurora palette.
- *
- * A thin COMPOSING producer over the shipped value.js Ottosson core (inv J-10:
- * no color math is re-implemented here). The seed's `{L,C,h}` is the anchor; the
- * ramp spreads L across a painterly band, falls C off toward the pale apex, and
- * walks the hue per `harmony`. EVERY derived stop is gamut-mapped through
- * value.js's `gamutMapOKLab` so none falls outside sRGB.
- *
- * Deterministic and DOM-free (SSR / happy-dom safe — `cssToOklch` is the only
- * string path and it parses via value.js, not a canvas). The returned length is
- * clamped to `[2, MAX_STOPS]`; L is monotonic ascending across the ramp.
- *
- * @param seed any CSS color string OR an `OklchStop` anchor.
- * @param options ramp shape — stop count, harmony, L/C/h spreads.
- */
-export declare function deriveAurora(seed: string | OklchStop, options?: DeriveAuroraOptions): OklchStop[];

package/dist/components/custom/aurora/composables/cursorModel.d.ts

@@ -1,78 +0,0 @@
-/**
- * Aurora cursor model — the eased pointer-attraction state.
- *
- * The cursor x/y in 0..1 ease toward their targets; `strength` ramps in while the
- * pointer is active and decays per-frame once it lifts. Exported ONCE here so any
- * CPU mirror (a consumer reproducing the cursor model) imports these constants
- * rather than re-declaring them — the shader and the CPU side stay in lockstep.
- */
-/**
- * Cursor easing constants. Authored to feel "snappy on entry, gentle decay";
- * documented in DESIGN.md §4. Higher lerp = faster ramp; smaller decay = longer
- * tail.
- */
-export declare const CURSOR_POS_LERP = 0.22;
-export declare const CURSOR_STRENGTH_LERP = 0.18;
-export declare const CURSOR_DECAY_PER_FRAME = 0.992;
-/**
- * At-rest epsilon for the demand-driven loop. The cursor is "settled" once its
- * eased position is within ε of its target AND its strength has decayed below ε —
- * below this the next frame is visually identical, so the loop may park.
- */
-export declare const CURSOR_REST_EPSILON = 0.001;
-/**
- * AW.W8.1 — the velocity-burst decay per frame. A fast pointer flick injects a
- * transient `burst` that eases out over ~1s (≈0.96^60 ≈ 0.09 after 1s at 60fps),
- * distinct from the steady attraction. The velocity itself eases faster (it tracks
- * the live pointer delta, not a lingering field).
- */
-export declare const CURSOR_BURST_DECAY_PER_FRAME = 0.96;
-export declare const CURSOR_VELOCITY_LERP = 0.3;
-/** The mutable eased-cursor state. `strength` ramps in; `targetStrength` decays. */
-export interface CursorState {
-    x: number;
-    y: number;
-    targetX: number;
-    targetY: number;
-    strength: number;
-    targetStrength: number;
-    radius: number;
-    /**
-     * AW.W8.1 — the smoothed pointer velocity (delta per move, eased). The
-     * velocity-reactive flow consumes its magnitude; a fast flick spikes it. Units
-     * are normalized-screen per move (clamped to avoid a teleport spike).
-     */
-    velX: number;
-    velY: number;
-    /**
-     * AW.W8.1 — the transient swirl-BURST a fast flick injects (decays over ~1s).
-     * The flow shader reads this as a decaying velocity-driven term, distinct from
-     * the steady `strength` attraction.
-     */
-    burst: number;
-}
-/** A fresh at-rest cursor (centred, no attraction, default radius). */
-export declare function createCursorState(): CursorState;
-/**
- * Advance the cursor easing one frame — snappy approach toward the target
- * position, gentle decay of the attraction strength when idle. AW.W8.1: also eases
- * the velocity toward zero and decays the swirl-burst. `tempo` (the master tempo
- * scalar, default 1; 0 under PRM/pause) scales the velocity + burst toward stillness
- * so the whole interactive stack freezes when tempo is 0 — `tempo` multiplies the
- * retained fraction, NOT `uTime` (scaling the clock makes the flow jump; the
- * integration step scales, the absolute clock keeps marching — the W11 discipline).
- */
-export declare function advanceCursor(cursor: CursorState, tempo?: number): void;
-/**
- * AW.W8.1 — feed a pointer delta into the velocity + burst. Called from the
- * `pointermove` listener, which MUST early-out on reduced-motion BEFORE calling this
- * (the cursor write-path PRM check — the listener fires independent of the rAF loop).
- * The delta is clamped so a teleport (tab-in, scroll jump) does not spike a giant burst.
- */
-export declare function injectCursorVelocity(cursor: CursorState, dx: number, dy: number): void;
-/**
- * True while the cursor is still easing (position not yet at target, or strength
- * not yet decayed below ε). The render-demand gate ORs this with the config drift
- * check — when both are false the next frame is pixel-identical, so the loop parks.
- */
-export declare function cursorIsLive(cursor: CursorState): boolean;

package/dist/components/custom/aurora/composables/frameLoop.d.ts

@@ -1,39 +0,0 @@
-/**
- * Aurora frame loop — the per-frame draw + the render-demand gate.
- *
- * `drawFrame` re-sends the per-frame cursor + time uniforms and issues the single
- * full-screen-triangle draw. `needsAnimation` is the demand gate: it returns
- * `false` under reduced-motion (the static frame draws once, then the loop parks),
- * `false` at steady-state (all four drift uniforms 0 AND the cursor settled within
- * ε — the next frame would be pixel-identical), and `true` while drift is live or
- * the cursor is still easing.
- */
-import type { UniformLocations } from "./glSetup";
-import { type CursorState } from "./cursorModel";
-import type { AuroraConfig } from "../constants/presets";
-import type { UsePointerVelocityField } from "../../../../composables/motion/usePointerVelocityField";
-export interface FrameLoopDeps {
-    gl: WebGL2RenderingContext;
-    prog: WebGLProgram;
-    uniforms: UniformLocations;
-    cursor: CursorState;
-    /** The live config (drift uniforms gate the demand loop). */
-    getConfig: () => AuroraConfig;
-    /** Reduced-motion intent — parks the loop after one static frame. */
-    getReducedMotion: () => boolean;
-    /**
-     * BC.W-VIZ-AURORA (T5) — the shared viz-pointer-physics field (BB.B4). FED
-     * `tick(deltaMs)` from THIS frame callback (the one-loop discipline — the field owns
-     * NO own rAF); the renderer reads `acceleration` for the iOS-27 gel snap-back. The
-     * existing cursorModel velocity/burst stays the byte-faithful baseline; the accel
-     * term is the additive fold.
-     */
-    pointerField: UsePointerVelocityField;
-}
-export interface FrameLoop {
-    /** Advance the cursor easing THEN draw — the per-frame step. */
-    frame: (timeSec: number) => void;
-    /** Demand gate — is there live motion to render on the next frame? */
-    needsAnimation: () => boolean;
-}
-export declare function createFrameLoop(deps: FrameLoopDeps): FrameLoop;

package/dist/components/custom/aurora/composables/glSetup.d.ts

@@ -1,29 +0,0 @@
-/**
- * Aurora GL setup seam — shader compile/link + geometry + the uniform location
- * cache. The GL-lifecycle orchestrator (`runtime.ts`) calls `createGlProgram` on a
- * fresh context (on arm AND on every webglcontextrestored), so a GPU context loss
- * self-heals: each call rebuilds the program + the full-screen triangle + the
- * `UNIFORM_NAMES` location cache against the fresh `gl`.
- *
- * The `UNIFORM_NAMES` const-assertion is the single source of truth for the
- * shader-uniform boundary: a NEW uniform name must be added here, and the cache is
- * keyed off it, so a fresh uniform always gets a location slot.
- */
-export declare const UNIFORM_NAMES: readonly ["uTime", "uPalette", "uStopCount", "uNucleiCount", "uNucleiPos", "uNucleiRadius", "uNucleiPaletteBias", "uNucleiValueBias", "uNucleiDriftRadius", "uNucleiDriftPhase", "uNucleiElong", "uNucleiAngle", "uSoftmaxBeta", "uValueVariance", "uWarpAmount", "uWarpScale", "uWarpDrift", "uWarpMode", "uNoiseOctaves", "uMedium", "uHuePath", "uFlowPattern", "uFlowFocal", "uFlowAngle", "uFlowCurl", "uCursor", "uCursorStrength", "uCursorRadius", "uCursorVelocity", "uCursorBurst", "uStrokeAmount", "uStrokeScale", "uStrokeAnisotropy", "uStrokeLayers", "uStrokeMode", "uStrokeOrient", "uLightDir", "uLightColor", "uWetEdge", "uGranulation", "uImpasto", "uBrokenColor", "uCanvasGrain", "uNucleiDrift", "uPaletteDrift", "uBreathDepth", "uBreathPeriod", "uSaturation", "uPaperGrain", "uAlpha"];
-export type UniformName = (typeof UNIFORM_NAMES)[number];
-export type UniformLocations = Record<UniformName, WebGLUniformLocation | null>;
-export interface GlProgram {
-    program: WebGLProgram;
-    vs: WebGLShader;
-    fs: WebGLShader;
-    uniforms: UniformLocations;
-    geometry: {
-        vao: WebGLVertexArrayObject;
-        buf: WebGLBuffer;
-    };
-}
-/**
- * Compile + link the shader pair, build the full-screen triangle (one draw covers
- * the viewport), and resolve the uniform location cache. Leaves the program bound.
- */
-export declare function createGlProgram(gl: WebGL2RenderingContext, vertexSrc: string, fragmentSrc: string): GlProgram;

package/dist/components/custom/aurora/composables/runtime.d.ts

@@ -1,127 +0,0 @@
-/**
- * Aurora v4.1 runtime — the GL-lifecycle orchestrator over the `useWebGLCanvas`
- * substrate (AU.W6, the DEC-AT-1 transposition).
- *
- * This module composes four cohesive seams atop the substrate:
- *   - glSetup       — compile/link + geometry + the uniform location cache
- *   - uniformBridge — the reactive-config → GL-uniform translation + enum dispatch
- *   - cursorModel   — the eased pointer-attraction state + advance
- *   - frameLoop     — the per-frame draw + the render-demand gate
- *
- * It owns ONLY the aurora-specific glue: threading the seams through the
- * substrate's `setup`/`frame`/`shouldContinue`/`resize`/`time`/`teardown`
- * callbacks, the reduced-motion frozen-t, the DPR policy, and the imperative
- * setters/pause/resume. The generic WebGL2 lifecycle — context creation, the
- * three-reason suspend/resume model, the demand-driven rAF loop, the tab-visibility
- * owner, the ResizeObserver, and the webglcontextlost/restored robustness — lives
- * in the substrate.
- *
- * Y-origin convention: config authoring is CSS-top-origin (0 = top). The seams
- * flip Y at the uniform boundary (`flipY` in uniformBridge/frameLoop).
- */
-import type { AuroraConfig, AuroraInstance } from "../constants/presets";
-export type AuroraRuntimeMode = "live" | "capture";
-/**
- * The three independent reasons the rAF loop may be suspended. Owned by the
- * `useWebGLCanvas` substrate as a `Set<reason>`: the loop runs IFF the set is
- * empty and each reason is cleared ONLY by the source that set it. This makes
- * resume-while-still-suspended structurally unreachable — a `resume("tab-hidden")`
- * cannot lift an `"off-screen"` suspension.
- *
- * - `"tab-hidden"` — the substrate's `document.visibilitychange` owner.
- * - `"off-screen"` — viewport-intersection, driven by `useIntersectionPause`.
- * - `"manual"` — the public `pause()`/`resume()` API (and capture-mode seed).
- */
-export type SuspendReason = "tab-hidden" | "off-screen" | "manual";
-/**
- * When the expensive WebGL path (context creation, shader compile + GPU link,
- * first uniform upload, rAF arm) actually runs.
- *
- * - `"deferred"` (default) — `createAurora` constructs a cheap, un-armed instance
- *   and returns immediately; the GL work is invoked later via `instance.arm()`.
- *   The Vue wrapper `useAurora` schedules `arm()` past first paint on an idle
- *   tick, gated on canvas visibility — so the shader compile-link never lands on
- *   the consumer's first-paint critical path.
- * - `"eager"` — `createAurora` arms synchronously before returning. Capture /
- *   thumbnail-baking consumers need this: `renderAt` must draw a real frame the
- *   instant `createAurora` returns. `mode: "capture"` forces eager regardless.
- */
-export type AuroraInitStrategy = "eager" | "deferred";
-export interface AuroraRuntimeOptions {
-    mode?: AuroraRuntimeMode;
-    preserveDrawingBuffer?: boolean;
-    /**
-     * When to run the expensive WebGL init. Defaults to `"deferred"`.
-     * `mode: "capture"` forces `"eager"` (a capture runtime must be able to
-     * `renderAt` synchronously). See {@link AuroraInitStrategy}.
-     */
-    initStrategy?: AuroraInitStrategy;
-    /**
-     * Init-failure handler. A WebGL2/shader-compile/link failure is a
-     * library-internal contract violation (O invariant 24). On the EAGER path
-     * `createAurora` throws synchronously and `useAurora` rethrows by default so
-     * the signal reaches the consumer's error boundary / dev console. On the
-     * DEFERRED path the failure happens on an idle tick — outside any mount-time
-     * boundary — so the runtime routes it here, and `useAurora` re-surfaces it on
-     * the microtask queue (so it still reaches the dev console /
-     * `app.config.errorHandler`) when no handler is supplied. Provide this
-     * callback to opt into silent handling on either path.
-     *
-     * NOTE: this is the `useAurora` Vue-wrapper contract surface. The imperative
-     * `createAurora(...)` runtime throws on eager init failure and — for
-     * `instance.arm()` on the deferred path — rethrows from `arm()`.
-     *
-     * BB.W-AURORA-SWRASTER — a SOFTWARE-RASTER fall is NOT a contract violation:
-     * it never reaches `onInitError`. The wedge catch (see {@link createAurora})
-     * recognizes the software-raster signal at arm time, leaves the canvas
-     * un-armed (the placeholder stays the surface), and returns CLEANLY — so a
-     * consumer who pins `mode:"capture"`/`mode:"webgl"` under SwiftShader never
-     * has to wire `onInitError` to avoid the hang. The handler is preserved for
-     * GENUINE violations (a malformed shader, an OOM, a real link failure).
-     */
-    onInitError?: (err: Error) => void;
-    /**
-     * BB.W-AURORA-SWRASTER — opt OUT of the runtime software-raster wedge catch.
-     * Default `false`: the wedge catch is the safe default — `createAurora`
-     * recognizes a software renderer at arm time and falls cleanly to the
-     * placeholder rather than arming the page-wedging live GL layer. `true` (the
-     * named, recorded escape for a deterministic test that ACCEPTS the cost)
-     * arms WebGL even under a detected software renderer. Mirrors the
-     * `resolveRenderMode` escape of the same name — ONE consumer-facing flag,
-     * threaded through both seams.
-     */
-    forceWebGLUnderSoftwareRaster?: boolean;
-}
-/**
- * The concrete `createAurora` return shape. It IS an {@link AuroraInstance}
- * (structurally assignable — every member matches) but widens `pause`/`resume` to
- * carry an optional {@link SuspendReason}, defaulting to `"manual"`. The Vue
- * wrapper passes `"off-screen"` for the intersection seam; a bare
- * `pause()`/`resume()` reads identically to the `AuroraInstance` contract.
- */
-export interface AuroraRuntime extends Omit<AuroraInstance, "pause" | "resume"> {
-    pause(reason?: SuspendReason): void;
-    resume(reason?: SuspendReason): void;
-    /**
-     * BC.W-VIZ-AURORA (T2) — the device-resolved arm PROMISE. On the WebGPU
-     * backend `renderAt`/`arm` are NO-OPS until `armAsync()` resolves the async
-     * adapter→device→configure→setup prelude (`useGpuSubstrate.armAsync` tries
-     * WebGPU then falls to the WebGL2 net). A CAPTURE consumer (`renderAt(t)` +
-     * `toDataURL`) MUST `await armAsync()` before the first `renderAt` — the
-     * synchronous `arm()` cannot guarantee the WebGPU device is present, so a
-     * synchronous `renderAt` right after `createAurora(…,{mode:"capture"})` paints
-     * a BLANK frame (the dead-preview defect). Resolves once the backend is armed;
-     * the WebGL2 fallback resolves immediately. Idempotent + safe post-dispose.
-     */
-    armAsync(): Promise<void>;
-    /**
-     * AW.W8.1 — feed a pointer delta into the velocity-reactive flow (a fast flick →
-     * a transient swirl-burst). The PRM early-out lives here: the injection is
-     * suppressed when the substrate reports reduced-motion (the cursor write-path
-     * fires from the pointermove listener, INDEPENDENT of the parked rAF loop).
-     */
-    injectCursorVelocity(dx: number, dy: number): void;
-    /** AW.W8.1 — the live reduced-motion state (the cursor listener early-outs on it). */
-    readonly reducedMotion: boolean;
-}
-export declare function createAurora(canvas: HTMLCanvasElement, initial: AuroraConfig, options?: AuroraRuntimeOptions): AuroraRuntime;

package/dist/components/custom/aurora/composables/uniformBridge.d.ts

@@ -1,100 +0,0 @@
-/**
- * Aurora uniform bridge — the reactive-config → GL-uniform translation seam.
- *
- * Owns the sealed enum↔shader-int dispatch maps and the per-config uniform upload.
- * Each map is `as const` constrained by a `satisfies Record<Union, number>` so a
- * NEW union member is a COMPILE error until it gets a slot — no silent stale-Record
- * gap where a fresh enum value uploads `undefined`.
- *
- * Crayon is a FIRST-CLASS medium (`uMedium == 4`, AX.W13), NOT a stroke mode: the
- * shader has a dedicated `mediumCrayon()` body (DRY wax-on-tooth). `MEDIUM_ID` carries
- * the `crayon: 4` slot and `StrokeMode` no longer has a `crayon` member — the legacy
- * `oil` + `strokeMode:"crayon"` peer-route is REMOVED (clean break); a crayon surface
- * selects `medium:"crayon"`.
- *
- * The pre-allocated upload buffers live in the bridge: a slider drag refills them
- * in place rather than allocating ~8 Float32Arrays per frame.
- */
-import type { OklchStop } from "../../../../composables/color";
-import type { UniformLocations } from "./glSetup";
-import type { CursorState } from "./cursorModel";
-import { type AuroraConfig } from "../constants/presets";
-export declare const MEDIUM_ID: {
-    readonly smooth: 0;
-    readonly pastel: 1;
-    readonly watercolor: 2;
-    readonly oil: 3;
-    readonly crayon: 4;
-    readonly vangogh: 5;
-    readonly "oil-pastel": 6;
-    readonly kuwahara: 7;
-};
-export declare const HUE_PATH_ID: {
-    readonly shorter: 0;
-    readonly longer: 1;
-    readonly increasing: 2;
-    readonly decreasing: 3;
-};
-export declare const FLOW_ID: {
-    readonly none: 0;
-    readonly radial: 1;
-    readonly swirl: 2;
-    readonly diagonal: 3;
-    readonly multi: 4;
-    readonly tensor: 5;
-};
-export declare const STROKE_ORIENT_ID: {
-    readonly flow: 0;
-    readonly tensor: 1;
-};
-export declare const WARP_ID: {
-    readonly fbm: 0;
-    readonly cellular: 1;
-    readonly hybrid: 2;
-    readonly curl: 3;
-};
-export declare const STROKE_MODE_ID: {
-    readonly oil: 0;
-    readonly knife: 1;
-    readonly chunky: 3;
-};
-export declare const AURORA_CATCH_LIGHT_ANCHOR: OklchStop;
-/**
- * Resolve a config's `lightColor` to a LINEAR-light `[r,g,b]` triple. Accepts either
- * a raw linear triple (the array form, passed through) OR an `{L,C,h}` OKLCh anchor
- * (derived through the shared `warmCatchLight` helper). Omitted = the canonical aurora
- * warm-white from `AURORA_CATCH_LIGHT_ANCHOR`.
- */
-export declare function resolveLightColor(lightColor: [number, number, number] | OklchStop | undefined): [number, number, number];
-/**
- * The effective `uMedium` int for a config. AX.W13 — a pure identity map over the
- * medium union (the `oil` + `strokeMode:"crayon"` peer-route is REMOVED; crayon is its
- * own first-class `medium:"crayon"`). `medium` is total over `MEDIUM_ID` (the
- * `satisfies` guarantees it), so this never resolves `undefined`.
- */
-export declare function resolveMediumId(cfg: AuroraConfig): number;
-/**
- * The `uStrokeMode` int for a config. AX.W13 — `strokeMode` is total over
- * `STROKE_MODE_ID` (no `crayon` special-case), so this is a direct map.
- */
-export declare function resolveStrokeModeId(cfg: AuroraConfig): number;
-/**
- * AX.W13 — the `uStrokeOrient` int for a config. The painterly mediums (`vangogh`,
- * `oil-pastel`, `crayon`) FORCE the structure-tensor orientation regardless of the
- * config's `strokeOrient` field — their marks must hug the color zones (the
- * congruent-to-real-works contract). Every other medium honors the config's
- * `strokeOrient` (default `"flow"`). BB.W-AUR-KUWAHARA — `kuwahara` ALSO forces
- * tensor: the anisotropic Kuwahara kernel is squeezed along the structure-tensor
- * minor eigenvector, so the orientation source must be the tensor field.
- */
-export declare function resolveStrokeOrientId(cfg: AuroraConfig): number;
-/**
- * Build the per-config uniform uploader bound to a program's uniform location
- * cache + cursor state. Returns `uploadConfig` — call it to push a fresh
- * `AuroraConfig` into the live program. The cursor uniforms are initialised here
- * and re-sent per frame by the frame loop.
- *
- * Y-origin: config authoring is CSS-top-origin (0 = top); the bridge flips Y at
- * the uniform boundary (`flipY`).
- */
-export declare function createUniformBridge(gl: WebGL2RenderingContext, prog: WebGLProgram, U: UniformLocations, cursor: CursorState): (cfg: AuroraConfig) => void;