@mkbabb/glass-ui 3.1.1 → 3.3.0

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

@@ -0,0 +1,49 @@
+/** An OKLCh color stop. `L` 0..1, `C` 0..~0.4, `h` 0..360. */
+export interface OklchStop {
+    L: number;
+    C: number;
+    h: number;
+}
+/**
+ * The injected color seam (DEC-AT-2, consumed by the AU.W7 blob). Resolves a CSS
+ * color string to a GAMMA-sRGB triple in [0,1]. `defaultBlobColorResolver` is the
+ * opt-in default; a consumer (value.js) may inject its own.
+ */
+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
+ * 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];
+/**
+ * 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
+ * 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).
+ *
+ * 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.
+ */
+export declare function cssToOklch(css: string): OklchStop;
+/** OKLCh stop → `#rrggbb` gamma hex (value.js `oklabToRgb255`). */
+export declare function oklchStopToHex(s: OklchStop): string;
+/**
+ * The OPT-IN default `ColorResolver` — `(css) => gamma [r,g,b]` via
+ * `cssToOklch → oklchToGammaRgb`. The AU.W7 goo-blob requires an INJECTED resolver
+ * and throws by THIS name on a no-resolver mount (the loud failure, not a silent
+ * gray default); value.js supplies its own, the demo story uses this one.
+ */
+export declare const defaultBlobColorResolver: ColorResolver;

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

@@ -0,0 +1,56 @@
+import { type InjectionKey } from "vue";
+/**
+ * Domain-neutral provide/inject DI factory pair — the single source the dock,
+ * dock-layer-group, toggle-group, sortable-list, glyph-face, and configurator
+ * contexts collapse onto (AV.W14). 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`,
+ * label, and (strict) error message.
+ *
+ * Two shapes, chosen per the strict-vs-optional matrix (PROGRESS.md):
+ *  - `createStrictContext<T>(label, outsideError)` — a `use()` that THROWS
+ *    `outsideError` when injected outside its provider (the consumer is
+ *    meaningless without the parent). It ALSO exposes `useOptional()` over the
+ *    SAME key, so a context that is strict for its primary consumer yet must
+ *    read null-safe elsewhere (the dock: `<Slider>` may sit outside) shares one
+ *    key across both `use` shapes — no second symbol, no `any` leak.
+ *  - `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).
+ *
+ * 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
+ * pattern stays a bare `inject(KEY, default)` and is NOT minted here — it is not
+ * a strict-or-optional triplet).
+ */
+export interface StrictContext<T> {
+    /** The typed injection key — exported so an external provider can target it. */
+    readonly KEY: InjectionKey<T>;
+    /** Provide the context to descendants. */
+    provide: (ctx: T) => void;
+    /** Strict — throws `outsideError` when used outside the provider. */
+    use: () => T;
+    /** Befitting-silent over the SAME key — returns `null` outside the provider. */
+    useOptional: () => T | null;
+}
+export interface OptionalContext<T> {
+    /** The typed injection key — exported so an external provider can target it. */
+    readonly KEY: InjectionKey<T>;
+    /** Provide the context to descendants. */
+    provide: (ctx: T) => void;
+    /** Befitting-silent — returns `null` when used outside the provider. */
+    use: () => T | null;
+}
+/**
+ * Strict context factory. `use()` throws `outsideError` outside the provider;
+ * `useOptional()` returns `null` over the same key for the null-safe-elsewhere
+ * case.
+ */
+export declare function createStrictContext<T>(label: string, outsideError: string): StrictContext<T>;
+/**
+ * Optional context factory. `use()` returns `T | null` (befitting-silent); no
+ * strict counterpart is minted.
+ */
+export declare function createOptionalContext<T>(label: string): OptionalContext<T>;

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

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

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

