@mkbabb/glass-ui 6.0.0 → 7.0.0

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

@@ -6,26 +6,25 @@ export interface OklchStop {
 }
 /**
  * A color seam: resolves a CSS color string to a GAMMA-sRGB triple in [0,1].
- * `defaultBlobColorResolver` is the shipped default. A general-purpose injection
+ * `defaultBlobColorResolver` is the default. A general-purpose injection
  * type — the `<FourierField>` background takes it as a REQUIRED `colorResolver`
  * prop (the SVG-field surface owns its own color pipeline). The goo-blob no longer
  * injects it: it resolves color internally through `cssToOklch → oklchToGammaRgb`
- * (W-BLOB3 STRIPPED the speculative DI built for an absent value.js consumer that
- * never repatriated).
+ * without dependency injection.
  */
 export type ColorResolver = (css: string) => [number, number, number];
 /**
  * OKLCh stop → LINEAR-sRGB in [0,1] — aurora's bundle-canonical bake target (the
  * shader ACES-tonemaps in linear, so the LUT stays linear).
  *
- * value.js's canonical Ottosson path (`rawOklchToOklab → oklabToLinearSRGB`,
- * inv-K-2). The `Math.max(0,·)` wrap is the ACES-in-linear contract — value.js
+ * value.js's canonical `oklch → convertColor(…, "srgb-linear")` path. The
+ * `Math.max(0,·)` wrap is the ACES-in-linear contract — value.js
  * does not clamp negative linear (an out-of-gamut stop yields negatives; the wrap
  * keeps them off the GPU). The equivalence canary asserts the COMPOSED path.
  */
 export declare function oklchToLinear(stop: OklchStop): [number, number, number];
 /**
- * Warm-white catch-light → LINEAR-sRGB triple (AX.W11). The OKLCh-principled light
+ * Warm-white catch-light to linear-sRGB triple. The OKLCh-principled light
  * tint the painterly relight (aurora's impasto sheen, the blob's `warmCream`) adds
  * in LINEAR light — one shared OKLCh derivation both surfaces' light models route
  * through instead of an eyeballed sRGB-ish literal. Just `oklchToLinear({L,C,h})`
@@ -33,42 +32,39 @@ export declare function oklchToLinear(stop: OklchStop): [number, number, number]
  * the literature prescribes is "the catch-light is a warm, near-white OKLCh anchor").
  *
  * Aurora's default anchor is `(0.985, 0.0125, 77.5°)` — the OKLCh anchor that
- * reproduces the prior eyeballed `[1.0, 0.95, 0.88]` warm-white to <1e-3 linear (so
- * the live relight reads identically; the seam fix is invisible to the eye). The
+ * approximates `[1.0, 0.95, 0.88]` warm white to <1e-3 linear. The
  * blob's `warmCream` anchor is `(0.97, 0.03, 85°)` — a deeper, more-saturated cream;
- * W15 re-routes the blob default through THIS helper at that anchor (the cross-surface
- * unification: ONE OKLCh derive, each surface its own principled anchor).
+ * Blob uses this helper at that anchor: one OKLCh derivation with a principled
+ * anchor per surface.
  *
  * An invalid (non-finite) anchor THROWS — a library-internal contract violation, not
  * a silent grey return (the fail-explicit precept; a stale anchor must surface loud).
  */
 export declare function warmCatchLight(L: number, C: number, hDeg: number): [number, number, number];
 /**
- * OKLCh stop → GAMMA-sRGB in [0,1] — the blob's faithful-lift exit (DEC-AT-7's W7
- * GAMMA space). value.js's `oklabToRgb255` returns gamma-encoded 0..255 (HSV/sRGB,
- * no extra OETF); divide to [0,1]. The blob's default resolver returns THIS space
- * so the W7 lift paints at parity (the LINEAR shader-quality flip + `linearToSrgb`
- * is the AU.W7 stage). Channels are clamped to [0,1] (an out-of-gamut stop is
+ * OKLCh stop → gamma-encoded sRGB in [0,1]. value.js's `toRgba8` returns clipped
+ * gamma-encoded 0..255; divide
+ * to [0,1]. The blob's default resolver returns THIS space
+ * so Blob paints in the intended output space. Channels are clamped to [0,1]
+ * (an out-of-gamut stop is
  * already gamut-mapped upstream; this is the float-edge guard).
  */
 export declare function oklchToGammaRgb(stop: OklchStop): [number, number, number];
 /**
  * Resolve any CSS color string to an OKLCh stop via value.js's parser — the single
- * canonical core (inv-K-2). DOM-free (SSR / happy-dom safe — no 1×1-canvas).
+ * canonical core. DOM-free and safe for SSR and happy-dom.
  *
- * Semantics: an INVALID string THROWS; ALPHA is dropped (OklchStop has no alpha);
- * out-of-gamut inputs are NOT byte-clamped. Callers feeding user / possibly-
- * transparent strings should wrap in try/catch and decide an alpha policy.
+ * Invalid, contextual, and non-opaque inputs throw one `GlassColorError` carrying
+ * the parser diagnostics or the named local alpha failure. No catch-to-default
+ * recovery occurs at this boundary.
  */
 export declare function cssToOklch(css: string): OklchStop;
