@mkbabb/glass-ui 3.10.0 → 3.11.0

package/dist/components/custom/aurora/constants/presets.d.ts

@@ -1,14 +1,19 @@
 /**
  * Aurora v4.1 — library config shape.
  *
- * Authored presets (Sky, Dawn, Meadow, Deliberative, Day9, Oil Impasto,
+ * Authored THEMED presets (Sky, Dawn, Meadow, Deliberative, Day9, Oil Impasto,
  * Oil Gestural, Oil Van Gogh, Crayon Sunset, Crayon Rainbow, Crayon Ocean)
  * live in the consumer — see demo/stories/aurora/presets.ts.
  *
- * Per memory rule "Presets in consumers": named themed presets belong in
- * each consumer project, not in the library. The library exports only the
- * shape + a minimum-viable DEFAULT_AURORA_CONFIG for the component's own
- * type-check ergonomics.
+ * Per memory rule "Presets in consumers": named THEMED presets belong in each
+ * consumer project, not in the library. The library exports only the shape, a
+ * minimum-viable DEFAULT_AURORA_CONFIG, and — the one deliberate exception
+ * (E22 / d-paper-aurora M4) — the `PAPER_WASH_GROUND` CALIBRATION partial: a
+ * recessive-ground crayon TUNING (not a themed palette) whose deft tooth dials
+ * are LIBRARY CANON so a data-ground aurora reads as paper-on-tooth without each
+ * consumer dial-tuning the same recessive calibration by hand (the
+ * `proof:aurora-paper-ground` gate locks it). It carries NO palette/nuclei — the
+ * consumer spreads it over its own pole-derived pigment (page-glow IS data-glow).
  */
 import type { OklchStop } from "../../../../composables/color";
 export type { OklchStop };