@@ -0,0 +1,23 @@
+/** The localStorage key vueuse `useColorMode`/`useDark` defaults to. The
+ * `useGlobalDark` factory passes no `storageKey`, so this default is canonical. */
+export declare const DARK_MODE_STORAGE_KEY = "vueuse-color-scheme";
+export interface DarkModeSyncScriptOptions {
+    /**
+     * Override the localStorage key the emitted script reads. Defaults to
+     * `vueuse-color-scheme` — the key `useGlobalDark`'s underlying `useDark`
+     * uses. Override ONLY if a consumer reconfigured the vueuse storage key.
+     */
+    storageKey?: string;
+}
+/**
+ * Return the inline `<head>` script STRING that resolves dark/light at parse
+ * time and stamps `<html>` before first paint. Inject it as the FIRST blocking
+ * script in `<head>` (or into an SSR head):
+ *
+ * ```html
+ * <script>${darkModeSyncScript()}</script>
+ * ```
+ *
+ * The function has no DOM side-effect itself — it only builds a string.
+ */
+export declare function darkModeSyncScript(options?: DarkModeSyncScriptOptions): string;

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

@@ -1,2 +1,5 @@
 export { useGlobalDark } from "./useGlobalDark";
+export type { UseGlobalDarkOptions } 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,5 +1,22 @@
-/** Single shared dark mode instance — avoids multiple useDark() watchers racing on classList. */
-export declare const useGlobalDark: () => {
+import type { BasicColorSchema } from "@vueuse/core";
+export interface UseGlobalDarkOptions {
+    /**
+     * The first-paint color scheme seed, threaded to `useDark({ initialValue })`.
+     * ONE-SHOT: only the FIRST `useGlobalDark()` call constructs the singleton, so
+     * only its `initialValue` is honored. A later call passing a CONFLICTING value
+     * THROWS (the misconfiguration is loud, not silently ignored); a matching
+     * re-seed is a no-op. Defaults to vueuse's `"auto"` (prefers-color-scheme).
+     * Pair with `darkModeSyncScript()` so the parse-time `<head>` script and this
+     * runtime seed agree.
+     */
+    initialValue?: BasicColorSchema;
+}
+/**
+ * The single shared dark-mode instance. The first call may pass an
+ * `initialValue` seed (one-shot — see `UseGlobalDarkOptions`); subsequent calls
+ * receive the already-constructed singleton and their `initialValue` is ignored.
+ */
+export declare function useGlobalDark(options?: UseGlobalDarkOptions): {
     isDark: import("@vueuse/core").UseDarkReturn;
     toggleDark: () => void;
     disableTransitions: import("vue").Ref<boolean, boolean>;

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

@@ -2,7 +2,5 @@ export * from "./useResizeObserver";
 export * from "./useTouchGate";
 export * from "./useTokenColor";
 export * from "./useClipboard";
-export * from "./useViewportReady";
-export * from "./useBreakpoint";
-export * from "./useIdleReady";
 export * from "./useUserInvalidAria";
+export * from "./useTextHighlight";

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

@@ -1,34 +1,57 @@
 import { type Ref } from "vue";
+/**
+ * Why a copy did not succeed. `'clipboard-api'` — the async
+ * `navigator.clipboard.writeText` channel threw or rejected; `'exec-command'`
+ * — the legacy `document.execCommand("copy")` fallback returned/threw failure;
+ * `'no-api'` — neither channel exists in this environment (SSR / locked-down).
+ */
+export type CopyFailureReason = "clipboard-api" | "exec-command" | "no-api";
 export interface UseClipboardOptions {
     /** Milliseconds before `copied` auto-resets to `false` (default 1500). */
     resetMs?: number;
+    /**
+     * Called with the NAMED reason when a copy attempt fails on a given
+     * channel. Both the clipboard-API and exec-command arms report through this
+     * (the exec-command arm only after the clipboard-API arm has already
+     * failed). Surfaces the failure instead of swallowing it.
+     */
+    onCopyError?: (reason: CopyFailureReason) => void;
+}
+/** Result of a composable `copy()` — the success flag plus, on failure, the
+ *  named reason the copy did not land. */
+export interface CopyResult {
+    ok: boolean;
+    /** The failure channel when `ok` is false; `undefined` on success. */
+    reason?: CopyFailureReason;
 }
 export interface UseClipboardReturn {
     /** Reactive flag—flips `true` on successful copy, auto-resets after `resetMs`. */
     copied: Ref<boolean>;
-    /** Copy `text` to the clipboard. Returns the success boolean. */
-    copy: (text: string) => Promise<boolean>;
+    /**
+     * Copy `text` to the clipboard. Resolves `{ ok }` on success or
+     * `{ ok: false, reason }` naming the channel that failed — the failure is
+     * REPORTED, never silently swallowed.
+     */
+    copy: (text: string) => Promise<CopyResult>;
 }
 /**
  * Bare clipboard copy—stateless `Promise<boolean>` return, no reactive `copied`
- * flag. P.W5 Lane A.1 (Path B) co-export paralleling the canonical
- * `useClipboard()` composable. Use this when call sites manage their own
- * confirmation state (e.g. hand-rolled `ref + setTimeout`) or in non-component
- * contexts (utility modules, stores).
- *
- * The `resetMs` option is currently a no-op for the bare function (no reactive
- * state to auto-reset); kept on the signature for forward-compatibility with
- * future paired-callback hooks.
+ * flag. Use this when call sites manage their own confirmation state (e.g.
+ * hand-rolled `ref + setTimeout`) or in non-component contexts (utility
+ * modules, stores). A copy failure is reported through `options.onCopyError`
+ * (the boolean return stays the verbatim cross-repo signature).
  *
  * @example
  * import { copyToClipboard } from "@mkbabb/glass-ui";
  *
  * async function shareLink(url: string) {
- *   const ok = await copyToClipboard(url);
+ *   const ok = await copyToClipboard(url, {
+ *     onCopyError: (reason) => toast.show(`Copy failed: ${reason}`),
+ *   });
  *   if (ok) toast.show("Link copied");
  * }
  */
-export declare function copyToClipboard(text: string, _options?: UseClipboardOptions): Promise<boolean>;
+export declare function copyToClipboard(text: string, options?: UseClipboardOptions): Promise<boolean>;
 /**
  * Reactive clipboard copy with auto-reset confirmation flag.
  *

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

@@ -0,0 +1,20 @@
+import { type Ref } from "vue";
+/**
+ * Scope-aware `document.visibilityState` leaf (AV.W14) — the single source for
+ * the `visibilitychange → document.hidden` pattern that the motion composables
+ * (`useRAFLoop`, `useIntersectionPause`) and the WebGL substrate hand-rolled
+ * four times over. Returns a `Ref<boolean>` `hidden` that flips on
+ * `visibilitychange`; SSR-safe (defaults `false` when `document` is absent) and
+ * self-disposing (the listener is removed on scope teardown).
+ *
+ * KISS: a per-call listener bound to the calling scope — NOT a global singleton.
+ * Each consumer's reactive `hidden` ref is independent, so a consumer's own
+ * pause policy (which `hidden`-true states it actually reacts to) is never
+ * fragmented by a shared global flag; the de-dup is the listener boilerplate +
+ * disposal, not the policy.
+ */
+export interface UseDocumentVisibilityReturn {
+    /** Reactive `document.hidden` — `false` under SSR / when the API is absent. */
+    hidden: Ref<boolean>;
+}
+export declare function useDocumentVisibility(): UseDocumentVisibilityReturn;

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

@@ -0,0 +1,40 @@
+/** Match a query against a text-node's content, returning matched char ranges. */
+export type HighlightMatcher = (
+/** The text-node's full string content. */
+text: string, 
+/** The active query (already passed through to the matcher unchanged). */
+query: string) => Array<{
+    start: number;
+    end: number;
+}>;
+export interface UseTextHighlightControls {
+    /** Replace the highlight's range set. Empty array clears the paint. */
+    set: (ranges: Range[]) => void;
+    /**
+     * Walk every text node under `container`, run `matcher` per node, and
+     * highlight the returned `[start, end)` char spans. Replaces the prior set.
+     * The default matcher is a case-insensitive substring scan over `query`.
+     */
+    setFromMatches: (container: HTMLElement, query: string, matcher?: HighlightMatcher) => void;
+    /** Drop every range — the named highlight stops painting. */
+    clear: () => void;
+    /** True when the CSS Custom Highlight API is available (else every op no-ops). */
+    readonly supported: boolean;
+}
+/**
+ * Drive a named CSS Custom Highlight reactively.
+ *
+ * @param name registry key — must match a `::highlight(<name>)` style rule.
+ *   Instances sharing a name multiplex: each contributes its own ranges and
+ *   the shared paint is their union (last to dispose drops the registry entry).
+ *
+ * @example
+ * const hl = useTextHighlight("fuzzy-search");
+ * watch([query, listEl], ([q, el]) => {
+ *     if (el) hl.setFromMatches(el, q, fuzzyRanges);
+ * });
+ *
+ * // Or hand it pre-built ranges directly:
+ * hl.set([range]);
+ */
+export declare function useTextHighlight(name: string): UseTextHighlightControls;

package/dist/composables/glass/webgl/compile.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared WebGL2 shader compile/link pair (AV.W14) — the single error-checked
+ * source the aurora GL setup (`glSetup.ts`) and the goo-blob renderer
+ * (`useMetaballRenderer.ts`) both build their program from. Each consumer was
+ * hand-rolling a byte-identical `compile`/`link` differing only in the error
+ * log prefix; the `label` parameter preserves that per-consumer diagnostic.
+ *
+ * On a compile/link failure the GL resource is deleted before the throw (so a
+ * caller that catches does not leak a dead shader/program), and the GPU info
+ * log is named in the message — the loud failure, not a silent draw of garbage.
+ */
+/** Compile a single shader; throws (and deletes the shader) on COMPILE_STATUS failure. */
+export declare function compileShader(gl: WebGL2RenderingContext, type: number, src: string, label?: string): WebGLShader;
+/** Link a vertex/fragment shader pair; throws (and deletes the program) on LINK_STATUS failure. */
+export declare function linkProgram(gl: WebGL2RenderingContext, vs: WebGLShader, fs: WebGLShader, label?: string): WebGLProgram;

package/dist/composables/glass/webgl/shaders/procedural-color.glsl.d.ts

@@ -0,0 +1,3 @@
+export declare const OETF_GLSL = "\nfloat srgbToLinearCh(float c) {\n    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);\n}\nvec3 srgbToLinear(vec3 c) {\n    return vec3(srgbToLinearCh(c.r), srgbToLinearCh(c.g), srgbToLinearCh(c.b));\n}\n\nfloat linearToSrgbCh(float c) {\n    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\nvec3 linearToSrgb(vec3 c) {\n    return vec3(linearToSrgbCh(c.r), linearToSrgbCh(c.g), linearToSrgbCh(c.b));\n}";
+export declare const FBM_ROT_GLSL = "const mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);";
+export declare const OKLCH_MATRICES_GLSL = "\n// value.js LINEAR_SRGB_TO_LMS (constants.ts), row-major; written here as GLSL\n// columns (= the transpose) so mat3 * vec3 evaluates the row-major M\u00B7v.\nconst mat3 LINEAR_SRGB_TO_LMS = mat3(\n    0.4122214708, 0.2119034982, 0.0883024619,\n    0.5363325363, 0.6806995451, 0.2817188376,\n    0.0514459929, 0.1073969566, 0.6299787005\n);\n\n// value.js srgbToOKLab's INLINE LMS\u2192OKLab coefficients (gamut.ts lines 295-297 \u2014\n// these differ at the ~1e-9 digit from LMS_TO_OKLAB_MATRIX; use the inline ones to\n// mirror the exact value.js path), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_OKLAB = mat3(\n    0.2104542553, 1.9779984951, 0.0259040371,\n    0.7936177850, -2.4285922050, 0.7827717662,\n    -0.0040720468, 0.4505937099, -0.8086757660\n);\n\n// value.js OKLAB_TO_LMS_COEFF (constants.ts), row-major \u2192 GLSL columns. Rows:\n// l = [1, 0.3963377774, 0.2158037573], m = [1, -0.1055613458, -0.0638541728],\n// s = [1, -0.0894841775, -1.2914855480].\nconst mat3 OKLAB_TO_LMS = mat3(\n    1.0, 1.0, 1.0,\n    0.3963377774, -0.1055613458, -0.0894841775,\n    0.2158037573, -0.0638541728, -1.2914855480\n);\n\n// value.js LMS_TO_LINEAR_SRGB (constants.ts), row-major \u2192 GLSL columns.\nconst mat3 LMS_TO_LINEAR_SRGB = mat3(\n    4.0767416621, -1.2684380046, -0.0041960863,\n    -3.3077115913, 2.6097574011, -0.7034186147,\n    0.2309699292, -0.3413193965, 1.7076147010\n);\n\n// Gamma sRGB \u2192 raw OKLab (L, a, b). Mirrors value.js srgbToOKLab.\nvec3 srgbToOklab(vec3 c) {\n    vec3 lin = srgbToLinear(c);\n    vec3 lms = LINEAR_SRGB_TO_LMS * lin;\n    vec3 lmsCbrt = sign(lms) * pow(abs(lms), vec3(1.0 / 3.0));\n    return LMS_TO_OKLAB * lmsCbrt;\n}\n\n// Raw OKLab (L, a, b) \u2192 linear sRGB. Mirrors value.js oklabToLinearSRGB.\nvec3 oklabToLinearSrgb(vec3 lab) {\n    vec3 lms_ = OKLAB_TO_LMS * lab;\n    vec3 lms = lms_ * lms_ * lms_;\n    return LMS_TO_LINEAR_SRGB * lms;\n}\n\n// OKLab \u2192 OKLCh: H in RADIANS. Mirrors value.js rawOklabToOklch (which returns\n// degrees; we stay in radians and only fold to [0, 2pi)).\nvec3 oklabToOklch(vec3 lab) {\n    float C = length(lab.yz);\n    float H = atan(lab.z, lab.y);\n    if (H < 0.0) H += 2.0 * PI;\n    return vec3(lab.x, C, H);\n}\n\n// OKLCh (H radians) \u2192 OKLab. Mirrors value.js rawOklchToOklab.\nvec3 oklchToOklab(vec3 lch) {\n    return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}";

package/dist/composables/glass/webgl/useWebGLCanvas.d.ts

@@ -0,0 +1,55 @@
+export type WebGLSuspendReason = "tab-hidden" | "off-screen" | "manual";
+/** The per-frame hooks a consumer's `setup(gl)` returns. */
+export interface WebGLCanvasFrame {
+    /** Draw one frame at `timeSec`. The consumer uploads its uniforms + draws. */
+    frame: (timeSec: number) => void;
+    /** Demand-gate: is there live motion to render next frame? `false` → park. */
+    shouldContinue: () => boolean;
+    /** Size the canvas + set the viewport. The consumer owns its DPR policy. */
+    resize: () => 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. */
+    teardown?: () => void;
+}
+export interface WebGLCanvasOptions {
+    /** `getContext("webgl2", …)` attributes (the consumer's — e.g. premultiplied alpha). */
+    contextAttrs?: WebGLContextAttributes;
+    /** `"capture"` pre-seeds the `manual` suspension (renderAt-only). Default `"live"`. */
+    mode?: "live" | "capture";
+    /**
+     * Honor `prefers-reduced-motion: reduce` by painting ONE static frame then
+     * parking the loop (AV.W7 G1). The substrate live-monitors the query via a
+     * `matchMedia` `change` listener and re-arms (one static frame) on un-reduce.
+     * Default `true` for live mode, `false` for capture mode (a capture runtime
+     * draws deterministic frames via `renderAt`, never the live loop). A consumer
+     * reads the live value via `handle.reducedMotion` (e.g. aurora's frozen-t).
+     */
+    respectReducedMotion?: boolean;
+    /**
+     * Build the program + geometry on a fresh context. Called on `arm()` AND on
+     * every `webglcontextrestored`. Returns the per-frame hooks.
+     */
+    setup: (gl: WebGL2RenderingContext) => WebGLCanvasFrame;
+}
+export interface WebGLCanvasHandle {
+    /** Run the expensive init (context + `setup` + arm the loop). Idempotent; no-op post-dispose. */
+    arm: () => void;
+    suspend: (reason?: WebGLSuspendReason) => void;
+    resume: (reason?: WebGLSuspendReason) => void;
+    /** Re-arm a parked loop (a setter that re-introduced motion calls this). */
+    wake: () => void;
+    /** Draw one frame at `timeSec` out-of-loop (capture / thumbnail). */
+    renderAt: (timeSec: number) => void;
+    dispose: () => void;
+    /** The live context (null before arm / after dispose / mid-loss). */
+    readonly gl: WebGL2RenderingContext | null;
+    /**
+     * The live `prefers-reduced-motion: reduce` state (AV.W7 G1). The substrate
+     * owns + re-monitors it; consumers read it (e.g. aurora freezes its frame
+     * time at the authored offset while this is `true`). `false` when
+     * `respectReducedMotion` is off.
+     */
+    readonly reducedMotion: boolean;
+}
+export declare function createWebGLCanvas(canvas: HTMLCanvasElement, options: WebGLCanvasOptions): WebGLCanvasHandle;

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

@@ -3,6 +3,7 @@ export * from "../useStaggerReveal";
 export * from "../useScrollProgress";
 export * from "../useRAFLoop";
 export * from "../useIntersectionPause";
-export * from "../useStagger";
 export * from "../useYieldToMain";
+export * from "../usePrioritizedTask";
 export * from "../useViewTransition";
+export * from "../vReveal";

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

@@ -4,4 +4,4 @@ export * from "./useSpringMount";
 export * from "./useSpringPress";
 export * from "./useNumericTransition";
 export * from "./useAnimatedNumber";
-export * from "./useAnimatedNumberMap";
+export * from "./useCountup";

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

@@ -0,0 +1,29 @@
+import { type Ref } from "vue";
+export interface Countup {
+    /** Animate the count-ups inside the currently-active slide/region. */
+    runActive: () => void;
+    /** Snap EVERY `[data-countup]` in the document to its end value (still capture). */
+    settle: () => void;
+    /** Cancel every in-flight tween (also runs on scope-dispose). */
+    cancel: () => void;
+}
+export interface UseCountupOptions {
+    /**
+     * Easing applied to tween progress — a value.js-FREE callable
+     * `(p: number) => number` over `[0, 1]`. A callable keeps the
+     * `NumericAnimation` engine off the value.js boundary (a string name would
+     * dynamic-import the value.js easing registry).
+     */
+    easeFn: (p: number) => number;
+    /** When it returns true, `runActive` is a no-op (e.g. export/print mode). */
+    skip?: () => boolean;
+}
+/**
+ * Walk `[data-countup]` figures under `hostRef` and tween each from 0 → target.
+ *
+ * @example
+ * const { runActive, settle } = useCountup(deckRef, { easeFn: (p) => p });
+ * // on slide-activate: runActive();
+ * // on still-capture:  settle();
+ */
+export declare function useCountup(hostRef: Ref<HTMLElement | null>, opts: UseCountupOptions): Countup;

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

@@ -0,0 +1,41 @@
+export type TaskPriority = "user-blocking" | "user-visible" | "background";
+export interface PostTaskOptions {
+    /** Scheduling priority. Defaults to the platform default ('user-visible'). */
+    priority?: TaskPriority;
+    /** Abort the task before it runs (rejects the returned promise). */
+    signal?: AbortSignal;
+    /** Delay in ms before the task becomes eligible to run. */
+    delay?: number;
+}
+/**
+ * Schedule `callback` at an explicit priority, resolving with its result.
+ * Native `scheduler.postTask` when available; otherwise a `MessageChannel`
+ * macrotask (honouring `delay` via `setTimeout`, and `signal` via a plain
+ * `AbortSignal` check) that cannot order by priority but still runs off the
+ * current task.
+ *
+ * @example
+ *   await postTaskSafe(() => recomputeHistory(), { priority: "background" });
+ */
+export declare function postTaskSafe<T>(callback: () => T, options?: PostTaskOptions): Promise<T>;
+export interface UsePrioritizedTaskReturn {
+    /**
+     * Schedule a unit of work. The controller's `signal` is merged in (its own
+     * `abort()` cancels every task it scheduled), and an explicit `options.signal`
+     * still applies on the fallback path.
+     */
+    postTask: <T>(callback: () => T, options?: PostTaskOptions) => Promise<T>;
+    /** Abort every task scheduled through this controller. */
+    abort: (reason?: unknown) => void;
+}
+/**
+ * Composable wrapper over {@link postTaskSafe} that owns a `TaskController`
+ * (when supported) so a single `abort()` cancels every task it scheduled — the
+ * controller a consumer constructs once and tears down on unmount. When
+ * `TaskController` is absent the controller is a no-op shell and per-task
+ * `options.signal` is the only cancellation channel.
+ *
+ * Pure-native (no `vue` import) — owns no reactive state and no lifecycle, so it
+ * has no cleanup obligation beyond the `abort()` the consumer calls itself.
+ */
+export declare function usePrioritizedTask(priority?: TaskPriority): UsePrioritizedTaskReturn;

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

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from "vue";
+export declare const vReveal: ObjectDirective<HTMLElement, number>;

package/dist/composables/sidebar/useSidebarState.d.ts

@@ -1,4 +1,4 @@
-import type { Ref, MaybeRefOrGetter } from "vue";
+import type { Ref, MaybeRefOrGetter, ComputedRef } from "vue";
 import type { TreeNode, TreeIndexEntry, SidebarSection, SidebarState } from "./types";
 export interface UseSidebarStateOptions<T extends TreeNode = SidebarSection> {
     sections: T[];
@@ -26,7 +26,7 @@ export interface UseSidebarStateOptions<T extends TreeNode = SidebarSection> {
 export interface GenericSidebarState<T extends TreeNode> {
     sections: T[];
     activeId: Ref<string | null>;
-    activeRootId: import("vue").ComputedRef<string | null>;
+    activeRootId: ComputedRef<string | null>;
     treeIndex: Map<string, TreeIndexEntry<T>>;
     isExpanded(id: string): boolean;
     toggleSection(id: string): void;

package/dist/composables/sortable/dragController.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Sortable drag-state controller — the drag lifecycle + cross-list routing.
+ *
+ * Owns the live drag state (`dragId` / `pos` / `dropIndex` / `pointerCaptureActive`)
+ * and the `beginDrag` → `onPointerMove` → `onPointerUp` → `endDrag` lifecycle. It
+ * composes the leaf services: the ghost renderer (visual clone), the drop resolver
+ * (collision/measure + cross-list lookup), and the touch gate (handle constraint +
+ * pointer-capture optimization). Same-list reorders and foreign-list transfers are
+ * both routed here through the unified resolver.
+ */
+import { type ShallowRef } from "vue";
+import type { InstanceHandle, SortableId } from "./types";
+import type { GhostRenderer } from "./ghostRenderer";
+export interface DragControllerDeps {
+    /** Live items array accessor (the reactive source-of-truth). */
+    getItems: () => readonly unknown[];
+    getId: (item: unknown) => SortableId;
+    /** Per-id element cache, shared with the row registry. */
+    elements: Map<SortableId, Element | null>;
+    /** This instance's registry handle (for cross-list lookups). */
+    handle: InstanceHandle;
+    onReorder: (next: unknown[]) => void;
+    /** Horizontal-axis drop resolution (`axis === "x"`). */
+    horizontal: boolean;
+    ghost: GhostRenderer;
+}
+export interface DragController {
+    /** Live id of the dragged row, or null. */
+    dragId: ShallowRef<SortableId | null>;
+    /** Live pointer position in page coordinates, or null. */
+    pos: ShallowRef<{
+        x: number;
+        y: number;
+    } | null>;
+    /** Resolved local drop index, or null. */
+    dropIndex: ShallowRef<number | null>;
+    /** Whether the active drag holds a pointer capture. */
+    pointerCaptureActive: ShallowRef<boolean>;
+    /** Start a drag for the row `id` from the pointerdown event `e`. */
+    beginDrag: (id: SortableId, e: PointerEvent) => void;
+    /** Tear down an in-flight drag (also the defensive scope-dispose path). */
+    endDrag: () => void;
+}
+export declare function createDragController(deps: DragControllerDeps): DragController;

package/dist/composables/sortable/dropResolver.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Sortable drop resolution — pure collision/measure math over the elements map.
+ *
+ * No DOM mutation: these read row bounding rects and resolve an insertion index.
+ * Walking registered row elements via the elements map (rather than subscribing
+ * to each row's box reactively) keeps the cost at O(rows) per pointermove frame
+ * and avoids a layout-thrash storm.
+ *
+ * The module-level instance registry lives here too — it is the cross-list
+ * resolution home: `findForeignTarget` hit-tests sibling instances in the same
+ * group, unifying the local-drop vs foreign-drop index math behind one resolver.
+ */
+import type { InstanceHandle, SortableId } from "./types";
+/**
+ * Every live `useSortable` instance registers here for cross-list lookups. On
+ * drag move, the source instance looks up any other instance in the same group
+ * whose container contains the cursor, and transfers the drop target to it.
+ * Entries are removed on scope dispose.
+ */
+export declare const instances: Set<InstanceHandle>;
+/**
+ * Resolve an insertion index by walking the registered row elements and finding
+ * the first row whose axis midpoint is past the cursor. Returns `list.length`
+ * (drop at end) when the cursor is past every row.
+ */
+export declare function resolveDropIndexIn(elMap: Map<SortableId, Element | null>, list: readonly {
+    id: SortableId;
+}[], clientX: number, clientY: number, horizontal: boolean): number;
+/**
+ * Find a sibling instance in the same group whose container bounds contain the
+ * cursor — the foreign drop target. Returns null when the source has no group or
+ * the cursor is over no sibling.
+ */
+export declare function findForeignTarget(sourceHandle: InstanceHandle, clientX: number, clientY: number): InstanceHandle | null;

package/dist/composables/sortable/ghostRenderer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Sortable drag ghost — the snap-physics + visual clone of the grabbed row.
+ *
+ * The ghost is a fixed-position DOM clone of the source row, positioned under the
+ * grab point so it tracks the cursor rather than teleporting. The clone inherits
+ * scoped `data-v-*` attributes + classes so stylesheet selectors continue to
+ * match, giving a pixel-faithful preview without any per-consumer markup.
+ *
+ * `createGhostRenderer()` returns the stateful trio (`createGhost` / `updateGhost`
+ * / `destroyGhost`) closing over the live ghost element + its cursor offset.
+ */
+/**
+ * True when a computed `border-radius` string has any non-zero corner. Computed
+ * values resolve to space-separated lengths (e.g. `"0px"`, `"6px"`, `"12px 12px
+ * 0px 0px"`) with an optional `/` separating the horizontal/vertical radii of
+ * elliptical corners. A radius is "zero" only when every numeric component parses
+ * to 0; a non-length token (`%`, `auto`) counts as non-zero so we never miss a
+ * rounded corner.
+ *
+ * Exported (and re-exported from `useSortable`) for the D9 drag-ring regression
+ * test — keep it a pure string predicate.
+ */
+export declare function isNonZeroRadius(radius: string): boolean;
+/**
+ * Resolve the effective VISIBLE corner radius for the dragged content. Returns
+ * the source's own computed `border-radius` when it is non-zero; otherwise walks
+ * descendants depth-first and returns the first element's non-zero radius (the
+ * common case where the SortableItem root is unrounded and the rounded surface
+ * lives on an inner child). Returns `null` when nothing in the subtree is rounded
+ * — caller leaves the ghost radius untouched.
+ */
+export declare function resolveVisibleRadius(source: HTMLElement): string | null;
+export interface GhostRenderer {
+    /**
+     * Build the drag ghost by cloning the source row's DOM and positioning a
+     * fixed copy at its current bounding rect.
+     */
+    createGhost: (source: HTMLElement, clientX: number, clientY: number) => void;
+    /** Track the ghost under the cursor at its captured grab offset. */
+    updateGhost: (clientX: number, clientY: number) => void;
+    /** Remove the ghost from the document. */
+    destroyGhost: () => void;
+}
+export declare function createGhostRenderer(): GhostRenderer;

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

@@ -1 +1 @@
-export { useSortable, type UseSortableReturn, type SortableId, } from "./useSortable";
+export { useSortable, type UseSortableReturn, type SortableId } from "./useSortable";