-/** OKLCh stop → `#rrggbb` gamma hex (value.js `oklabToRgb255`). */
+/** OKLCh stop → `#rrggbb` gamma hex through value.js `toRgba8`. */
 export declare function oklchStopToHex(s: OklchStop): string;
 /**
- * The shipped default `ColorResolver` — `(css) => gamma [r,g,b]` via
- * `cssToOklch → oklchToGammaRgb` (the GAMMA exit; `proof:blob-space-gamma` witnesses
- * the `oklchToGammaRgb` resolve). The `<FourierField>` background passes THIS as its
- * `colorResolver` prop. The goo-blob inlines this exact body internally (W-BLOB3 —
- * no DI seam).
+ * Default `ColorResolver`: `(css) => gamma [r,g,b]` through
+ * `cssToOklch → oklchToGammaRgb`. `<FourierField>` can pass it as its
+ * `colorResolver`; Blob uses the same body internally without a DI seam.
  */
 export declare const defaultBlobColorResolver: ColorResolver;
 /**
@@ -85,16 +81,13 @@ export declare const defaultBlobColorResolver: ColorResolver;
 export type ColorHarmony = "analogous" | "complementary" | "split-complementary" | "triad" | "tetradic" | "monochrome";
 /**
  * Hue per harmony, walked across the ramp parameter `t` (0..1) THROUGH value.js's
- * `interpolateHue` in the NORMALIZED-TURNS domain (`/360` in, `*360` out — value.js
- * takes turns [0,1], NOT degrees; the `.5` short-arc threshold is a half-TURN). The
- * single canonical hue-walk both backdrops consume.
+ * degree-domain `interpolateHue`. The single canonical hue-walk both backdrops
+ * consume.
  */
 export declare function deriveHue(anchorHue: number, harmony: ColorHarmony, hueSpread: number, t: number): number;
 /**
- * Gamut-map one OklchStop through value.js's Ottosson core
- * (`rawOklchToOklab → gamutMapOKLab → rawOklabToOklch`) with a bounded inward-chroma
- * nudge for the over-1 hull-placement escape. Hue is preserved exactly; the result
- * is in-sRGB to the pipeline's tolerance. The single gamut-mapper both backdrops use.
+ * Gamut-map one OklchStop through value.js's final-object `mapColorToGamut`.
+ * The single gamut-mapper both backdrops use.
  */
 export declare function gamutMapStop(stop: OklchStop): OklchStop;
 /** Tuning for {@link deriveBlobPalette}. */