@@ -114,6 +119,14 @@ export interface AuroraConfig {
     granulation: number;
     impasto: number;
     brokenColor: number;
+    /**
+     * The medium's own paper-tooth multiplier (`uCanvasGrain` — `mediums.glsl.ts`
+     * `result *= 1 + tooth*toothAmp*uCanvasGrain`). The themed mediums ride the
+     * sub-0.1 band; the RECESSIVE-ground `crayon` preset (PAPER_WASH_GROUND) rides
+     * a higher tooth multiplier (~0.5) so the dry tooth is FELT at the clamped
+     * ground ceiling where a hue-tint dies — texture is cheap to the eye, flat hue
+     * is expensive (the d-paper-aurora load-bearing physics).
+     */
     canvasGrain: number;
     /**
      * AW.W4.2 — the impasto relight direction (the movable directional source the
@@ -181,3 +194,47 @@ export declare const MAX_STOPS = 8;
  * Not a themed preset — the demo's 11 authored presets override every field.
  */
 export declare const DEFAULT_AURORA_CONFIG: AuroraConfig;
+/**
+ * `PAPER_WASH_GROUND` — the library-canon recessive-ground crayon calibration.
+ *
+ * The deft tooth dials the paper-aurora hybrid needs, pinned ONCE at the library
+ * level so a data-ground aurora reads as pigment-on-paper-tooth — NOT a dead hue
+ * tint, NOT a screen-like gradient — without each consumer hand-tuning the same
+ * recessive calibration (the root-repo law: the calibration lives in the library;
+ * the consumer never dial-tunes it). It is a PARTIAL: it carries NO palette /
+ * nuclei / motion — the consumer SPREADS it over its own pole-derived pigment so
+ * the page-glow stays the data-glow (the keystone the smooth-medium swap preserves
+ * verbatim; only the DEPOSITION changes from a gradient to a dry-tooth multiply).
+ *
+ * The pinned dials (the named stopping rules, d-paper-aurora M1):
+ *   - `medium: "crayon"`        — the DRY tooth-multiply (a TEXTURE, not strokes;
+ *                                 admissible behind data where the four
+ *                                 stroke-deposition mediums are forbidden).
+ *   - `granulation: 0.30`       — pigment settles in the paper tooth (felt-at-rest).
+ *   - `canvasGrain: 0.5`        — the medium's tooth multiplier, lifted so the dry
+ *                                 tooth survives the clamped ground ceiling.
+ *   - `strokeAmount: 0.35`      — the crayon PRESSURE (how hard the tooth bites);
+ *                                 LOW (recessive — the tooth is felt, never a slab).
+ *   - `strokeAnisotropy: 0.5`   — moderate directional squash; never high enough to
+ *                                 read as STROKES (crumb-texture, not brushwork).
+ * Plus the recessive guards: `saturation < 1` (the ground spends NO chroma budget —
+ * the pops live in the icons), no impasto/sheen (`impasto: 0`, single layer), and a
+ * felt `paperGrain` floor.
+ *
+ * Spread it: `const cfg = { ...consumerBase, ...PAPER_WASH_GROUND }` — the
+ * calibration wins the deposition dials, the consumer keeps the pigment + nuclei.
+ */
+export declare const PAPER_WASH_GROUND: {
+    readonly medium: "crayon";
+    readonly strokeOrient: "tensor";
+    readonly granulation: 0.3;
+    readonly canvasGrain: 0.5;
+    readonly strokeAmount: 0.35;
+    readonly strokeAnisotropy: 0.5;
+    readonly strokeLayers: 1;
+    readonly impasto: 0;
+    readonly brokenColor: 0;
+    readonly wetEdge: 0;
+    readonly saturation: 0.92;
+    readonly paperGrain: 0.008;
+};

package/dist/components/custom/aurora/index.d.ts

@@ -5,7 +5,7 @@ export type { UseAuroraReturn } from "./composables/useAurora";
 export { useCursorInteraction } from "./composables/useCursorInteraction";
 export { createAurora } from "./composables/runtime";
 export type { AuroraRuntimeMode, AuroraRuntimeOptions } from "./composables/runtime";
-export { DEFAULT_AURORA_CONFIG, MAX_NUCLEI, MAX_STOPS, type AuroraConfig, type AuroraCursorApi, type AuroraFlow, type AuroraInstance, type AuroraInteractivity, type AuroraMedium, type AuroraNucleus, type FlowPattern, type OklchStop, type StrokeMode, type StrokeOrient, type WarpMode, } from "./constants/presets";
+export { DEFAULT_AURORA_CONFIG, PAPER_WASH_GROUND, MAX_NUCLEI, MAX_STOPS, type AuroraConfig, type AuroraCursorApi, type AuroraFlow, type AuroraInstance, type AuroraInteractivity, type AuroraMedium, type AuroraNucleus, type FlowPattern, type OklchStop, type StrokeMode, type StrokeOrient, type WarpMode, } from "./constants/presets";
 export { resolveAtoms, configToAtoms, nucleiPrior, DEFAULT_ATOMS, type AuroraAtoms, type AuroraMotionAtom, type AuroraZones, type AuroraZoneArrangement, type AuroraMediumAtom, type AuroraInteractivityAtom, } from "./composables/atoms";
 export { cssToOklch, deriveAurora, flattenPalette, hexToOklchStop, oklchStopToHex, oklchToLinear, paletteToCssGradient, } from "./composables/color";
 export type { AuroraHarmony, DeriveAuroraOptions, DeriveEasing, } from "./composables/color";

package/dist/components/custom/dock/GlassDock.vue.d.ts

@@ -106,7 +106,7 @@ interface DockVariantProps extends DockCommonProps {
 interface DockRailProps extends DockCommonProps {
     variant: "rail" | "instrument-strip";
 }
-declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_14: {};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_14: {}, __VLS_16: {}, __VLS_18: {};
 type __VLS_Slots = {} & {
     persistent?: (props: typeof __VLS_1) => any;
 } & {
@@ -117,6 +117,10 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_7) => any;
 } & {
     collapsed?: (props: typeof __VLS_14) => any;
+} & {
+    default?: (props: typeof __VLS_16) => any;
+} & {
+    collapsed?: (props: typeof __VLS_18) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<DockVariantProps | DockRailProps, {
     expanded: import("vue").Ref<boolean, boolean>;

package/dist/components/custom/expandable-container/ExpandableContainer.vue.d.ts

@@ -8,7 +8,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     collapseLabel?: string;
     /**
      * Opt into the `gl-expand` plate → fullscreen MORPH (D6.c M7). When set,
-     * the inline plate and the teleported fullscreen surface share ONE
+     * the inline anchor and the teleported fullscreen surface share ONE
      * `view-transition-name` (this prop, suffixed by an app-unique `useId()`
      * so two ExpandableContainers on a page never collide their groups — the
      * proof:vt-names mandate), and the open/close toggle is wrapped in
@@ -27,7 +27,13 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
      * buttons continue to operate without parent wiring.
      */
     open?: boolean;
-}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}, {
+    anchorEl: Readonly<import("vue").ShallowRef<HTMLElement | null>>;
+    surfaceEl: Readonly<import("vue").ShallowRef<HTMLElement | null>>;
+    expand: () => void;
+    collapse: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    settle: (fullscreen: boolean) => any;
     "update:open": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<{
     buttonPosition?: "left" | "right";
@@ -37,7 +43,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     collapseLabel?: string;
     /**
      * Opt into the `gl-expand` plate → fullscreen MORPH (D6.c M7). When set,
-     * the inline plate and the teleported fullscreen surface share ONE
+     * the inline anchor and the teleported fullscreen surface share ONE
      * `view-transition-name` (this prop, suffixed by an app-unique `useId()`
      * so two ExpandableContainers on a page never collide their groups — the
      * proof:vt-names mandate), and the open/close toggle is wrapped in
@@ -57,6 +63,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
      */
     open?: boolean;
 }> & Readonly<{
+    onSettle?: ((fullscreen: boolean) => any) | undefined;
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
     viewTransitionName: string;
@@ -67,10 +74,6 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
     default?: (props: {
         fullscreen: boolean;
     }) => any;
-} & {
-    default?: (props: {
-        fullscreen: boolean;
-    }) => any;
 }>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/components/custom/handmark/brush.d.ts

@@ -158,6 +158,29 @@ export declare const BRUSHES: {
         readonly segments: 13;
         readonly cap: "round";
     };
+    readonly ring: {
+        readonly weight: 5;
+        readonly weightJitter: 0.6;
+        readonly thinning: 0.3;
+        readonly taper: {
+            readonly start: 8;
+            readonly end: 12;
+            readonly ease: "out-cubic";
+        };
+        readonly ribbon: "stroke";
+        readonly opacity: 0.55;
+        readonly blend: "source-over";
+        readonly passes: 1;
+        readonly passOpacity: 0;
+        readonly grain: 0.7;
+        readonly grainFreq: 0.18;
+        readonly grainScale: 1.8;
+        readonly octaves: 4;
+        readonly roughness: 1.4;
+        readonly wobble: 2.6;
+        readonly segments: 13;
+        readonly cap: "round";
+    };
     readonly marker: {
         readonly weight: 12;
         readonly weightJitter: 0.2;

package/dist/components/custom/handmark/geometry.d.ts

@@ -19,13 +19,31 @@ import { type WobbleOptions } from "@mkbabb/pencil-boil";
 import type { HandShape, MarkBox } from "./types";
 export declare const VB_W = 100;
 export declare const VB_H = 40;
+/**
+ * The hairline gap, as a fraction of the `.hm` box, between the MEASURED text
+ * baseline and the underline centerline. The underline rides just under the real
+ * glyph bottoms — a hand mark sits a few % of cap-height below the baseline, never
+ * through it (the E1 occlusion root: a constant `y=32` strikethroughs tight-leading
+ * display type because 80% of a `line-height:1.02` box IS the baseline).
+ */
+export declare const UNDERLINE_GAP = 0.06;
 /** A shape maps to one or more centerlines (open polylines) or one closed ring. */
 export interface ShapeGeom {
     lines: [number, number][][];
     closed: boolean;
 }
-/** Semantic shape → { lines, closed } in the marking space (or a positioned box). */
-export declare function shapeGeom(shape: HandShape, opts: WobbleOptions, box?: MarkBox | null): ShapeGeom;
+/**
+ * Semantic shape → { lines, closed } in the marking space (or a positioned box).
+ *
+ * The text-mode underline anchors to a MEASURED baseline: `baselineFrac` is the
+ * slotted word's alphabetic baseline as a fraction of the `.hm` box height (the SFC
+ * measures it via ResizeObserver + `document.fonts.ready`). The underline y is then
+ * `VB_H × (baselineFrac + UNDERLINE_GAP)` — never the old hardcoded `32` (80% of the
+ * box), which struck through tight-leading headings. `null` ⇒ not yet measured: fall
+ * back to the legacy `VB_H − 8` constant so first paint (and jsdom/SSR) still renders
+ * a line, replaced the instant the measure lands.
+ */
+export declare function shapeGeom(shape: HandShape, opts: WobbleOptions, box?: MarkBox | null, baselineFrac?: number | null): ShapeGeom;
 /** Boil one geometry: re-perturb the CACHED centerlines (anchored → no draw-on pop). */
 export declare function boilLines({ lines, closed }: ShapeGeom, amount: number, seed: number): [number, number][][];
 /** Serialize centerlines → one SVG `d` (multi-line shapes concat with a space). */

package/dist/components/custom/handmark/index.d.ts

@@ -13,9 +13,9 @@
  */
 export { default as HandMark, default as InkMark } from "./HandMark.vue";
 export { BRUSHES, resolveBrush, lerpBrush, type Brush, type BrushName, type BlendMode, type TaperSpec, type StampFn, type InkPath, } from "./brush";
-export { shapeGeom, serialize, boilLines, VB_W, VB_H, type ShapeGeom, } from "./geometry";
+export { shapeGeom, serialize, boilLines, VB_W, VB_H, UNDERLINE_GAP, type ShapeGeom, } from "./geometry";
 export { ink, type SVGFragment } from "./ink";
 export { grainFilter, hasGrain } from "./texture";
 export { getStroke, getStrokePoints, getSvgPathFromStroke, type StrokeOptions, type InputPoint, } from "./freehand";
-export { useHandMark, normalizeProps, type UseHandMarkInput, type HandMarkCore, } from "./useHandMark";
+export { useHandMark, normalizeProps, type UseHandMarkInput, type HandMarkCore, type BoilClock, } from "./useHandMark";
 export type { HandMarkProps, HandShape, HandAnimation, MarkBox, } from "./types";

package/dist/components/custom/handmark/useHandMark.d.ts

@@ -18,8 +18,18 @@
  * (`useLineBoil.start()` early-returns under reduced motion).
  */
 import { type Ref } from "vue";
-import { useLineBoil } from "@mkbabb/pencil-boil";
 import { type Brush, type BrushName } from "./brush";
+/**
+ * The boil clock surface the SFC binds — the `useLineBoil` return shape, declared
+ * structurally over glass-ui's OWN `Ref` (pencil-boil ships a nested `@vue`, so its
+ * `Ref` symbol differs; the no-op stub is built with this `ref`, hence the surface
+ * is named here rather than `ReturnType<typeof useLineBoil>`).
+ */
+export interface BoilClock {
+    currentFrame: Ref<number>;
+    start: () => void;
+    stop: () => void;
+}
 import { type ShapeGeom } from "./geometry";
 import { type SVGFragment } from "./ink";
 import type { HandAnimation, HandMarkProps, HandShape, MarkBox } from "./types";
@@ -38,9 +48,20 @@ export interface UseHandMarkInput {
     box: MarkBox | null;
     path: string | null;
     filterId: string;
+    /**
+     * The MEASURED text baseline as a fraction of the `.hm` box height (text-mode
+     * underline anchor). `null` until the SFC measures it (ResizeObserver +
+     * `document.fonts.ready`) — geometry falls back to the legacy constant for that
+     * one pre-measure frame. Ignored in positioned (`box`) mode.
+     */
+    baselineFrac: number | null;
 }
-/** Normalise raw HandMarkProps (with their defaults applied) into the core input. */
-export declare function normalizeProps(props: HandMarkProps, filterId: string): UseHandMarkInput;
+/**
+ * Normalise raw HandMarkProps (with their defaults applied) into the core input.
+ * `baselineFrac` is the SFC's MEASURED text baseline (text-mode underline anchor) —
+ * passed in (not a prop) because it is a runtime measurement, `null` until measured.
+ */
+export declare function normalizeProps(props: HandMarkProps, filterId: string, baselineFrac?: number | null): UseHandMarkInput;
 export interface HandMarkCore {
     /** the resolved effective brush vector. */
     brush: Ref<Brush>;
@@ -58,8 +79,8 @@ export interface HandMarkCore {
     draws: Ref<boolean>;
     /** does this animation boil? */
     boils: Ref<boolean>;
-    /** the lazy boil clock (subscribes to the singleton RAF). */
-    boil: ReturnType<typeof useLineBoil>;
+    /** the boil clock (a real `useLineBoil` only when the mark boils; else a no-op stub). */
+    boil: BoilClock;
     /** arm/disarm boil (draw-then-boil holds it until the draw finishes). */
     boilArmed: Ref<boolean>;
 }

package/dist/components/ui/toggle/Toggle.vue.d.ts

@@ -16,7 +16,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
 }>, {
     size: "default" | "sm" | "lg" | null;
-    variant: "default" | "outline" | "card" | null;
+    variant: "default" | "outline" | "glass" | "card" | null;
     disabled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/ui/toggle/index.d.ts

@@ -20,7 +20,7 @@ export { default as Toggle } from './Toggle.vue';
  * than re-declaring the surface at the consumer.
  */
 export declare const toggleVariants: (props?: ({
-    variant?: "default" | "outline" | "card" | null | undefined;
+    variant?: "default" | "outline" | "glass" | "card" | null | undefined;
     size?: "default" | "sm" | "lg" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export type ToggleVariants = VariantProps<typeof toggleVariants>;

package/dist/components/ui/toggle-group/ToggleGroup.vue.d.ts

@@ -1,10 +1,16 @@
 import { type HTMLAttributes } from 'vue';
 import { type ToggleGroupRootProps } from 'reka-ui';
-import { type ToggleGroupVariants } from './toggleGroupContext';
+import { type ToggleGroupRegister, type ToggleGroupVariants } from './toggleGroupContext';
 type __VLS_Props = ToggleGroupRootProps & {
     class?: HTMLAttributes['class'];
     variant?: ToggleGroupVariants['variant'];
     size?: ToggleGroupVariants['size'];
+    /**
+     * The MATERIAL register (E21/E23 — d-glassui M2). `register="glass"` moves
+     * every item onto the control-glass chip tier (wash-rest, quiet-on-select)
+     * without each call-site naming `variant="glass"`. An explicit `variant` wins.
+     */
+    register?: ToggleGroupRegister;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

package/dist/components/ui/toggle-group/ToggleGroupItem.vue.d.ts

@@ -1,10 +1,12 @@
 import { type HTMLAttributes } from 'vue';
 import { type ToggleGroupItemProps } from 'reka-ui';
-import { type ToggleGroupVariants } from './toggleGroupContext';
+import { type ToggleGroupRegister, type ToggleGroupVariants } from './toggleGroupContext';
 type __VLS_Props = ToggleGroupItemProps & {
     class?: HTMLAttributes['class'];
     variant?: ToggleGroupVariants['variant'];
     size?: ToggleGroupVariants['size'];
+    /** Per-item material register override (E21/E23). Group `register` propagates by default. */
+    register?: ToggleGroupRegister;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

package/dist/components/ui/toggle-group/toggleGroupContext.d.ts

@@ -10,9 +10,22 @@ import type { toggleVariants } from "../toggle";
  * `inject<ToggleGroupVariants>("toggleGroup")` pair.
  */
 export type ToggleGroupVariants = VariantProps<typeof toggleVariants>;
+/**
+ * The MATERIAL register a toggle group wears (E21/E23 — d-glassui M2). `"glass"`
+ * moves every item onto the control-glass chip tier (wash-rest, quiet-on-select,
+ * one rung quieter than the host hull) WITHOUT each call-site opting into the
+ * heavyweight `card` variant. It is the semantic chrome-tier alias for
+ * `variant: "glass"`: a group-level register, not a per-item style override.
+ * Omitted ⇒ the flat default register (back-compat). An EXPLICIT item/group
+ * `variant` still wins over the register (the register only supplies the variant
+ * when none is named).
+ */
+export type ToggleGroupRegister = "glass";
 export interface ToggleGroupContext {
     variant: ToggleGroupVariants["variant"];
     size: ToggleGroupVariants["size"];
+    /** The material register (E21/E23). Resolves to `variant: "glass"` when set. */
+    register?: ToggleGroupRegister;
 }
 export declare const TOGGLE_GROUP_KEY: import("vue").InjectionKey<ToggleGroupContext>;
 export declare function provideToggleGroupContext(context: ToggleGroupContext): void;

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

@@ -1,5 +1,5 @@
 export { useGlobalDark } from "./useGlobalDark";
-export type { UseGlobalDarkOptions } 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";

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

@@ -1,9 +1,15 @@
 import type { BasicColorSchema } from "@vueuse/core";
 import { type Ref, type WritableComputedRef } from "vue";
+/**
+ * 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
  * single shared dark-mode instance: the reactive `isDark` flag, a `toggleDark`
- * that optionally suppresses transitions, and the transition-suppression switch.
+ * that optionally suppresses transitions, the transition-suppression switch, and
+ * the post-flip settle hook (E9b).
  */
 export interface UseGlobalDarkReturn {
     /** Reactive dark-mode flag (vueuse `useDark` ref — writable). */
@@ -14,6 +20,20 @@ export interface UseGlobalDarkReturn {
     disableTransitions: Ref<boolean>;
     /** Configure transition suppression during the dark-mode toggle. */
     setDisableTransitions: (value: boolean) => void;
+    /**
+     * E9b — 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. an atlas's N-chart
+     * `merge-setOption` palette tween) into a single beat instead of N watchers
+     * firing in N sequential storms on the critical frame. The class toggle is
+     * synchronous (chrome flips instantly); the batch drains one frame later via a
+     * single `requestAnimationFrame` (an SSR/no-rAF env falls back to a macrotask).
+     * EVERY registered callback shares that ONE task — no per-subscriber scheduling.
+     * No View Transition is involved anywhere in this path (PRM-safe by
+     * construction). Returns an unsubscribe function. Idempotent re-registration
+     * of the same callback is a no-op.
+     */
+    onFlipSettled: (callback: DarkFlipSettledCallback) => () => void;
 }
 export interface UseGlobalDarkOptions {
     /**

package/dist/controls.js

@@ -1,6 +1,6 @@
 import { t as e } from "./cn-DJXf4yaB.js";
 import { t } from "./_plugin-vue_export-helper-ok8pgSl5.js";
-import { t as n } from "./useGlobalDark-d6waty-X.js";
+import { t as n } from "./useGlobalDark-D1wgEqfW.js";
 import { computed as r, createBlock as i, createElementVNode as a, defineComponent as o, mergeProps as s, openBlock as c, resolveDynamicComponent as l, unref as u, useAttrs as d, watchEffect as f, withCtx as p } from "vue";
 //#endregion
 //#region src/components/custom/controls/DarkModeToggle.vue

package/dist/dark.d.ts

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

package/dist/dark.js

@@ -1,4 +1,4 @@
-import { t as e } from "./useGlobalDark-d6waty-X.js";
+import { t as e } from "./useGlobalDark-D1wgEqfW.js";
 import { nextTick as t, watch as n } from "vue";
 //#region src/composables/dark/installDarkModeSync.ts
 function r(r) {