@mkbabb/glass-ui 7.0.0 → 8.0.0

package/dist/components/tooltip/TooltipContent.vue.d.ts

@@ -1,11 +1,7 @@
 import { type HTMLAttributes } from "vue";
-import type { Surface } from "../_shared/axes";
-import { type FloatingPlacementProps } from "../_shared/floating";
+import { type FloatingPlacementProps } from "../_shared/overlay/index.js";
 export interface TooltipContentProps extends FloatingPlacementProps {
     class?: HTMLAttributes["class"];
-    surface?: Surface;
-    /** Override the text announced through the trigger's description relation. */
-    ariaLabel?: string;
 }
 export interface TooltipContentEmits {
     escapeKeyDown: [event: KeyboardEvent];
@@ -21,11 +17,10 @@ declare const __VLS_base: import("vue").DefineComponent<TooltipContentProps, {},
     onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
     onPointerDownOutside?: ((event: Event) => any) | undefined;
 }>, {
-    side: import("../_shared/floating").FloatingSide;
+    align: import("../_shared/overlay/index.js").FloatingAlign;
+    side: import("../_shared/overlay/index.js").FloatingSide;
     sideOffset: number;
-    align: import("../_shared/floating").FloatingAlign;
     alignOffset: number;
-    surface: Surface;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/tooltip/TooltipTrigger.vue.d.ts

@@ -1,5 +1,5 @@
 import { type HTMLAttributes } from "vue";
-import type { PrimitiveProps } from "../_shared/primitive";
+import type { PrimitiveProps } from "../_shared/primitive.js";
 export interface TooltipTriggerProps {
     /** Merge trigger behavior into one interactive child. */
     asChild?: PrimitiveProps["asChild"];

package/dist/components/tooltip/index.d.ts

@@ -1,4 +1,4 @@
-export { default as Tooltip, type TooltipEmits, type TooltipProps, } from "./Tooltip.vue";
-export { default as TooltipContent, type TooltipContentEmits, type TooltipContentProps, } from "./TooltipContent.vue";
-export { default as TooltipTrigger, type TooltipTriggerProps, } from "./TooltipTrigger.vue";
-export { default as TooltipProvider, type TooltipProviderProps, } from "./TooltipProvider.vue";
+export { default as Tooltip, type TooltipEmits, type TooltipProps, } from "./Tooltip.vue.js";
+export { default as TooltipContent, type TooltipContentEmits, type TooltipContentProps, } from "./TooltipContent.vue.js";
+export { default as TooltipTrigger, type TooltipTriggerProps, } from "./TooltipTrigger.vue.js";
+export { default as TooltipProvider, type TooltipProviderProps, } from "./TooltipProvider.vue.js";

package/dist/components/typewriter/TypewriterText.vue.d.ts

@@ -1,33 +1,27 @@
-import type { TypewriterWord } from "./types";
+import type { TypewriterWord } from "./types.js";
 interface Props {
     /** Single text to type. Use this OR `words`, not both. */
     text?: string;
     /** Array of words to cycle through in rotation mode. Use this OR `text`, not both. */
     words?: TypewriterWord[];
-    ngramSize?: number | {
-        min: number;
-        max: number;
-    };
+    /** Base typing speed in ms per keystroke. */
     baseSpeed?: number;
-    variance?: number;
-    errorRate?: number;
-    firstAnimationSpeedFactor?: number;
-    maxCharsBeforeNotice?: number;
-    continueAfterTypoProbability?: number;
-    sequentialTypoDecay?: number;
-    correctionSpeedMultiplier?: number;
     cursorVisible?: boolean;
     cursorBlink?: boolean;
-    cursorChar?: string;
-    startDelay?: number;
     loop?: boolean;
     /** Pause after typing a word before deleting (ms). Word-rotation mode only. */
     pauseAfterType?: number;
     /** Pause after deleting a word before typing the next (ms). Word-rotation mode only. */
     pauseAfterDelete?: number;
-    /** Backspace speed in word-rotation mode (ms per char). */
-    deletingSpeed?: number;
-    respectReducedMotion?: boolean;
+    /**
+     * Typing character. `true` (default) types like a person — variable cadence,
+     * n-gram bursts, and the occasional self-corrected typo (the humanized default
+     * the engine ships). `false` types mechanically at a steady `baseSpeed` with no
+     * variance and no typos. The one intent-level knob that replaces the retired
+     * per-parameter simulation surface (variance/errorRate/ngramSize/typo-FSM &c.);
+     * reduced-motion respect is always-on (it settles to the final phrase in one paint).
+     */
+    humanize?: boolean;
 }
 declare const __VLS_export: import("vue").DefineComponent<Props, {
     startTyping: () => Promise<void>;
@@ -55,28 +49,14 @@ declare const __VLS_export: import("vue").DefineComponent<Props, {
     onWordComplete?: ((index: number) => any) | undefined;
 }>, {
     text: string;
-    respectReducedMotion: boolean;
     loop: boolean;
     words: TypewriterWord[];
-    ngramSize: number | {
-        min: number;
-        max: number;
-    };
     baseSpeed: number;
-    variance: number;
-    errorRate: number;
-    firstAnimationSpeedFactor: number;
-    maxCharsBeforeNotice: number;
-    continueAfterTypoProbability: number;
-    sequentialTypoDecay: number;
-    correctionSpeedMultiplier: number;
     cursorVisible: boolean;
     cursorBlink: boolean;
-    cursorChar: string;
     pauseAfterType: number;
     pauseAfterDelete: number;
-    deletingSpeed: number;
-    startDelay: number;
+    humanize: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/typewriter/composables/useTypewriter.d.ts

@@ -1,4 +1,4 @@
-import type { TypewriterOptions } from "../types";
+import type { TypewriterOptions } from "../types.js";
 export declare function useTypewriter(options: TypewriterOptions): {
     displayText: import("vue").Ref<string, string>;
     isTyping: import("vue").Ref<boolean, boolean>;

package/dist/components/typewriter/index.d.ts

@@ -1,7 +1,7 @@
-export { default as TypewriterText } from "./TypewriterText.vue";
-export { useTypewriter } from "./composables/useTypewriter";
-export * from "./types";
-export * from "./utils/keyboard";
-export * from "./utils/pausePatterns";
-export * from "./utils/timing";
-export * from "./utils/typoStateMachine";
+export { default as TypewriterText } from "./TypewriterText.vue.js";
+export { useTypewriter } from "./composables/useTypewriter.js";
+export * from "./types.js";
+export * from "./utils/keyboard.js";
+export * from "./utils/pausePatterns.js";
+export * from "./utils/timing.js";
+export * from "./utils/typoStateMachine.js";

package/dist/components/typewriter/types.d.ts

@@ -1,4 +1,4 @@
-import type { KeyPosition } from "./utils/keyboard";
+import type { KeyPosition } from "./utils/keyboard.js";
 export type { KeyPosition };
 /** A single word entry for word-rotation mode. */
 export interface TypewriterWord {

package/dist/components/typewriter/utils/timing.d.ts

@@ -1,4 +1,4 @@
-import type { CancellationToken } from "../types";
+import type { CancellationToken } from "../types.js";
 export declare function createCancellationToken(): CancellationToken;
 /** Resolves `true` if elapsed normally, `false` if cancelled. */
 export declare function sleep(ms: number, token: CancellationToken): Promise<boolean>;

package/dist/components/typewriter/utils/typoStateMachine.d.ts

@@ -1,4 +1,4 @@
-import type { TypoContext, TypoAction } from "../types";
+import type { TypoContext, TypoAction } from "../types.js";
 export interface TypoConfig {
     maxCharsBeforeNotice: number;
     continueAfterTypoProbability: number;

package/dist/composables/color/accent-tone-solve.d.ts

@@ -1,4 +1,4 @@
-import type { UseAccentToneOptions } from "./useAccentTone";
+import type { UseAccentToneOptions } from "./useAccentTone.js";
 /**
  * Resolve the contrast-safe label ink for a CONCRETE tone (the caller — the shell —
  * has already screened out `var(--…)` tones; there is no author-time solve for a

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

@@ -6,11 +6,11 @@ export interface OklchStop {
 }
 /**
  * A color seam: resolves a CSS color string to a GAMMA-sRGB triple in [0,1].
- * `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`
- * without dependency injection.
+ * `defaultBlobColorResolver` is the default. A general-purpose injection type for
+ * consumers that theme a substrate through an external color pipeline — the
+ * `<FourierField>` ambient background takes it as an optional `colorResolver` prop
+ * (paired with the `color` token seam). The goo-blob resolves color internally through
+ * `cssToOklch → oklchToGammaRgb` without dependency injection.
  */
 export type ColorResolver = (css: string) => [number, number, number];
 /**
@@ -143,5 +143,5 @@ export interface DeriveBlobPaletteOptions {
  * @param options stop count, harmony, spreads.
  */
 export declare function deriveBlobPalette(seed: string | OklchStop, options?: DeriveBlobPaletteOptions): OklchStop[];
-export { useAccentTone } from "./useAccentTone";
-export type { UseAccentToneOptions, UseAccentToneReturn } from "./useAccentTone";
+export { useAccentTone } from "./useAccentTone.js";
+export type { UseAccentToneOptions, UseAccentToneReturn } from "./useAccentTone.js";

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

@@ -1 +1 @@
-export { createStrictContext, createOptionalContext, type StrictContext, type OptionalContext, } from "./createContext";
+export { createStrictContext, createOptionalContext, type StrictContext, type OptionalContext, } from "./createContext.js";

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

@@ -1,5 +1,5 @@
-export { useGlobalDark } 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";
+export { useGlobalDark } from "./useGlobalDark.js";
+export type { GlobalColorSchema, UseGlobalDarkOptions, UseGlobalDarkReturn, DarkFlipSettledCallback, } from "./useGlobalDark.js";
+export { installDarkModeSync } from "./installDarkModeSync.js";
+export { darkModeSyncScript, DARK_MODE_STORAGE_KEY } from "./darkModeSyncScript.js";
+export type { DarkModeSyncScriptOptions } from "./darkModeSyncScript.js";

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

@@ -1,10 +1,10 @@
-export * from "./useResizeObserver";
-export * from "./useTouchGate";
-export * from "./useDragVelocity";
-export * from "./useTokenColor";
-export * from "./useResolveTokenColor";
-export * from "./useClipboard";
-export * from "./useUserInvalidAria";
-export * from "./useBreakpoint";
-export * from "./useIdleReady";
-export * from "./useViewportReady";
+export * from "./useResizeObserver.js";
+export * from "./useTouchGate.js";
+export * from "./useDragVelocity.js";
+export * from "./useTokenColor.js";
+export * from "./useResolveTokenColor.js";
+export * from "./useClipboard.js";
+export * from "./useUserInvalidAria.js";
+export * from "./useBreakpoint.js";
+export * from "./useIdleReady.js";
+export * from "./useViewportReady.js";

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

@@ -7,6 +7,13 @@ export interface UseDragVelocityParams {
      * element; descendants inherit it (the fill + the cast read it).
      */
     host: () => HTMLElement | null;
+    /**
+     * A SECOND element that receives the same two writes. A teleported organ (the
+     * slider's loupe) is out of the host's inheritance chain, so it cannot read the
+     * vars off an ancestor — and minting a second velocity pole for it would break the
+     * one-owner law. One writer, two hosts.
+     */
+    mirror?: () => HTMLElement | null;
     /**
      * The pointer axis the velocity is measured on. Default `"x"` (the horizontal
      * slider). A getter re-reads on an orientation flip.

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