@@ -110,29 +103,29 @@ export interface DeriveBlobPaletteOptions {
     /** Midpoint chroma-bump (keeps a vivid pair off the grey midpoint). Default ~0.03. */
     chromaBump?: number;
     /**
-     * AY.W-COHERE E1 — the OKLCh-chroma CEILING on every derived stop (OKLCh C
+     * The OKLCh-chroma CEILING on every derived stop (OKLCh C
      * units). When set, each stop's chroma is clamped to AT MOST this value AFTER
      * the midpoint bump and BEFORE the gamut-map — so the seed→palette derivation
      * can never amplify a vivid seed into the neon register the shader's
      * SSS/iridescence then over-drives. This is a CHROMA CAP, not a hue re-map: a
      * blue seed stays blue, just bounded to the non-neon chroma. `undefined` (the
-     * default) leaves the derivation byte-identical to HEAD. The blob substrate
+     * default) leaves the derivation unchanged. The blob substrate
      * caps the MOOD/seed path into the warm-register band the FourierField comet +
      * the constellation focal share (the set-cohesion accent identity).
      */
     chromaCeiling?: number;
     /**
-     * BG.W-BLOB-SATELLITE-SHADE (F9.R1 — the `uSatColor[]` companion) — pin the BODY
+     * Pin the body
      * stop's OKLCh lightness. The default ramp centres L on the seed
      * (`anchor.L - lightnessSpread/2` at the body, climbing `lightnessSpread` to the
      * lightest satellite). When set, the body stop (t=0) anchors at exactly this L and
      * the satellites still climb `lightnessSpread` from it — so a consumer picks the
      * body luminance directly (the deep-body read) without moving the seed hue/chroma.
-     * `undefined` (the default) leaves the derivation byte-identical to HEAD.
+     * `undefined` (the default) leaves the derivation unchanged.
      */
     bodyLightness?: number;
     /**
-     * BG.W-BLOB-SATELLITE-SHADE (F9.R1) — the OKLCh-lightness FLOOR on every derived
+     * the OKLCh-lightness FLOOR on every derived
      * stop. Replaces the hardcoded `0.05` low clamp, so a consumer guarantees no stop
      * reads darker than this (a body/satellite that never collapses toward black). The
      * `0.98` high clamp is untouched. `undefined` → the byte-identical `0.05` floor.
@@ -141,7 +134,7 @@ export interface DeriveBlobPaletteOptions {
 }
 /**
  * Seed ONE color into a harmonious, gamut-safe 2-4-stop OKLCh palette for the blob
- * — the blob-side twin of `deriveAurora`, consuming the SHARED `ColorHarmony`
+ * the blob-side twin of `deriveAurora`, consuming the SHARED `ColorHarmony`
  * vocabulary (no forked `deriveHue`). The body takes the deepest/most-saturated
  * stop; satellites take the lighter in-family stops. Every stop is gamut-mapped.
  * Deterministic + DOM-free (SSR-safe; `cssToOklch` parses via value.js).

package/dist/composables/color/useAccentTone.d.ts

@@ -1,8 +1,5 @@
 import { type ComputedRef, type MaybeRefOrGetter } from "vue";
 export interface UseAccentToneOptions {
-    /** Idle fill strength (0..1). Default 0.08. The CSS `--accent-fill-strength`
-     *  twin — passed here so the JS ink-solve composites the matching band. */
-    fillStrength?: number;
     /** Active band strength (0..1). Default 0.18 (the CSS `--accent-band-strength`). */
     bandStrength?: number;
     /** Target ink-over-band contrast. Default 4.5 (AA). */

package/dist/composables/color/value.d.ts

@@ -0,0 +1,21 @@
+import { type Alpha, type Color, type ColorIssue, type Result } from "@mkbabb/value.js/color";
+import { type CssColor, type ParseIssue } from "@mkbabb/value.js/css";
+type LocalColorIssue = Readonly<{
+    code: "color_non_opaque";
+    alpha: Alpha;
+}>;
+/** The single Glass-domain failure for its Value color boundary. */
+export declare class GlassColorError extends Error {
+    readonly operation: string;
+    readonly details: ColorIssue | LocalColorIssue | readonly ParseIssue[];
+    constructor(operation: string, details: ColorIssue | LocalColorIssue | readonly ParseIssue[]);
+}
+export declare function colorValue<T>(operation: string, result: Result<T, ColorIssue>): T;
+export declare function opaqueCssColor(source: string, operation: string): CssColor;
+export declare function oklchColor(stop: {
+    L: number;
+    C: number;
+    h: number;
+}): Color<"oklch">;
+export declare function numericChannel(value: number | "none", operation: string): number;
+export {};

package/dist/composables/context/createContext.d.ts

@@ -2,7 +2,7 @@ import { type InjectionKey } from "vue";
 /**
  * Domain-neutral provide/inject DI factory pair — the single source the dock,
  * dock-layer-group, toggle-group, sortable-list, and configurator
- * contexts collapse onto (AV.W14). Generalizes the four hand-rolled
+ * contexts collapse onto. Generalizes the four hand-rolled
  * provide/inject/throw triplets into ONE typed factory so a `*_KEY:
  * InjectionKey<T>` declaration + its `provide`/`use`/throw boilerplate is never
  * re-rolled per call site — each site keeps only its distinct `interface`,
@@ -18,7 +18,7 @@ import { type InjectionKey } from "vue";
  *  - `createOptionalContext<T>(label)` — a `use()` that returns `T | null`
  *    (befitting-silent; the consumer renders bare when no provider is present).
  *    No strict counterpart is minted — a strict throw would be dead code at
- *    these sites (invariant 25's "per intent" clause).
+ *    these sites (the "per intent" clause).
  *
  * The returned `KEY` is exported by each call site so an external provider can
  * `provide(KEY, …)` directly (the goo-blob `BLOB_CONFIG_KEY` external-provide

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

@@ -1,5 +1,5 @@
 export { useGlobalDark } from "./useGlobalDark";
-export type { UseGlobalDarkOptions, UseGlobalDarkReturn, DarkFlipSettledCallback, } from "./useGlobalDark";
+export type { GlobalColorSchema, UseGlobalDarkOptions, UseGlobalDarkReturn, DarkFlipSettledCallback, } from "./useGlobalDark";
 export { installDarkModeSync } from "./installDarkModeSync";
 export { darkModeSyncScript, DARK_MODE_STORAGE_KEY } from "./darkModeSyncScript";
 export type { DarkModeSyncScriptOptions } from "./darkModeSyncScript";

package/dist/composables/dark/useGlobalDark.d.ts

@@ -1,15 +1,16 @@
-import type { BasicColorSchema } from "@vueuse/core";
 import { type Ref, type WritableComputedRef } from "vue";
+/** Stable color-scheme seed accepted by the shared dark-mode controller. */
+export type GlobalColorSchema = "auto" | "light" | "dark";
 /**
  * A post-flip settle callback. Receives the dark-mode flag's NEW value. Runs in
  * the single coalesced post-flip task (see `onFlipSettled`).
  */
 export type DarkFlipSettledCallback = (isDark: boolean) => void;
 /**
- * The `useGlobalDark` return shape (AW.W15 — named `Use<Name>Return`). The
+ * The `useGlobalDark` return shape. The
  * single shared dark-mode instance: the reactive `isDark` flag, a `toggleDark`
  * that optionally suppresses transitions, the transition-suppression switch, and
- * the post-flip settle hook (BA.W-ATLAS-RECONCILE A-1 — d6 9467bd16 adopt).
+ * the post-flip settle hook.
  */
 export interface UseGlobalDarkReturn {
     /** Reactive dark-mode flag (vueuse `useDark` ref — writable). */
@@ -21,9 +22,9 @@ export interface UseGlobalDarkReturn {
     /** Configure transition suppression during the dark-mode toggle. */
     setDisableTransitions: (value: boolean) => void;
     /**
-     * BA.W-ATLAS-RECONCILE A-1 — the post-flip SETTLE hook. Register a callback
+     *  A-1 — the post-flip SETTLE hook. Register a callback
      * that runs in ONE coalesced task AFTER each dark↔light flip's instant chrome
-     * paint, so consumers BATCH N expensive re-theme operations (e.g. the atlas's
+     * paint, so consumers BATCH N expensive re-theme operations (e.g. a consumer's
      * palette memo + N-chart `merge-setOption` palette tween + aurora
      * re-derivation) into a single beat instead of N watchers firing in N
      * sequential storms on the critical frame. The class toggle is synchronous
@@ -47,7 +48,7 @@ export interface UseGlobalDarkOptions {
      * Pair with `darkModeSyncScript()` so the parse-time `<head>` script and this
      * runtime seed agree.
      */
-    initialValue?: BasicColorSchema;
+    initialValue?: GlobalColorSchema;
 }
 /**
  * The single shared dark-mode instance. The first call may pass an

package/dist/composables/dom/useBreakpoint.d.ts

@@ -18,9 +18,9 @@ export interface UseBreakpointControls {
  * permanently-`false` ref. Consumers should treat the initial frame as
  * "mobile-first / narrow-default" because the matchMedia subscription only
  * mounts client-side. This is the same shape consumers wrote by hand at the
- * speedtest origin sites.
+ * consumer origin sites.
  *
- * Why this exists (speedtest origin, glass-ui promotion W6-β): the survey
+ * Why this exists (promoted from a consumer): the survey
  * cockpit (`SurveyWizard.vue`) and the admin data-source toggle
  * (`AdminDataSourceToggle.vue`) both hand-rolled the same `matchMedia`
  * subscribe-on-mount + tear-down-on-unmount pattern. Two hand-rolls of one

package/dist/composables/dom/useClipboard.d.ts

@@ -1,68 +1,44 @@
-import { type Ref } from "vue";
-/**
- * Why a copy did not succeed. `'clipboard-api'` — the async
- * `navigator.clipboard.writeText` channel threw or rejected; `'exec-command'`
- * — the legacy `document.execCommand("copy")` fallback returned/threw failure;
- * `'no-api'` — neither channel exists in this environment (SSR / locked-down).
- */
-export type CopyFailureReason = "clipboard-api" | "exec-command" | "no-api";
+import { type ComputedRef } from "vue";
+export type CopyFailureReason = "clipboard-api" | "no-api";
+export type ClipboardStatus = "idle" | "pending" | "success" | "failure";
 export interface UseClipboardOptions {
-    /** Milliseconds before `copied` auto-resets to `false` (default 1500). */
+    /** Milliseconds before a successful copy resets to `idle` (default 1500). */
     resetMs?: number;
     /**
-     * Called with the NAMED reason when a copy attempt fails on a given
-     * channel. Both the clipboard-API and exec-command arms report through this
-     * (the exec-command arm only after the clipboard-API arm has already
-     * failed). Surfaces the failure instead of swallowing it.
+     * Optional watchdog: a write that has not settled within this many ms is
+     * reported as a `clipboard-api` failure (some platforms leave `writeText`
+     * pending forever). Default: no timeout.
      */
+    timeoutMs?: number;
+    /** Called when the current active copy attempt fails. */
     onCopyError?: (reason: CopyFailureReason) => void;
 }
-/** Result of a composable `copy()` — the success flag plus, on failure, the
- *  named reason the copy did not land. */
-export interface CopyResult {
-    ok: boolean;
-    /** The failure channel when `ok` is false; `undefined` on success. */
-    reason?: CopyFailureReason;
-}
+/** A failed copy always names its channel; a successful copy carries no reason. */
+export type CopyResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: CopyFailureReason;
+};
 export interface UseClipboardReturn {
-    /** Reactive flag—flips `true` on successful copy, auto-resets after `resetMs`. */
-    copied: Ref<boolean>;
-    /**
-     * Copy `text` to the clipboard. Resolves `{ ok }` on success or
-     * `{ ok: false, reason }` naming the channel that failed — the failure is
-     * REPORTED, never silently swallowed.
-     */
+    /** The current active attempt's complete feedback state. */
+    status: ComputedRef<ClipboardStatus>;
+    /** Copy `text`, returning a named failure when the platform rejects it. */
     copy: (text: string) => Promise<CopyResult>;
+    /** Invalidate pending or settled feedback because its payload is no longer current. */
+    invalidate: () => void;
 }
 /**
- * Bare clipboard copy—stateless `Promise<boolean>` return, no reactive `copied`
- * flag. Use this when call sites manage their own confirmation state (e.g.
- * hand-rolled `ref + setTimeout`) or in non-component contexts (utility
- * modules, stores). A copy failure is reported through `options.onCopyError`
- * (the boolean return stays the verbatim cross-repo signature).
- *
- * @example
- * import { copyToClipboard } from "@mkbabb/glass-ui";
- *
- * async function shareLink(url: string) {
- *   const ok = await copyToClipboard(url, {
- *     onCopyError: (reason) => toast.show(`Copy failed: ${reason}`),
- *   });
- *   if (ok) toast.show("Link copied");
- * }
+ * Stateless one-shot clipboard write — the honest primitive shared by
+ * `useClipboard` and by consumers that own their own feedback. Returns the
+ * discriminated result (`{ ok }` / `{ ok, reason }`) rather than a lossy
+ * boolean, for identical call ergonomics: `const { ok } = await writeClipboard(text)`.
  */
-export declare function copyToClipboard(text: string, options?: UseClipboardOptions): Promise<boolean>;
+export declare function writeClipboard(text: string): Promise<CopyResult>;
 /**
- * Reactive clipboard copy with auto-reset confirmation flag.
- *
- * @example
- * const { copied, copy } = useClipboard();
- * <button @click="copy(value)">
- *   {{ copied ? "Copied" : "Copy" }}
- * </button>
+ * Reactive clipboard copy with scope-owned confirmation state.
  *
  * @example
- * // Custom reset window (e.g. for paired toast feedback):
- * const { copied, copy } = useClipboard({ resetMs: 2000 });
+ * const { status, copy } = useClipboard({ resetMs: 2000 });
  */
 export declare function useClipboard(options?: UseClipboardOptions): UseClipboardReturn;

package/dist/composables/dom/useDocumentVisibility.d.ts

@@ -1,6 +1,6 @@
 import { type Ref } from "vue";
 /**
- * Scope-aware `document.visibilityState` leaf (AV.W14) — the single source for
+ * Scope-aware `document.visibilityState` leaf: the single source for
  * the `visibilitychange → document.hidden` pattern that the motion composables
  * (`useRAFLoop`, `useIntersectionPause`) and the WebGL substrate hand-rolled
  * four times over. Returns a `Ref<boolean>` `hidden` that flips on
@@ -16,5 +16,7 @@ import { type Ref } from "vue";
 export interface UseDocumentVisibilityReturn {
     /** Reactive `document.hidden` — `false` under SSR / when the API is absent. */
     hidden: Ref<boolean>;
+    /** Detach the visibility listener before scope teardown. */
+    dispose: () => void;
 }
 export declare function useDocumentVisibility(): UseDocumentVisibilityReturn;

