@mkbabb/glass-ui 2.1.0 → 3.1.0

package/dist/components/custom/labeled-field/LabeledField.vue.d.ts

@@ -1,4 +1,4 @@
-import type { HTMLAttributes } from "vue";
+import { type HTMLAttributes } from "vue";
 /**
  * LabeledField — parent SFC for the labeled-field family (V.W3.T5 / A5 §5.5).
  *
@@ -15,15 +15,29 @@ import type { HTMLAttributes } from "vue";
  * paints the canonical typography (font-display + body-size + muted-fg +
  * cursor-help). The previous mixed `text-base` / `text-lg` literals
  * harmonise on a single body-size token.
+ *
+ * AQ.W4 §W4.5 — `required` threads a `aria-hidden` asterisk onto the label
+ * (the `required` attr on the slotted control is the semantic carrier). The
+ * `error` slot renders an error-message region that the W3.1c
+ * `:has(:user-invalid)` group rule reveals; it carries `aria-live="polite"`
+ * so the message is announced when shown. The region's id is exposed as the
+ * default slot's `errorId` slot-prop so the slotted control can bind
+ * `aria-errormessage="errorId"` (the four wrappers auto-wire it; a raw
+ * `<LabeledField>` slot binds it manually).
  */
 type __VLS_Props = {
     label: string;
     tooltip?: string;
     labelClass?: HTMLAttributes["class"];
+    required?: boolean;
 };
