@mkbabb/glass-ui 7.0.0 → 9.0.0

package/dist/composables/glass/backdropLuminanceSample.d.ts

@@ -1,9 +1,7 @@
-/** The per-sample result — the luminance AND the ambient hue (the FREE rider). */
+/** The per-sample result — the luminance, the one signal the cascade reads. */
 export interface SampleResult {
     /** WCAG relative luminance of the sampled backdrop (0..1). */
     luma: number;
-    /** A complete `oklch()` ambient-hue string, or `transparent` for a gray null. */
-    ambientHue: string;
 }
 /**
  * The KNOWN background-layer source for the ANIMATED case — an HTMLCanvasElement, a
@@ -28,30 +26,30 @@ export declare const SHELL_FIELD_CANVAS_SELECTOR = "[data-glass-field-canvas] ca
  * (backward-safe: no field canvas → null → the static elementsFromPoint path).
  */
 export declare function resolveSourceCanvas(src: BackgroundCanvasSource | undefined): HTMLCanvasElement | null;
-/**
- * Robust CSS-color → sRGB `[r,g,b,a]`. `parseRgb` is the fast path for the legacy
- * `rgb()/rgba()` serialization; ANY other valid CSS color form — the MODERN
- * `oklch()`, `color(srgb …)`, `hsl()` tokens the warm-cream demo basis resolves to —
- * is normalized by painting it onto the 1×1 corner of the reused 2D canvas (passed in)
- * and reading the composited pixel back (`getImageData` ALWAYS returns integer sRGB
- * whatever the source space).: without this `sampleStatic`
- * returned null on a `color(srgb …)`/`oklch(…)` backdrop and wrote NOTHING — the static
- * floor was a DEAD channel. The static floor is now writer-true over ANY backdrop.
- */
-export declare function normalizeToRgb(css: string, ctx: CanvasRenderingContext2D | null): [number, number, number, number] | null;
 /**
  * Sample the ANIMATED backdrop: downsample the resolved source canvas under the
- * surface's bounding box → mean relative luminance + the ambient-hue histogram (a FREE
- * rider over the SAME pixel pass). Returns null if no source, an all-transparent
+ * surface's bounding box → mean relative luminance. Returns null if no source, an all-transparent
  * (unrendered) field, or a tainted canvas — the live caller writes `unavailable` on a
  * null; it NEVER falls to the static stack-walk (that coalescing is forbidden).
+ *
+ * The field canvas is TRANSLUCENT, so each downsampled pixel is composited over the
+ * REAL opaque page `underlay` (resolved by `resolveUnderlayRgb` from the same stack the
+ * static sampler reads) — the same translucent field over a dark page vs a light page
+ * yields DISTINCT luma. Passing a fixed white underlay collapses that distinction and
+ * is the born-RED this repairs. The underlay feeds the EXISTING luma→tint axis; it is
+ * NOT a second opacity/attenuation axis.
+ */
+export declare function sampleAnimated(el: HTMLElement, source: HTMLCanvasElement | null, ctx: CanvasRenderingContext2D | null, underlay: readonly [number, number, number]): SampleResult | null;
+/**
+ * The REAL opaque page underlay beneath the surface — the color the TRANSLUCENT
+ * animated field composites OVER. Reuses `resolveBackdropRgba` (the same stack the
+ * static sampler reads), dropping alpha to an opaque triple; falls back to the
+ * CSS-initial white viewport when nothing opaque paints under the surface. This is the
+ * luma→tint axis input for `sampleAnimated`, NOT a second opacity/attenuation axis.
  */
-export declare function sampleAnimated(el: HTMLElement, source: HTMLCanvasElement | null, ctx: CanvasRenderingContext2D | null): SampleResult | null;
+export declare function resolveUnderlayRgb(el: HTMLElement, ctx: CanvasRenderingContext2D | null): [number, number, number];
 /**
- * Sample the STATIC backdrop: stack-walk `elementsFromPoint` at the surface centre,
- * read the first element under it with a resolved non-transparent background, un-wrap
- * the `var(--token)` through the resolveTokenColor leaf → relative luminance + the
- * ambient hue (the single resolved background color binned the SAME way). The reusable
- * 2D context (for the modern-color normalization paint-read) is passed in.
+ * Sample the STATIC backdrop: reduce the resolved backdrop (`resolveBackdropRgba`) to
+ * relative luminance. The reusable 2D context is passed in.
  */
 export declare function sampleStatic(el: HTMLElement, ctx: CanvasRenderingContext2D | null): SampleResult | null;

package/dist/composables/glass/backdropSampleMath.d.ts

@@ -1,5 +1,15 @@
 /** WCAG relative luminance of an sRGB triple [0..255]. */
 export declare function relLuminance(r: number, g: number, b: number): number;