package/dist/composables/dom/useIdleReady.d.ts

@@ -2,8 +2,8 @@ import { type Ref } from "vue";
 export interface UseIdleReadyOptions {
     /**
      * `requestIdleCallback` timeout, in ms. Default 2_000 — the canonical
-     * value at every speedtest hand-rolled site (App.vue + useIPInfo both
-     * pass `{ timeout: 2000 }`). Unlike useViewportReady's 10s (which fronts
+     * value at every hand-rolled consumer site (consumers pass
+     * `{ timeout: 2000 }`). Unlike useViewportReady's 10s (which fronts
      * the budget with an IO gate), useIdleReady has no visibility stage, so
      * the timeout is the only ceiling — 2s matches the consumer sites and
      * keeps the deferred work inside a reasonable post-paint window.
@@ -50,10 +50,9 @@ export interface UseIdleReadyControls {
  * a composable not a component). SSR / non-browser flips synchronously so
  * consumers don't stall.
  *
- * Why this exists (speedtest origin, glass-ui promotion AO.W3): the gate is
- * hand-rolled at 5 speedtest sites (App.vue, MapView.vue, DashboardMap.vue,
- * useAutoStart.ts, useIPInfo.ts) — the ≥2-consumer substrate-promotion gate
- * (J inv 10 / L inv 8) fires for a publisher-side absorption.
+ * This gate is
+ * hand-rolled at 5 consumer sites — the ≥2-consumer substrate-promotion gate
+ * fires for a publisher-side absorption.
  *
  * @param options.timeout Default `2000` ms — forwarded to `requestIdleCallback`.
  * @param options.onReady Optional one-shot task run on the idle flip.

package/dist/composables/dom/useTokenColor.d.ts

@@ -1,6 +1,6 @@
 import { type MaybeRefOrGetter, type Ref } from "vue";
 /**
- * The resolver seam (AW.W15) — given a property name + the resolved element,
+ * Given a property name and resolved element,
  * return the property's value. Defaults to the live
  * `getComputedStyle(el).getPropertyValue(prop)` read; an injected resolver lets
  * SSR / tests close the DI loop without touching `document.documentElement`.
@@ -12,7 +12,7 @@ export interface UseTokenColorOptions {
     /** Fallback when the property is unset or `document` is unavailable (SSR). */
     fallback?: string;
     /**
-     * Injected property resolver (AW.W15 DI seam). Defaults to the live
+     * Injected property resolver. Defaults to the live
      * `getComputedStyle(el).getPropertyValue(prop)` read. Pass a custom resolver
      * for SSR / tests / a themed-context override without reaching the DOM.
      */

package/dist/composables/dom/useUserInvalidAria.d.ts

@@ -1,7 +1,6 @@
 /**
- * Options for {@link useUserInvalidAria}. Empty since the legacy
- * `fallbackClasses` knob was retired at BG.NF.2 W-LEGACY-LADDER-COLLAPSE
- * (`:user-invalid` is Baseline on the target set); the shape is kept as the
+ * Options for {@link useUserInvalidAria}. Empty because `:user-invalid` is
+ * Baseline on the target set (no `fallbackClasses` knob); the shape is the
  * canonical options seam for future extension.
  */
 export interface UseUserInvalidAriaOptions {

package/dist/composables/dom/useViewportReady.d.ts

@@ -31,7 +31,7 @@ export interface UseViewportReadyOptions {
     idleTimeout?: number;
     /**
      * IntersectionObserver `threshold`. Default 0.01 (1 % visible). Mirrors
-     * the speedtest origin-site semantic — "any pixel visible counts".
+     * the origin-site semantic — "any pixel visible counts".
      */
     threshold?: number;
 }
@@ -62,11 +62,11 @@ export interface UseViewportReadyControls {
  * disposal (mirrors `useResizeObserver` / `useInterval` upstream); outside
  * a scope callers receive the manual `stop()` control.
  *
- * Why this exists (speedtest origin, glass-ui promotion AJ.W6-α): both
+ * Both
  * `AdminOverviewView` and `ChartsView` shipped a near-identical `chartReady`
- * flag flipped by `requestIdleCallback` alone. The W3-R1 idiom in those
+ * flag flipped by `requestIdleCallback` alone. The idiom in those
  * sites — gate visibility first, then schedule rIC inside the IO callback —
- * is generic across heavy-widget hydration; the speedtest 2-consumer trigger
+ * is generic across heavy-widget hydration; the 2-consumer trigger
  * fired for a publisher-side absorption per `feedback_generic_components`.
  *
  * Usage:

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

@@ -14,9 +14,9 @@ export type BackgroundCanvasSource = HTMLCanvasElement | (() => HTMLCanvasElemen
 /** The downsample resolution for the animated-field read (a 32×32 mean). */
 export declare const SAMPLE_DOWNSAMPLE = 32;
 export declare const FIELD_ALPHA_FLOOR = 0.02;
-/** BG.W-FIELD-ACCENT-RECONCILE — the library convention marking the ONE shell
+/** Library convention marking the single shell
  *  field canvas (the recessive shell `<Aurora>` the demo chassis mounts behind every
- *  non-focal route; also the WS8 BACKDROP-SAMPLE marker). A glass surface that does
+ *  non-focal route; also the BACKDROP-SAMPLE marker). A glass surface that does
  *  NOT name an explicit `backgroundCanvas` auto-discovers this canvas so it samples
  *  the LIVE field rather than a static stack-walk; absent it (a focal route where the
  *  shell stands down, an SSR scope) the static `elementsFromPoint` path is the floor. */
@@ -31,10 +31,10 @@ export declare function resolveSourceCanvas(src: BackgroundCanvasSource | undefi
 /**
  * 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 —
+ * `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). BG.W-GLASS-SIGNAL-TRUTH: without this `sampleStatic`
+ * 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.
  */
@@ -42,8 +42,9 @@ export declare function normalizeToRgb(css: string, ctx: CanvasRenderingContext2
 /**
  * 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
- * (unrendered) field / a tainted canvas — the caller falls to the static stack-walk.
+ * rider over the SAME pixel pass). 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).
  */
 export declare function sampleAnimated(el: HTMLElement, source: HTMLCanvasElement | null, ctx: CanvasRenderingContext2D | null): SampleResult | null;
 /**

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

@@ -1,7 +1,8 @@
 import { type MaybeRefOrGetter } from "vue";
+import { type DprPolicy } from "../webgl/createCanvasLifecycle";
 /**
  * The suspend reasons that gate the loop. Twins the WebGL substrate's union
- * (`createCanvasLifecycle.CanvasSuspendReason`): the AX.W16 F6 `"off-screen-io"`
+ * (`createCanvasLifecycle.CanvasSuspendReason`): the `"off-screen-io"`
  * key is the IntersectionObserver fallback's OWN reason, distinct from the
  * content-visibility path's `"off-screen"`, so the two offscreen detectors never
  * cross-lift each other's suspend.
@@ -33,6 +34,11 @@ export interface Canvas2DOptions {
     respectReducedMotion?: boolean;
     /** `getContext("2d", …)` attributes. */
     contextAttrs?: CanvasRenderingContext2DSettings;
+    /**
+     * Backing-store DPR policy. Defaults to the existing Canvas2D ceiling:
+     * `min(devicePixelRatio, 2)`.
+     */
+    dprPolicy?: DprPolicy;
     /** IntersectionObserver `rootMargin` for the offscreen seam. Default `200px`. */
     rootMargin?: string;
 }

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

@@ -1,22 +1,20 @@
 /**
- * The ONE shared texture-upload primitive (BG.W-AUR-IMAGE-SOURCE).
+ * The ONE shared texture-upload primitive.
  *
  * A photo entering a dual-engine (WebGL2 + WebGPU) shader family has ONE genuine
- * cross-engine hazard: the WebGL2 and WebGPU uploads DIFFER on premultiply /
- * colour-space / flip-Y defaults (gpuweb #4356; Safari's
+ * cross-engine hazard: the WebGL2 and WebGPU uploads differ on premultiply,
+ * colour-space and flip-Y defaults (gpuweb #4356; Safari's
  * `copyExternalImageToTexture(ImageBitmap)` history). Left ad-hoc per site it bites
  * invisibly and per-backend. This module NORMALISES the decode + declares the SAME
  * flag set EXPLICITLY on both upload legs, so a texture reads identically on Chromium
  * and WebKit — the single seam every image-consuming viz routes through.
  *
- * The ≥2-consumer bar is met by construction: `<Aurora source="image">` is consumer
- * #1 (this wave BUILDS the seam); `BD.W-DOT-IMAGE` (the dot-matrix image variant) is
- * the booked consumer #2 — whichever landed first BUILDS it, the other CONSUMES it
- * (the first-to-land-builds contract). Recorded in
+ * `<Aurora source="image">` consumes this upload seam. Further image-backed
+ * substrates can share it without adding another texture path.
  * `docs/consumer-evidence/texture-upload.md`.
  *
- * INTERNAL — off the public `src/composables/glass/index.ts` barrel (the WebGL2 /
- * WebGPU substrates are likewise): aurora + dot-image compose it via a direct
+ * Internal and absent from the public `src/composables/glass/index.ts` barrel, like the
+ * WebGL2 and WebGPU substrates: Aurora and dot-image compose it via a direct
  * relative import.
  *
  * The decode contract (BOTH legs share it):
@@ -32,7 +30,7 @@ export declare const IMAGE_DECODE_OPTIONS: ImageBitmapOptions;
  */
 export type UploadableImageSource = ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageData;
 /**
- * Anything a consumer may hand the axis: a URL string / `Blob` (needs a decode) OR an
+ * Anything a consumer may hand the axis: a URL string, `Blob` (needs a decode) OR an
  * already-uploadable source (passed straight through). `resolveImageSource` normalises
  * every form to an {@link UploadableImageSource} via the shared decode contract.
  */