@mkbabb/glass-ui 6.0.0 → 8.0.0

package/dist/components/toggle-group/context.d.ts

@@ -0,0 +1,28 @@
+import type { ComputedRef } from "vue";
+import type { SelectionValue } from "../_shared/selection.js";
+/** What an item publishes to its group. The element is the roving/recenter target. */
+export interface ToggleItemEntry {
+    /** The item's stable identity — the library's ONE scalar (never narrowed here). */
+    readonly value: SelectionValue;
+    /** Read live: an item may become disabled after it registers. */
+    readonly disabled: () => boolean;
+    /** The item's host button, or `null` before mount / after unmount. */
+    el: HTMLElement | null;
+}
+/** What the group publishes back — every per-item answer, none of it re-derived. */
+export interface ToggleGroupContext {
+    register: (entry: ToggleItemEntry) => void;
+    unregister: (entry: ToggleItemEntry) => void;
+    /** `true` when the item's value is in the model (one for `single`, N for `multiple`). */
+    isSelected: (value: SelectionValue) => boolean;
+    /** Role-per-mode ARIA from the engine — `radio`/`aria-checked` or `aria-pressed`. */
+    itemAttrs: (value: SelectionValue) => Record<string, string>;
+    /** The roving tabindex: exactly one `0` in the group, `-1` everywhere else. */
+    tabindex: (entry: ToggleItemEntry) => number;
+    /** Commit — the engine's ONE selection path (model write + recenter). */
+    select: (entry: ToggleItemEntry) => void;
+    /** The group's disabled axis, so an item need not read two sources. */
+    disabled: ComputedRef<boolean>;
+}
+export declare function provideToggleGroupContext(context: ToggleGroupContext): void;
+export declare const useOptionalToggleGroupContext: () => ToggleGroupContext | null;

package/dist/components/toggle-group/index.d.ts

@@ -1,2 +1,2 @@
-export { default as ToggleGroup } from './ToggleGroup.vue';
-export { default as ToggleGroupItem } from './ToggleGroupItem.vue';
+export { default as ToggleGroup, type ToggleGroupProps } from "./ToggleGroup.vue.js";
+export { default as ToggleGroupItem, type ToggleGroupItemProps, } from "./ToggleGroupItem.vue.js";

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

@@ -1,13 +1,26 @@
-import { type TooltipRootProps } from 'reka-ui';
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+export interface TooltipProps {
+    /** Controlled visibility. */
+    open?: boolean;
+    /** Initial visibility for an uncontrolled tooltip. */
+    defaultOpen?: boolean;
+    /** Per-tooltip override of the provider's opening delay. */
+    delayDuration?: number;
+    disabled?: boolean;
+}
+export interface TooltipEmits {
+    "update:open": [value: boolean];
+}
+type __VLS_Slots = {
+    default?: () => unknown;
 };
-declare const __VLS_base: import("vue").DefineComponent<TooltipRootProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const __VLS_base: import("vue").DefineComponent<TooltipProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<TooltipRootProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<TooltipProps> & Readonly<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    open: boolean;
+    defaultOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,23 +1,26 @@
-import { type HTMLAttributes } from 'vue';
-import { type TooltipContentProps } from 'reka-ui';
-import { type Surface } from '../_shared/useSurfaceAxis';
-type __VLS_Props = TooltipContentProps & {
-    class?: HTMLAttributes['class'];
-    surface?: Surface;
+import { type HTMLAttributes } from "vue";
+import { type FloatingPlacementProps } from "../_shared/overlay/index.js";
+export interface TooltipContentProps extends FloatingPlacementProps {
+    class?: HTMLAttributes["class"];
+}
+export interface TooltipContentEmits {
+    escapeKeyDown: [event: KeyboardEvent];
+    pointerDownOutside: [event: Event];
+}
+type __VLS_Slots = {
+    default?: () => unknown;
 };
-declare var __VLS_14: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_14) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const __VLS_base: import("vue").DefineComponent<TooltipContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     escapeKeyDown: (event: KeyboardEvent) => any;
     pointerDownOutside: (event: Event) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<TooltipContentProps> & Readonly<{
     onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
     onPointerDownOutside?: ((event: Event) => any) | undefined;
 }>, {
-    surface: Surface;
+    align: import("../_shared/overlay/index.js").FloatingAlign;
+    side: import("../_shared/overlay/index.js").FloatingSide;
     sideOffset: number;
+    alignOffset: number;
 }, {}, {}, {}, 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/TooltipProvider.vue.d.ts

@@ -1,9 +1,16 @@
-import { type TooltipProviderProps } from 'reka-ui';
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+export interface TooltipProviderProps {
+    /** Pointer dwell before the first tooltip opens, in milliseconds. */
+    delayDuration?: number;
+    /** Grace period for moving between sibling tooltips, in milliseconds. */
+    skipDelayDuration?: number;
+}
+type __VLS_Slots = {
+    default?: () => unknown;
 };
-declare const __VLS_base: import("vue").DefineComponent<TooltipProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<TooltipProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipProviderProps> & Readonly<{}>, {
+    delayDuration: number;
+    skipDelayDuration: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,9 +1,16 @@
-import { type TooltipTriggerProps } from 'reka-ui';
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+import { type HTMLAttributes } from "vue";
+import type { PrimitiveProps } from "../_shared/primitive.js";
+export interface TooltipTriggerProps {
+    /** Merge trigger behavior into one interactive child. */
+    asChild?: PrimitiveProps["asChild"];
+    class?: HTMLAttributes["class"];
+}
+type __VLS_Slots = {
+    default?: () => unknown;
 };
-declare const __VLS_base: import("vue").DefineComponent<TooltipTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<TooltipTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipTriggerProps> & Readonly<{}>, {
+    asChild: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,4 +1,4 @@
-export { default as Tooltip } from './Tooltip.vue';
-export { default as TooltipContent } from './TooltipContent.vue';
-export { default as TooltipTrigger } from './TooltipTrigger.vue';
-export { default as TooltipProvider } 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>;
@@ -10,6 +10,7 @@ export declare function useTypewriter(options: TypewriterOptions): {
         className?: string | undefined;
         isCode?: boolean | undefined;
     }>;
+    reducedMotion: Readonly<import("vue").Ref<boolean, boolean>>;
     startTyping: () => Promise<void>;
     stopTyping: () => void;
     reset: () => void;

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>;
@@ -13,5 +13,3 @@ export declare function pickNgramSize(config: number | {
 }): number;
 /** Uniform random integer in [min, max] (inclusive). */
 export declare function randomInRange(min: number, max: number): number;
-/** Check if user prefers reduced motion. SSR-safe. */
-export declare function prefersReducedMotion(): 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,11 +1,8 @@
-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
- * cascade var). The ink RESOLVES `safeAccentColor(toneColor, bandLightness, …)`:
- * value.js shifts the tone's OKLCh lightness AWAY from the active-band fill until it
- * clears the AA bar, so the label reads ON the fill in either mode. Returns an
- * `oklch(...)` string, or `""` on an unparseable tone/surface (fail-explicit — the
- * consumer falls back to the CSS default ink, a befitting graceful degrade).
+ * cascade var). Invalid CSS and unreachable contrast throw `GlassColorError`; this
+ * boundary never substitutes a default ink.
  */
 export declare function solveAccentInk(toneCss: string, opts?: UseAccentToneOptions): string;

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
- * 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).
+ * `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];
 /**
  * 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).
@@ -150,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/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/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 { 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/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/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";