+/**
+ * Composite a straight-alpha sRGB pixel [r,g,b] at coverage `a` (0..1) OVER an
+ * opaque sRGB `underlay` triple → the resolved opaque sRGB [r,g,b] (source-over).
+ * The animated field is a TRANSLUCENT canvas; the perceived backdrop is the field
+ * painted over the REAL opaque page beneath it, so the underlay MUST be the actual
+ * page color — a dark page and a light page under the SAME translucent field yield
+ * DISTINCT composited luma. A hardcoded white underlay collapses that distinction
+ * (the born-RED). This is the luma→tint axis input, NOT a second opacity axis.
+ */
+export declare function compositeOver(r: number, g: number, b: number, a: number, underlay: readonly [number, number, number]): [number, number, number];
 /** Parse a `rgb()/rgba()` string → [r,g,b,a] (the un-wrapped concrete form). */
 export declare function parseRgb(str: string): [number, number, number, number] | null;
 export declare function isCanvas(v: unknown): v is HTMLCanvasElement;

package/dist/composables/glass/canvas2d/index.d.ts

@@ -1,3 +1,3 @@
-export { useCanvas2D, useCanvasLifecycle } from "./useCanvas2D";
-export type { Canvas2DFrame, Canvas2DHandle, Canvas2DOptions, Canvas2DSuspendReason, } from "./useCanvas2D";
-export { resolveCanvasColor } from "./resolveCanvasColor";
+export { useCanvas2D } from "./useCanvas2D.js";
+export type { Canvas2DFrame, Canvas2DHandle, Canvas2DOptions, Canvas2DSuspendReason, } from "./useCanvas2D.js";
+export { resolveCanvasColor } from "./resolveCanvasColor.js";

package/dist/composables/glass/canvas2d/useCanvas2D.d.ts

@@ -1,5 +1,5 @@
 import { type MaybeRefOrGetter } from "vue";
-import { type DprPolicy } from "../webgl/createCanvasLifecycle";
+import { type DprPolicy } from "../webgl/createCanvasLifecycle.js";
 /**
  * The suspend reasons that gate the loop. Twins the WebGL substrate's union
  * (`createCanvasLifecycle.CanvasSuspendReason`): the `"off-screen-io"`
@@ -62,14 +62,6 @@ export interface Canvas2DHandle {
  * `useWebGLCanvas`, a thin Canvas2D backend over the shared
  * `createCanvasLifecycle` core. Returns an imperative {@link Canvas2DHandle} (the
  * same handle idiom the WebGL twin uses — an imperative canvas seam is NOT a
- * ref-bundle). `useCanvasLifecycle` is the alias-of-record for the lifecycle-only
- * framing; both name the same factory.
+ * ref-bundle).
  */
 export declare function useCanvas2D(options: Canvas2DOptions): Canvas2DHandle;
-/**
- * Alias-of-record for {@link useCanvas2D} — the lifecycle-only framing (the
- * park/freeze/dispose machinery, paralleling the WebGL substrate's
- * `createCanvasLifecycle`). Same factory, same handle; reach for this name when
- * the lifecycle (not the 2D drawing) is the consumer's emphasis.
- */
-export declare const useCanvasLifecycle: typeof useCanvas2D;

package/dist/composables/glass/index.d.ts

@@ -1,7 +1,5 @@
-export { useSpecularTracking, createSpecularWriter, } from "./useSpecularTracking";
-export type { UseSpecularTracking, SpecularWriter, } from "./useSpecularTracking";
-export { vSpecular } from "./vSpecular";
-export { useSpecularPointer } from "./useSpecularPointer";
-export type { UseSpecularPointer } from "./useSpecularPointer";
-export { useCanvas2D, useCanvasLifecycle, resolveCanvasColor } from "./canvas2d";
-export type { Canvas2DFrame, Canvas2DHandle, Canvas2DOptions, Canvas2DSuspendReason, } from "./canvas2d";
+export { useSpecularTracking, createSpecularWriter, } from "./useSpecularTracking.js";
+export type { UseSpecularTracking, SpecularWriter, } from "./useSpecularTracking.js";
+export { vSpecular } from "./vSpecular.js";
+export { useCanvas2D, resolveCanvasColor } from "./canvas2d/index.js";
+export type { Canvas2DFrame, Canvas2DHandle, Canvas2DOptions, Canvas2DSuspendReason, } from "./canvas2d/index.js";

package/dist/composables/glass/useGlassBackdropLuminance.d.ts

@@ -1,5 +1,5 @@
 import { type Ref } from "vue";