-declare var __VLS_7: {};
+declare var __VLS_7: {
+    errorId: string;
+}, __VLS_9: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_7) => any;
+} & {
+    error?: (props: typeof __VLS_9) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/custom/labeled-field/LabeledInput.vue.d.ts

@@ -5,11 +5,27 @@ type __VLS_Props = {
     labelClass?: string;
     inputClass?: string;
     type?: string;
+    /**
+     * AQ.W4 §W4.5 — mark the field required. Threads the `aria-hidden`
+     * asterisk onto the label AND sets the native `required` attribute on the
+     * inner `<Input>` (the semantic carrier that drives `:user-invalid`).
+     */
+    required?: boolean;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare var __VLS_17: {};
+type __VLS_Slots = {} & {
+    error?: (props: typeof __VLS_17) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {}, {}, {}, {}, 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/labeled-field/LabeledSelect.vue.d.ts

@@ -6,6 +6,8 @@ type __VLS_Props = {
     label: string;
     tooltip: string;
     labelClass?: string;
+    /** AQ.W4 §W4.5 — thread the required-field asterisk onto the label. */
+    required?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;

package/dist/components/custom/labeled-field/LabeledSlider.vue.d.ts

@@ -6,6 +6,8 @@ type __VLS_Props = {
     min: number;
     max: number;
     step: number;
+    /** AQ.W4 §W4.5 — thread the required-field asterisk onto the label. */
+    required?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: number) => any;

package/dist/components/custom/labeled-field/LabeledSwitch.vue.d.ts

@@ -3,6 +3,8 @@ type __VLS_Props = {
     label: string;
     tooltip: string;
     labelClass?: string;
+    /** AQ.W4 §W4.5 — thread the required-field asterisk onto the label. */
+    required?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:checked": (value: boolean) => any;

package/dist/components/custom/toggle-chip/ToggleChip.vue.d.ts

@@ -5,13 +5,15 @@
  * selectors or `variant="cell"` for square icon + label cards.
  *
  * Usage:
- *   <ToggleChip v-model:pressed="isActive" variant="chip">
+ *   <ToggleChip v-model="isActive" variant="chip">
  *     Label
  *   </ToggleChip>
  *
- * When multiple chips share an exclusive selection, wire them up via
- * `pressed` / `@update:pressed` rather than reaching for ToggleGroup —
- * this component is deliberately unopinionated about selection mode.
+ * The toggle state is the reka-ui Toggle `modelValue` contract — bind it via
+ * `v-model` (or `:model-value` / `@update:model-value`). When multiple chips
+ * share an exclusive selection, wire them up this way rather than reaching for
+ * ToggleGroup — this component is deliberately unopinionated about selection
+ * mode.
  */
 import type { HTMLAttributes } from "vue";
 import { type ToggleProps } from "reka-ui";

package/dist/components/ui/input/Input.vue.d.ts

@@ -1,13 +1,16 @@
 import type { HTMLAttributes } from 'vue';
-type __VLS_Props = {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
     defaultValue?: string | number;
     modelValue?: string | number;
-    class?: HTMLAttributes['class'];
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    class?: HTMLAttributes["class"];
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:modelValue": (payload: string | number) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<{
+    defaultValue?: string | number;
+    modelValue?: string | number;
+    class?: HTMLAttributes["class"];
+}> & Readonly<{
     "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/components/ui/label/Label.vue.d.ts

@@ -2,6 +2,14 @@ import { type HTMLAttributes } from 'vue';
 import { type LabelProps } from 'reka-ui';
 type __VLS_Props = LabelProps & {
     class?: HTMLAttributes['class'];
+    /**
+     * AQ.W4 §W4.5 — render a required-field asterisk after the label text.
+     * The asterisk is decorative-to-AT (the `required` attribute on the input
+     * is the semantic carrier), so it is marked `aria-hidden`. Indicate
+     * required fields visually BEFORE interaction (required-field-feedback
+     * guide).
+     */
+    required?: boolean;
 };
 declare var __VLS_8: {};
 type __VLS_Slots = {} & {

package/dist/components/ui/textarea/Textarea.vue.d.ts

@@ -1,13 +1,50 @@
 import type { HTMLAttributes } from 'vue';
-type __VLS_Props = {
-    class?: HTMLAttributes['class'];
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    class?: HTMLAttributes["class"];
     defaultValue?: string | number;
     modelValue?: string | number;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    /**
+     * AQ.W4 §W4.3 — opt into `field-sizing: content` auto-grow. When `true`,
+     * the textarea grows vertically with its content between a 3-line floor
+     * and a `--textarea-autosize-max` ceiling (default `12lh`), then scrolls;
+     * the manual resize handle stays. Default `false` keeps the fixed
+     * `min-h-20` height (the unchanged no-op fallback).
+     *
+     * `field-sizing` is Baseline Newly (Chromium 2024) — on a non-supporting
+     * engine the element degrades to the fixed `min-block-size: 3lh` floor
+     * with standard scroll (no JS, no polyfill).
+     *
+     * Caveat: a grid/flex parent stretches children, defeating `field-sizing`.
+     * Inside a flex column, add `align-self: start` on the `<Textarea>` so it
+     * sizes to content rather than the track.
+     */
+    autosize?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:modelValue": (payload: string | number) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<{
+    class?: HTMLAttributes["class"];
+    defaultValue?: string | number;
+    modelValue?: string | number;
+    /**
+     * AQ.W4 §W4.3 — opt into `field-sizing: content` auto-grow. When `true`,
+     * the textarea grows vertically with its content between a 3-line floor
+     * and a `--textarea-autosize-max` ceiling (default `12lh`), then scrolls;
+     * the manual resize handle stays. Default `false` keeps the fixed
+     * `min-h-20` height (the unchanged no-op fallback).
+     *
+     * `field-sizing` is Baseline Newly (Chromium 2024) — on a non-supporting
+     * engine the element degrades to the fixed `min-block-size: 3lh` floor
+     * with standard scroll (no JS, no polyfill).
+     *
+     * Caveat: a grid/flex parent stretches children, defeating `field-sizing`.
+     * Inside a flex column, add `align-self: start` on the `<Textarea>` so it
+     * sizes to content rather than the track.
+     */
+    autosize?: boolean;
+}> & Readonly<{
     "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;
+}>, {
+    autosize: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/ui/toast/Toaster.vue.d.ts

@@ -1,3 +1,9 @@
-declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type ToasterPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+type __VLS_Props = {
+    position?: ToasterPosition;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    position: ToasterPosition;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -6,3 +6,4 @@ export { default as ToastTitle } from './ToastTitle.vue';
 export { default as Toaster } from './Toaster.vue';
 export { toast, useToast } from './use-toast';
 export type { Toast as ToastType, ToastVariant } from './use-toast';
+export type { ToasterPosition } from './Toaster.vue';

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

@@ -1 +1,2 @@
 export { useGlobalDark } from "./useGlobalDark";
+export { installDarkModeSync } from "./installDarkModeSync";

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

@@ -4,3 +4,5 @@ export * from "./useTokenColor";
 export * from "./useClipboard";
 export * from "./useViewportReady";
 export * from "./useBreakpoint";
+export * from "./useIdleReady";
+export * from "./useUserInvalidAria";

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

@@ -0,0 +1,63 @@
+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
+     * 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.
+     */
+    timeout?: number;
+    /**
+     * Optional task run the moment the gate flips (the scope-aware variant —
+     * useIPInfo's `() => void refresh()`). Runs exactly once; auto-cancelled
+     * on scope dispose with the rIC handle so a short-lived consumer cannot
+     * leak a deferred write to disposed refs. Consumers that only need the
+     * `ready` ref omit it.
+     */
+    onReady?: () => void;
+}
+export interface UseIdleReadyControls {
+    /** Flips `false → true` exactly once on the first idle tick (post-mount). */
+    readonly ready: Ref<boolean>;
+    /** Tear down the pending idle/timer handle. Auto-called on scope dispose. */
+    stop: () => void;
+}
+/**
+ * `useIdleReady(options?)` — `requestIdleCallback` (+ `setTimeout(0)` Safari
+ * fallback) post-mount idle gate that flips a `Ref<boolean>` exactly once on
+ * the first idle tick, and optionally runs an `onReady` task at that moment.
+ *
+ * The rIC-only sibling of `useViewportReady` — same one-shot `ready` ref +
+ * `stop()` shape, same auto-dispose discipline — minus the
+ * `IntersectionObserver` visibility stage. The gate is "idle, full stop", not
+ * "visible AND idle"; reach for it when there is no element to gate on (a
+ * top-level lazy mount, a composable's first-idle data fetch).
+ *
+ * Two unified use shapes:
+ *
+ *   1. `ready`-flag — `v-if`-gate a heavy mount on the returned ref:
+ *        const { ready } = useIdleReady();
+ *        // <Aurora v-if="ready" />
+ *   2. scope-aware task — run a callback on first idle, cancelled on dispose:
+ *        useIdleReady({ onReady: () => void refresh() });
+ *      The handle is auto-cancelled on Vue scope disposal so a short-lived
+ *      consumer cannot leak a deferred write to disposed refs.
+ *
+ * The composable schedules synchronously at call time (NOT inside an
+ * `onMounted`) so it works outside a component too (e.g. inside `useIPInfo`,
+ * 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.
+ *
+ * @param options.timeout Default `2000` ms — forwarded to `requestIdleCallback`.
+ * @param options.onReady Optional one-shot task run on the idle flip.
+ * @returns Object with `ready: Ref<boolean>` (flips false → true once) and
+ *          `stop()` for manual disposal outside a Vue scope.
+ */
+export declare function useIdleReady(options?: UseIdleReadyOptions): UseIdleReadyControls;

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

@@ -0,0 +1,32 @@
+export interface UseUserInvalidAriaOptions {
+    /**
+     * Also toggle the `.user-invalid-fallback` / `.user-valid-fallback`
+     * classes the W4.1 CSS rungs key off (for engines without `:user-invalid`
+     * support).
+     *
+     * Default: auto — `true` only when `CSS.supports('selector(:user-invalid)')`
+     * resolves `false`. Pass an explicit boolean to force the path (e.g. for a
+     * test that stubs feature detection).
+     */
+    fallbackClasses?: boolean;
+}
+export interface UseUserInvalidAriaReturn {
+    /**
+     * Attach the bridge to a scope root (a `<form>`, `<fieldset>`, or field
+     * wrapper). Wires capture-phase `blur` + `input` + `submit` listeners that
+     * sync `aria-invalid` (and, in fallback mode, the validity classes) on the
+     * scope's form controls. Idempotent per call; returns a stop fn that
+     * removes the listeners and clears the per-control interaction tracking.
+     */
+    bind: (root: HTMLElement) => () => void;
+}
+/**
+ * The `:user-invalid` → `aria-invalid` bridge. Wired on `blur` (capture —
+ * show error on field-exit), `input` (clear error on correction), and
+ * `submit` (sync all controls; submission counts as interaction). The setting
+ * of `aria-invalid="true"` is gated on first interaction per control (a
+ * `WeakSet`) so a pristine required-empty field is never flagged on mount;
+ * the `input` handler only CLEARS — never sets — so a programmatic `v-model`
+ * write can at worst clear a stale error, never mint a false one.
+ */
+export declare function useUserInvalidAria(opts?: UseUserInvalidAriaOptions): UseUserInvalidAriaReturn;

package/dist/composables/index.d.ts

@@ -3,6 +3,7 @@ export * from "./keyboard";
 export * from "./reactive";
 export * from "./dom";
 export * from "./motion";
+export * from "./motion/core";
 export * from "./glass";
 export * from "./sortable";
 export * from "./sidebar";

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

@@ -0,0 +1,8 @@
+export * from "../constants";
+export * from "../useStaggerReveal";
+export * from "../useScrollProgress";
+export * from "../useRAFLoop";
+export * from "../useIntersectionPause";
+export * from "../useStagger";
+export * from "../useYieldToMain";
+export * from "../useViewTransition";

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

@@ -3,12 +3,5 @@ export * from "./useSpring";
 export * from "./useSpringMount";
 export * from "./useSpringPress";
 export * from "./useNumericTransition";
-export * from "./useSpringOrchestrator";
-export * from "./useStaggerReveal";
-export * from "./useScrollProgress";
 export * from "./useAnimatedNumber";
 export * from "./useAnimatedNumberMap";
-export * from "./installDarkModeSync";
-export * from "./useRAFLoop";
-export * from "./useIntersectionPause";
-export * from "./useStagger";

package/dist/composables/motion/supportsCssTimeline.d.ts

@@ -0,0 +1,8 @@
+/** Genuine support for a `scroll()` timeline (the `.scroll-progress` recipe). */
+export declare function supportsScrollTimeline(): boolean;
+/**
+ * Genuine support for a `view()` timeline + `animation-range` (the
+ * `[data-scroll-reveal]` recipe). The `view()` value carries the range probe
+ * implicitly — an engine new enough for `view()` carries `animation-range`.
+ */
+export declare function supportsViewTimeline(): boolean;

package/dist/composables/motion/useRAFLoop.d.ts

@@ -35,6 +35,13 @@ export interface RAFLoopControls {
     resume: () => void;
     /** Stop the loop and detach document/media listeners. */
     dispose: () => void;
+    /**
+     * Yield to the main thread between chunks of heavy per-frame work (the INP
+     * lever). Native `scheduler.yield()` when available, else a MessageChannel/
+     * setTimeout fallback. `await` it inside the frame callback when a single
+     * frame's work would otherwise block input/paint. See {@link yieldToMain}.
+     */
+    yieldToMain: () => Promise<void>;
 }
 /**
  * Scope-aware requestAnimationFrame loop with manual controls plus document

package/dist/composables/motion/useScrollProgress.d.ts

@@ -16,8 +16,12 @@ interface ScrollProgressConfig {
  * `Ref<number>` in [0, 1]. Drives things like scroll-linked typography
  * axes, parallax depth, or progress indicators.
  *
- * Uses a rAF-coalesced scroll listener plus ResizeObserver so the mapping
- * stays accurate when layout shifts.
+ * AQ.W5: on an engine with native scroll-driven animations, the listener +
+ * `ResizeObserver` machinery does NOT attach — prefer the `.scroll-progress`
+ * CSS recipe (scroll-driven.css), which runs the same 0..1 axis on the
+ * compositor. This composable is the feature-detected fallback (the sole writer
+ * when the native feature is absent); `computeProgress()` still runs once on
+ * mount for a correct initial value.
  */
 export declare function useScrollProgress(options: ScrollProgressConfig): Ref<number>;
 export {};

package/dist/composables/motion/useStaggerReveal.d.ts

@@ -13,6 +13,12 @@ interface StaggerRevealConfig {
  * gets a staggered `revealed` flag once it crosses the viewport threshold.
  * Consumers bind the flag to a Tailwind class (e.g. `opacity-100 translate-y-0`)
  * and let CSS transitions handle the visual entry.
+ *
+ * AQ.W5: on an engine with native `view()` timelines, no `IntersectionObserver`
+ * is constructed — prefer the `[data-scroll-reveal]` CSS recipe
+ * (scroll-driven.css). This composable is the feature-detected fallback (the
+ * sole writer when the native feature is absent); under native, `register()`
+ * reveals immediately so the terminal state is correct and the CSS animates.
  */
 export declare function useStaggerReveal(options?: StaggerRevealConfig): {
     targets: import("vue").Ref<HTMLElement[], HTMLElement[]>;

package/dist/composables/motion/useViewTransition.d.ts

@@ -0,0 +1,31 @@
+export interface ViewTransitionResult {
+    /**
+     * Resolves when the transition's `finished` promise settles (or
+     * immediately in the fallback path). Use to route focus per the a11y
+     * MANDATORY: `await startViewTransition(mutate).finished; el.focus()`.
+     * Never rejects — a skipped/aborted transition settles cleanly.
+     */
+    finished: Promise<void>;
+    /** True when the native API ran; false when the instant fallback ran. */
+    transitioned: boolean;
+}
+/**
+ * True when `document.startViewTransition` is available — the feature-detected
+ * predicate consumers gate optional VT-only styling on.
+ */
+export declare function supportsViewTransitions(): boolean;
+/**
+ * Wrap a synchronous DOM mutation in `document.startViewTransition` with an
+ * instant fallback. `mutate` performs the DOM/state change and is called
+ * synchronously in BOTH paths (native and fallback), so the post-mutation DOM
+ * is identical regardless of support.
+ *
+ * @param mutate the synchronous DOM/state change to animate between.
+ * @returns `{ finished, transitioned }` — await `finished` to route focus.
+ *
+ * @example
+ *   const { finished } = startViewTransition(() => { rows.value = reranked });
+ *   await finished;            // animation done
+ *   firstRow.value?.focus();   // consumer routes focus (the a11y MANDATORY)
+ */
+export declare function startViewTransition(mutate: () => void): ViewTransitionResult;

package/dist/composables/motion/useYieldToMain.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Yield control to the main thread, returning a promise that resolves after the
+ * browser has had a chance to run pending input/render work. Native
+ * `scheduler.yield()` when available; otherwise a `MessageChannel` macrotask
+ * (with a `setTimeout(0)` floor). Await it between chunks of a long task to keep
+ * input responsive (the INP lever).
+ *
+ * @example
+ *   for (const chunk of chunks) {
+ *     processChunk(chunk);
+ *     await yieldToMain();   // let the browser breathe between chunks
+ *   }
+ */
+export declare function yieldToMain(): Promise<void>;
+export interface UseYieldToMainReturn {
+    /** True when the native `scheduler.yield()` is available (vs the fallback). */
+    readonly hasNativeYield: boolean;
+    /** Yield to the main thread. Native `scheduler.yield()` or the fallback. */
+    yield: () => Promise<void>;
+}
+/**
+ * Composable wrapper over {@link yieldToMain} that exposes the native-yield
+ * feature flag alongside the bound `yield` function. Consumers loop their work
+ * units and `await ctx.yield()` between chunks to keep input responsive.
+ *
+ * Pure-native (no `vue` import) — call it from setup or anywhere; it owns no
+ * reactive state and no lifecycle, so it has no cleanup obligation.
+ */
+export declare function useYieldToMain(): UseYieldToMainReturn;

package/dist/configurator.js

@@ -1,2 +1,2 @@
-import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-BlaevW0S.js";
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-BR5vUDL8.js";
 export { e as CONFIGURATOR_DENSITY_KEY, t as Configurator, i as ConfiguratorLayer, n as ConfiguratorRow, r as provideConfiguratorDensity, o as useConfiguratorState, a as useOptionalConfiguratorDensity };

package/dist/confirm-dialog.js

@@ -1,6 +1,6 @@
 import { t as e } from "./createLucideIcon-Bn9a1b70.js";
-import { n as t } from "./button-BlOW34DT.js";
-import { t as n } from "./_plugin-vue_export-helper-n-_DRHWS.js";
+import { n as t } from "./button-C0aHmBbt.js";
+import { t as n } from "./_plugin-vue_export-helper-Dq1MygBL.js";
 import { Transition as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, createTextVNode as c, createVNode as l, defineComponent as u, mergeModels as d, openBlock as f, renderSlot as p, toDisplayString as m, unref as h, useModel as g, withCtx as _, withKeys as v, withModifiers as y } from "vue";
 var b = e("loader-circle", [["path", {
 	d: "M21 12a9 9 0 1 1-6.219-8.56",

package/dist/constants-DwBwnG8N.js

@@ -0,0 +1,13 @@
+//#region src/composables/motion/constants.ts
+var e = {
+	canvasNeedle: .08,
+	domHero: .12,
+	domPill: .14,
+	domProgress: .18
+}, t = {
+	canvas: .002,
+	dom: .05,
+	domProgress: .5
+};
+//#endregion
+export { t as n, e as t };

package/dist/context-menu.js

@@ -1,3 +1,3 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./ContextMenuSubContent-DCkweFW9.js";
-import { n as l, r as u, t as d } from "./ContextMenuContent-CvXfU5qz.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./ContextMenuSubContent-gAFxJ-qi.js";
+import { n as l, r as u, t as d } from "./ContextMenuContent-otjFIu8v.js";
 export { u as ContextMenu, s as ContextMenuCheckboxItem, d as ContextMenuContent, t as ContextMenuItem, o as ContextMenuLabel, r as ContextMenuRadioGroup, a as ContextMenuRadioItem, n as ContextMenuSeparator, e as ContextMenuShortcut, c as ContextMenuSubContent, i as ContextMenuSubTrigger, l as ContextMenuTrigger };

package/dist/controls.js

@@ -1,6 +1,6 @@
 import { t as e } from "./cn-DJXf4yaB.js";
-import { t } from "./_plugin-vue_export-helper-n-_DRHWS.js";
-import { t as n } from "./useGlobalDark-PMiP5Jku.js";
+import { t } from "./_plugin-vue_export-helper-Dq1MygBL.js";
+import { t as n } from "./useGlobalDark-B0WvLJE3.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 +1 @@
-export { useGlobalDark } from "./composables/dark";
+export { useGlobalDark, installDarkModeSync } from "./composables/dark";

package/dist/dark.js

@@ -1,2 +1,13 @@
-import { t as e } from "./useGlobalDark-PMiP5Jku.js";
-export { e as useGlobalDark };
+import { t as e } from "./useGlobalDark-B0WvLJE3.js";
+import { nextTick as t, watch as n } from "vue";
+//#region src/composables/dark/installDarkModeSync.ts
+function r(r) {
+	let { isDark: i } = e();
+	n(i, () => {
+		t(() => {
+			requestAnimationFrame(r);
+		});
+	});
+}
+//#endregion
+export { r as installDarkModeSync, e as useGlobalDark };

package/dist/data-table.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./DataTable-Ce00dbHD.js";
+import { n as e, t } from "./DataTable-R8-Zidms.js";
 export { t as DataTable, e as DataTablePagination };

package/dist/dialog.js

@@ -1,3 +1,3 @@
-import { n as e, t } from "./DialogContent-CmCijgX9.js";
-import { a as n, i as r, n as i, o as a, r as o, s, t as c } from "./DialogFooter-DRdaCok0.js";
+import { n as e, t } from "./DialogContent-2fALDSvc.js";
+import { a as n, i as r, n as i, o as a, r as o, s, t as c } from "./DialogFooter-ClrNEOVU.js";
 export { e as Dialog, s as DialogClose, t as DialogContent, o as DialogDescription, c as DialogFooter, n as DialogHeader, i as DialogScrollContent, r as DialogTitle, a as DialogTrigger };

package/dist/disco-glyph.js

@@ -1,2 +1,2 @@
-import { t as e } from "./DiscoGlyph-wRA02zAJ.js";
+import { t as e } from "./DiscoGlyph-C3JfMnRV.js";
 export { e as DiscoGlyph };