-import { type BackgroundCanvasSource } from "./backdropLuminanceSample";
+import { type BackgroundCanvasSource } from "./backdropLuminanceSample.js";
 /** The discrete backdrop bucket derived and written by the observer. */
 export type GlassBackdropBucket = "light" | "dark";
 export interface UseGlassBackdropLuminanceOptions {
@@ -39,7 +39,7 @@ export interface UseGlassBackdropLuminanceOptions {
      * mark this as the SHARED per-ROUTE observer. It stamps
      * `GLASS_BACKDROP_SHARED_ATTR` on its target (the route/stage scope) so descendant
      * glass surfaces (docks) DETECT the coverage and STAND DOWN — inheriting the route's
-     * `--glass-backdrop-luma`, `--glass-backdrop`, `--glass-ambient-*` via the cascade
+     * `--glass-backdrop-luma`, `--glass-backdrop` via the cascade
      * rather than each mounting its own readback loop (12 per-dock observers over ONE
      * aurora → ONE per-route readback). Default false: a per-SURFACE observer, which
      * stands down when a shared ancestor covers it and self-samples as the honest floor
@@ -71,7 +71,6 @@ export type GlassBackdropSample = {
     mode: "live" | "static";
     source: "canvas" | "elements";
     luma: number;
-    ambientHue: string;
     sampledAt: number;
     targetRect: GlassBackdropTargetRect;
 } | {
@@ -99,7 +98,7 @@ export declare const GLASS_BACKDROP_SHARED_ATTR = "data-glass-backdrop-shared";
  * The sampled-luminance observer. Wire it on a glass surface (the dock root, a
  * content-glass panel) to write a dynamic backdrop-luminance signal that refines the
  * declarative bucket. Default on for Dock; a dark-substrate consumer
- * opts out by setting `--glass-tint-strength: 0%` on the surface (the declarative floor
+ * opts out by setting `--glass-level: 0` on the surface (the declarative floor
  * stays the guarantee — the observer only refines).
  *
  * @param target the glass surface element ref to sample under + write the tokens on

package/dist/composables/glass/useSpecularTracking.d.ts

@@ -5,7 +5,7 @@ import { ref, type CSSProperties } from "vue";
  *
  * On pointer-move it writes the cursor position (`--mouse-x`/`--mouse-y`, as
  * percentages of the host box) onto the host's inline style; the unified
- * `.glass-material::before` recipe (`glass.css`) MAPS that host write onto its
+ * material-group `::before` recipe (`glass.css`) MAPS that host write onto its
  * typed `--specular-x`/`--specular-y` channel and paints the travelling glow.
  *
  * VOCAB: `--mouse-x`/`--mouse-y` is the HOST WRITE this seam

package/dist/composables/glass/webgl/createCanvasLifecycle.d.ts

@@ -1,6 +1,5 @@
 export type CanvasSuspendReason = "tab-hidden" | "off-screen" | "off-screen-io" | "manual";
-import { sizeBacking, type BackingSize, type DprPolicy } from "./backingSize";
-export { sizeBacking };
+import { type BackingSize, type DprPolicy } from "./backingSize.js";
 export type { BackingSize, DprPolicy };
 /** The per-frame hooks a backend's `buildContext` returns to the lifecycle core. */
 export interface CanvasFrameHooks {
@@ -25,28 +24,20 @@ export interface CanvasLifecycleOptions {
     /**
      * Upload the backing geometry to the viewport/uniforms.
      *
-     * The leaf measures and sizes the backing store via
-     * `sizeBacking`, the ONE sizer) and passes the freshly-computed `BackingSize` here so
-     * the consumer can never re-derive a wrong one. When the leaf owns sizing (`dprPolicy`
-     * provided) the buffer is already correct on entry — the consumer body is UPLOAD-ONLY,
-     * shrinking to `gl.viewport(0,0,s.w,s.h)`, `uploadResolution` (a WGPU swap-chain leg
-     * is a no-op — it auto-resizes to the backing the leaf set).
-     *
-     * Procedural scenes, including Canvas2D, pass `dprPolicy` and use this upload-only
-     * size. The optional argument remains only for direct legacy WebGL/WebGPU callers
-     * that omit a DPR policy.
+     * The leaf measures and sizes the backing store via `sizeBacking` (the ONE sizer)
+     * and passes the freshly-computed `BackingSize` here, so the consumer can never
+     * re-derive a wrong one. The buffer is ALWAYS correct on entry — the consumer body
+     * is UPLOAD-ONLY, shrinking to `gl.viewport(0,0,s.w,s.h)`/`uploadResolution` (a WGPU
+     * swap-chain leg is a no-op — it auto-resizes to the backing the leaf set).
      */
-    resize: (s?: BackingSize) => void;
+    resize: (s: BackingSize) => void;
     /**
-     * The consumer's DPR policy, handed to the leaf's `sizeBacking`. When PRESENT the
-     * leaf owns backing-store measurement and sizing, and the live
-     * `BackingSize` rides every `resize` call. When ABSENT the leaf falls back to the
-     * legacy behaviour (the consumer's `resize()` self-measures) — the migration seam.
-     *
-     * Procedural scenes use the present branch. The absent branch remains for direct
-     * legacy WebGL/WebGPU callers.
+     * The consumer's DPR policy, handed to the leaf's `sizeBacking`. REQUIRED: the leaf
+     * owns backing-store measurement and sizing, and the live `BackingSize` rides every
+     * `resize` call. There is no self-measuring arm — a caller that cannot state a DPR
+     * policy cannot state a backing size either.
      */
-    dprPolicy?: DprPolicy;
+    dprPolicy: DprPolicy;
     /**
      * Bind/unbind backend-specific context-loss/restore listeners. `rebuild` re-runs
      * `buildContext` on a fresh context + resumes the loop (the self-heal); the backend
@@ -103,7 +94,7 @@ export interface CanvasLifecycleHandle {
      * SYNCHRONOUSLY, decoupled from the (async) context acquire. The WebGPU backend
      * calls this BEFORE `armAsync`'s device request so the canvas is sharp from frame 0
      * while the device resolves behind it (the ≤6s blurry-flash close). Idempotent: a
-     * no-op once `arm()` has run it. A no-op when no `dprPolicy` was supplied (legacy).
+     * no-op once `arm()` has run it.
      */
     presize: () => void;
     suspend: (reason?: CanvasSuspendReason) => void;

package/dist/composables/glass/webgl/useWebGLCanvas.d.ts

@@ -1,5 +1,5 @@
-import { type BackingSize, type DprPolicy } from "./createCanvasLifecycle";
-export type { BackingSize, DprPolicy } from "./createCanvasLifecycle";
+import { type BackingSize, type DprPolicy } from "./createCanvasLifecycle.js";
+export type { BackingSize, DprPolicy } from "./createCanvasLifecycle.js";
 /**
  * The one `getContext("webgl2")` capability probe. A throwaway WebGL2 context is
  * created here in the substrate,
@@ -23,13 +23,11 @@ export interface WebGLCanvasFrame {
     /** Demand-gate: is there live motion to render next frame? `false` → park. */
     shouldContinue: () => boolean;
     /**
-     * Upload the backing geometry to the viewport/uniforms.:
-     * when a `dprPolicy` is supplied the leaf MEASURES + sizes the backing and passes
-     * the live `BackingSize` here (the consumer body shrinks to
-     * `gl.viewport(0,0,s.w,s.h)`); the arg is optional so a legacy self-measuring
-     * consumer keeps compiling until it adopts the leaf sizer.
+     * Upload the backing geometry to the viewport/uniforms. The leaf MEASURES + sizes
+     * the backing and passes the live `BackingSize` here, so the consumer body is
+     * upload-only (`gl.viewport(0,0,s.w,s.h)`).
      */
-    resize: (s?: BackingSize) => void;
+    resize: (s: BackingSize) => void;
     /** Frame time from elapsed seconds — the consumer owns frozen/reduced-motion. */
     time?: (elapsedSec: number) => number;
     /** Delete GL resources (program/buffers/VAO). Runs on dispose + before a restore re-setup. */
@@ -50,12 +48,11 @@ export interface WebGLCanvasOptions {
      */
     respectReducedMotion?: boolean;
     /**
-     * The consumer's DPR policy. When present the
-     * leaf owns the backing-store measurement + sizing (the ONE sizer, sized
-     * synchronously at mount before any acquire) and hands the live `BackingSize` to
-     * `resize(s)`. When ABSENT the legacy path runs (the consumer self-measures).
+     * The consumer's DPR policy. REQUIRED: the leaf owns the backing-store measurement
+     * + sizing (the ONE sizer, sized synchronously at mount before any acquire) and
+     * hands the live `BackingSize` to `resize(s)`.
      */
-    dprPolicy?: DprPolicy;
+    dprPolicy: DprPolicy;
     /** Compose the leaf IO park. Default `false`; see createCanvasLifecycle. */
     composeIntersectionPark?: boolean;
     /** `rootMargin` for the leaf IO park. */

package/dist/composables/glass/webgl/visibility.d.ts

@@ -1,4 +1,4 @@
-import type { CanvasSuspendReason } from "./createCanvasLifecycle";
+import type { CanvasSuspendReason } from "./createCanvasLifecycle.js";
 /**
  * The scheduler seam the observers drive. Each observer writes a DISTINCT suspend
  * reason (`tab-hidden`, `off-screen`, `off-screen-io`) — the one-writer-per-reason

package/dist/composables/glass/webgpu/useGpuSubstrate.d.ts

@@ -1,10 +1,9 @@
-import { type WebGLCanvasFrame, type WebGLCanvasOptions } from "../webgl/useWebGLCanvas";
-import type { DprPolicy } from "../webgl/createCanvasLifecycle";
-export type { BackingSize, DprPolicy } from "../webgl/createCanvasLifecycle";
-import { supportsWebGPU, type WebGPUCanvasFrame, type WebGPUCanvasOptions } from "./useWebGPUCanvas";
-import { type RendererStatus } from "./rendererStatus";
-export type { RendererStatus, RendererEngine } from "./rendererStatus";
-export { supportsWebGPU };
+import { type WebGLCanvasFrame, type WebGLCanvasOptions } from "../webgl/useWebGLCanvas.js";
+import type { DprPolicy } from "../webgl/createCanvasLifecycle.js";
+export type { BackingSize, DprPolicy } from "../webgl/createCanvasLifecycle.js";
+import { type WebGPUCanvasFrame, type WebGPUCanvasOptions } from "./useWebGPUCanvas.js";
+import { type RendererStatus } from "./rendererStatus.js";
+export type { RendererStatus, RendererEngine } from "./rendererStatus.js";
 /** Which backend the picker resolved. */
 export type GpuBackend = "webgpu" | "webgl2";
 export interface GpuSubstrateOptions {
@@ -21,13 +20,11 @@ export interface GpuSubstrateOptions {
     setupGL: WebGLCanvasOptions["setup"];
     /**
      * The consumer's DPR policy: a flat multiplier
-     * or a box-aware resolver). When PRESENT the leaf owns the backing-store measurement
+     * or a box-aware resolver). REQUIRED: the leaf owns the backing-store measurement
      * + sizes it SYNCHRONOUSLY at mount (the ONE sizer; before the async acquire on the
-     * WebGPU path), handing the live `BackingSize` to each `setup`'s `resize(s)`. When
-     * ABSENT the legacy path runs (the consumer self-measures) — the per-viz adoption
-     * seam, identical on both backends.
+     * WebGPU path), handing the live `BackingSize` to each `setup`'s `resize(s)`.
      */
-    dprPolicy?: DprPolicy;
+    dprPolicy: DprPolicy;
     /**
      * Compose the leaf IntersectionObserver park so a consumer inherits the
      * off-screen IO-park ORed with content-visibility, no per-viz `useIntersectionPause`
@@ -93,7 +90,7 @@ export interface GpuSubstrateHandle {
      * canvas is in the DOM so the field is sharp from frame 0 while the device resolves
      * (the ≤6s blurry-flash close). `armAsync` already calls it internally on both legs;
      * exposed so a consumer can presize even earlier (e.g. immediately on mount, before
-     * the awaited `armAsync`). A no-op when no `dprPolicy` was supplied (legacy).
+     * the awaited `armAsync`). Idempotent — a no-op once the backing is already sized.
      */
     presize: () => void;
     suspend: (reason?: "tab-hidden" | "off-screen" | "off-screen-io" | "manual") => void;

package/dist/composables/glass/webgpu/useWebGPUCanvas.d.ts

@@ -1,7 +1,6 @@
-export type { BackingSize, DprPolicy } from "../webgl/createCanvasLifecycle";
-export { WebGPUInitError, WEBGPU_ACQUIRE_TIMEOUT_MS } from "./webgpuDevice";
-export type { WebGPUSuspendReason, WebGPUCanvasFrame, WebGPUCanvasOptions, WebGPUCanvasHandle, } from "./webgpuCanvasTypes";
-import type { WebGPUCanvasOptions, WebGPUCanvasHandle } from "./webgpuCanvasTypes";
+export type { BackingSize, DprPolicy } from "../webgl/createCanvasLifecycle.js";
+export type { WebGPUSuspendReason, WebGPUCanvasFrame, WebGPUCanvasOptions, WebGPUCanvasHandle, } from "./webgpuCanvasTypes.js";
+import type { WebGPUCanvasOptions, WebGPUCanvasHandle } from "./webgpuCanvasTypes.js";
 /**
  * The ONE `navigator.gpu` capability probe (the single-bootstrap rule — mirrors
  * `probeWebGL2Renderer`). SSR-safe (returns `false` with no `navigator`). The picker

package/dist/composables/glass/webgpu/webgpuCanvasTypes.d.ts

@@ -1,4 +1,4 @@
-import type { BackingSize, DprPolicy } from "../webgl/createCanvasLifecycle";
+import type { BackingSize, DprPolicy } from "../webgl/createCanvasLifecycle.js";
 export type WebGPUSuspendReason = "tab-hidden" | "off-screen" | "off-screen-io" | "manual";
 /**
  * The per-frame hooks a consumer's `setup(device, context, format)` returns. The
@@ -15,12 +15,11 @@ export interface WebGPUCanvasFrame {
     /** Demand-gate: is there live motion to render next frame? `false` → park. */
     shouldContinue: () => boolean;
     /**
-     * Upload the backing geometry.: when a `dprPolicy` is
-     * supplied the leaf sizes the backing + passes the live `BackingSize` here (the
-     * WGSL swap chain auto-tracks the backing, so the consumer body shrinks to an aspect
-     * upload). The arg is optional so a legacy self-measuring consumer keeps compiling.
+     * Upload the backing geometry: the leaf sizes the backing + passes the live
+     * `BackingSize` here (the WGSL swap chain auto-tracks the backing, so the consumer
+     * body is an aspect upload).
      */
-    resize: (s?: BackingSize) => void;
+    resize: (s: BackingSize) => void;
     /** Frame time from elapsed seconds — the consumer owns frozen/reduced-motion. */
     time?: (elapsedSec: number) => number;
     /** Release per-instance GPU resources (pipelines/buffers/bind groups). Runs on dispose + before a restore re-setup. */
@@ -43,12 +42,11 @@ export interface WebGPUCanvasOptions {
      */
     respectReducedMotion?: boolean;
     /**
-     * The consumer's DPR policy. When present the
-     * leaf sizes the backing SYNCHRONOUSLY at mount (via `presize`, BEFORE the async
-     * device acquire — the ≤6s blurry-flash close) and hands the live `BackingSize` to
-     * `resize(s)`. When ABSENT the legacy path runs (the consumer self-measures).
+     * The consumer's DPR policy. REQUIRED: the leaf sizes the backing SYNCHRONOUSLY at
+     * mount (via `presize`, BEFORE the async device acquire — the ≤6s blurry-flash
+     * close) and hands the live `BackingSize` to `resize(s)`.
      */
-    dprPolicy?: DprPolicy;
+    dprPolicy: DprPolicy;
     /** Compose the leaf IO park. Default `false`; see createCanvasLifecycle. */
     composeIntersectionPark?: boolean;
     /** `rootMargin` for the leaf IO park. */

package/dist/composables/glass/webgpu/webgpuDevice.d.ts

@@ -39,23 +39,6 @@ export declare class WebGPUInitError extends Error {
  * across UAs); a throwing read is morally "cannot prove software" → keep WebGPU.
  */
 export declare function isSoftwareWebGPUAdapter(adapter: GPUAdapter): boolean;
-/**
- * The bound on the adapter/device acquisition (ms). The adapter/device request can
- * resolve NEITHER way on a hanging host (a headless, virtualized-Metal + some-Chrome
- * class). A REAL cold acquire on a healthy Metal-3 host was live-measured at ~3478ms
- * (the FIRST device request on a cold GPU process) — well over a tight 2500ms
- * ceiling, which would convert a slow-but-fine cold acquire into a FALSE hang so the WGSL
- * primary never runs (every viz silently downgrading to WebGL2 — the
- * Safari-primary surface masked by the
- * always-winning fallback). 6000ms lets the real cold acquire through while a genuine
- * wedge (a device that never settles) still falls to the WebGL2 net before the user
- * perceives a permanent blank. With the SHARED device warm the ceiling is hit at most
- * ONCE per page, not N-times-per-canvas — a single ≤6s race, never N.
- *
- * homed in this device-acquisition-support leaf beside the typed
- * failure signal it throws. The substrate re-imports + re-exports it.
- */
-export declare const WEBGPU_ACQUIRE_TIMEOUT_MS = 6000;
 /**
  * Race a WebGPU acquisition promise against a timeout. On a hang the timeout wins and
  * rejects with the recognized typed `acquire-timeout` signal (the picker falls to the

package/dist/composables/keyboard/index.d.ts

@@ -1 +1 @@
-export * from "./useKeyboardShortcuts";
+export * from "./useKeyboardShortcuts.js";

package/dist/composables/motion/core/constants.d.ts

@@ -16,3 +16,10 @@ export declare const SNAP_THRESHOLD: {
     readonly dom: 0.05;
     readonly domProgress: 0.5;
 };
+/**
+ * One frame at 60fps, in milliseconds. The display's own beat, which is why it is
+ * shared rather than derived twice: an integrator's first-frame `dt` (before there is
+ * a previous timestamp to difference) and a "this outlives that by N frames" floor are
+ * the same number for the same reason. Anything that means "one frame" reads this.
+ */
+export declare const FRAME_MS: number;

package/dist/composables/motion/core/index.d.ts

@@ -1,21 +1,21 @@
-export * from "./constants";
-export * from "../reveal/useStaggerReveal";
-export * from "../reveal/useStagger";
-export * from "../scroll/useScrollProgress";
-export * from "./useRAFLoop";
-export * from "./useReducedMotion";
-export * from "./useIntersectionPause";
-export * from "./useYieldToMain";
-export * from "./useViewTransition";
-export * from "../reveal/vReveal";
-export * from "../reveal/useTextHighlight";
-export * from "../spring/useLiquidFlex";
-export * from "../morph/useLeadTrail";
-export * from "../pointer/usePointerVelocityField";
-export * from "../pointer/useRoutePointer";
-export * from "../pointer/pointerFieldMappings";
-export * from "../scroll/useScrollTrigger";
-export * from "../scroll/useScrollChrome";
-export * from "./writeVelocityWeight";
-export * from "../morph/useSelectionIndicator";
-export * from "../morph/useSelectionGroup";
+export * from "./constants.js";
+export * from "../reveal/useStagger.js";
+export * from "../scroll/useScrollProgress.js";
+export * from "./useRAFLoop.js";
+export * from "./useReducedMotion.js";
+export * from "./useIntersectionPause.js";
+export * from "./useYieldToMain.js";
+export * from "./useViewTransition.js";
+export * from "../route/routeGrammar.js";
+export * from "../route/useRouteTransition.js";
+export * from "../dissolve/dissolveGrammar.js";
+export * from "../reveal/vReveal.js";
+export * from "../spring/useLiquidFlex.js";
+export * from "../pointer/usePointerVelocityField.js";
+export * from "../pointer/useRoutePointer.js";
+export * from "../pointer/pointerFieldMappings.js";
+export * from "../scroll/useScrollTrigger.js";
+export * from "../scroll/useScrollChrome.js";
+export * from "./writeVelocityWeight.js";
+export * from "../morph/useSelectionIndicator.js";
+export * from "../morph/useSelectionGroup.js";

package/dist/composables/motion/core/motionTempo.d.ts

@@ -1,5 +1,3 @@
-/** The identity tempo — no time scaling (the `@property` initial-value). */
-export declare const MOTION_TEMPO_IDENTITY = 1;
 /**
  * Read the effective `--motion-tempo` off `el` (or `:root` when omitted). Returns a
  * positive multiplier (the identity `1` off-DOM, on a malformed value, or on any

package/dist/composables/motion/dissolve/dissolveGrammar.d.ts

@@ -0,0 +1,88 @@
+/** The five dialects, by the name each is known by in the codex table. */
+export type DissolveDialect = "auto-expiry" | "flicked" | "miniaturize" | "row-dissolve" | "vaporize";
+/**
+ * A row states what the dialect IS, who ended it, and which roster row owns the surface
+ * that speaks it. It carries no figures: a dialect that this library has not built has no
+ * constants to carry, and the one it HAS built keeps its constants in
+ * `VAPORIZE_CONSTANTS` below, where the CSS mirror reads them.
+ */
+export interface DissolveDialectRow {
+    readonly dialect: DissolveDialect;
+    /** Who ended it — the selector the codex row rules by ("who ended it selects the dialect"). */
+    readonly endedBy: "timer" | "gesture" | "system" | "user";
+    /** Built by THIS library today, or named-and-routed. */
+    readonly built: boolean;
+    /** The roster row that owns the surface speaking it. */
+    readonly owner: string;
+    readonly comment: string;
+}
+/** The table. Reading order is the codex row's, not a precedence. */
+export declare const DISSOLVE_DIALECTS: readonly DissolveDialectRow[];
+/** Look one dialect up by name. */
+export declare function dissolveDialect(dialect: DissolveDialect): DissolveDialectRow;
+/**
+ * The vaporize's measured constants, carried in ONE table.
+ *
+ * `channelRatio` traces to `IOS27-ARCHIVE.md` §4b: saturation, dim and blur reach 95% of
+ * their released values at 184 / 250 / 317 ms — 1 : 1.36 : 1.72, monotone, ease-out, zero
+ * overshoot on any channel, saturation always first and blur always last. The absolutes
+ * are the archive's device; the ratio is the mechanism, and it is the ratio we keep.
+ *
+ * The other three are TR#30's amendments, stated there verbatim: the ink collapses by 40%
+ * of the travel, its alpha floors at 0.30 on the way, and its blur peaks at half the
+ * element's own height. `transform-free` and `the backdrop outlives the panel by two
+ * frames` are the amendments that are structural rather than numeric — the first is an
+ * absence the arms check, and the second is a FLOOR the ratio already clears (see
+ * `backdropOutlivesPanel`).
+ */
+export declare const VAPORIZE_CONSTANTS: {
+    /** §4b: sat : dim : blur = 1 : 1.36 : 1.72, saturation first, blur last. */
+    readonly channelRatio: {
+        readonly saturate: 1;
+        readonly dim: 1.36;
+        readonly blur: 1.72;
+    };
+    /** Amendment: the ink's collapse completes at 40% of the travel. */
+    readonly inkCollapseFraction: 0.4;
+    /** Amendment: the ink's alpha floors at 0.30 where the collapse completes. */
+    readonly inkOpacityFloor: 0.3;
+    /** Amendment: the ink's blur peaks at half the element's own block size. */
+    readonly inkBlurHeightRatio: 0.5;
+};
+/**
+ * The total travel is the BLUR channel's clock, because blur is always last. Every other
+ * clock in the recipe is this one times a ratio, so the recipe carries exactly one
+ * duration token and spends it.
+ */
+export declare function channelFraction(channel: keyof typeof VAPORIZE_CONSTANTS.channelRatio): number;
+/**
+ * Where the ink's blur peaks, as a fraction of the travel. The blur leads the fade by the
+ * SAME ratio the saturation leads the blur — the mechanism's one ratio, spent twice,
+ * rather than a second lead figure nobody measured.
+ */
+export declare function inkBlurFraction(): number;
+/**
+ * The panel — plate, rim and cast — is gone when the DIM channel lands; the backdrop's
+ * blur runs on to the end. This is "the backdrop outlives the panel by two frames" stated
+ * as what it is: a floor, in milliseconds, that a given travel either clears or does not.
+ * At the shipped travel it clears it several times over, and the arm checks the arithmetic
+ * rather than a remembered millisecond. The frame the floor is counted in is the shared
+ * `FRAME_MS` (`motion/core/constants.ts`) — this table mints no second one.
+ */
+export declare function backdropOutlivesPanel(travelMs: number): number;
+/**
+ * The corner affordance's placement, from `IOS27-ARCHIVE.md` §3 as adjudicated by CWT O-10
+ * (`:1293`): the disc's centre sits ON the element's corner point, nudged inward by ~6.5%
+ * of its own diameter, so about 70% of it floats free and it visually rests on the corner
+ * arc. `offset` is what both insets take, in units of the diameter — negative, because the
+ * disc hangs outside the box. The diameter itself is 0.42 × a SQUARE host's edge; a
+ * non-square host names its own, which is why `size` is a knob and not a derivation.
+ */
+export declare const CORNER_AFFORDANCE: {
+    /** §3: diameter = 0.42 × the element's edge length (25.3pt on a 60pt icon). */
+    readonly edgeRatio: 0.42;
+    /** §3: the centre is nudged inward by ~6.5% of the disc's own diameter. */
+    readonly inwardNudge: 0.065;
+};
+/** The inset both axes take, in units of the diameter. Negative: the disc hangs out. */
+export declare function cornerAffordanceOffset(): number;

package/dist/composables/motion/engage/engageEnvelopes.d.ts

@@ -0,0 +1,45 @@
+/** An engagement-envelope role name. */
+export type EngageRole = "press-drain" | "medium-exit" | "control-engage" | "signal-decay";
+/** One envelope row: the (attack, release) time constants + who rides it. */
+export interface EngageEnvelopeRow {
+    /** The role this envelope serves — the lookup key. */
+    readonly role: EngageRole;
+    /** τ_up: the first-order attack time constant in ms (the shared acknowledge class). */
+    readonly attackMs: number;
+    /** τ_down: the release time constant in ms. Always slower than the attack. */
+    readonly releaseMs: number;
+    /** The named surface this row was measured on — one rider per row. */
+    readonly rider: string;
+    /** The register this envelope serves. */
+    readonly comment: string;
+}
+/**
+ * The ONE press-acknowledge attack class every role shares. Attacks do not vary by
+ * role — an acknowledge is an acknowledge — so the class is a BAND that every row's
+ * τ_up must sit inside, not a per-row invention. Releases are where the roles differ:
+ * that is what makes a drain feel like a cancel and a decay feel like a level falling.
+ */
+export declare const ENGAGE_ATTACK_CLASS: {
+    readonly minMs: 40;
+    readonly maxMs: 60;
+};
+/**
+ * The acknowledge window: a press must be visibly answered within this budget, measured
+ * as the envelope's t90 rather than its time constant. The class band above is drawn so
+ * that even its slowest attack lands inside this window.
+ */
+export declare const ACKNOWLEDGE_WINDOW_MS = 150;
+/**
+ * The engagement envelopes. No envelope constant may be minted outside this table: a
+ * new engagement earns a new ROW here, never a literal at a call site. That is the same
+ * no-second-authority rule the spring table holds, for the channel springs do not own.
+ */
+export declare const ENGAGE_ENVELOPES: readonly EngageEnvelopeRow[];
+/** Look one engagement envelope up by role. */
+export declare function engageEnvelope(role: EngageRole): EngageEnvelopeRow;
+/**
+ * The role's acknowledge time — when the attack reaches 90% of its target. A first-order
+ * envelope's t90 is `τ·ln(10)`; it is DERIVED here so the acknowledge budget is checked
+ * against the shipped time constant rather than against a remembered millisecond figure.
+ */
+export declare function engageAttackT90Ms(role: EngageRole): number;