@backbay/glia 0.2.0-alpha.1

package/dist/hooks/useSync.js

@@ -0,0 +1,336 @@
+/**
+ * useSync - Offline-first sync hook with conflict resolution
+ *
+ * Implements the hybrid local+API sync pattern from Backbay.
+ */
+import { useState, useCallback, useEffect, useRef } from 'react';
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        const encoded = JSON.stringify(value);
+        return encoded === undefined ? "null" : encoded;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    const record = value;
+    const keys = Object.keys(record).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record[k])}`).join(",")}}`;
+}
+function hashString(input) {
+    // FNV-1a 32-bit
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i);
+        hash = (hash * 0x01000193) >>> 0;
+    }
+    return hash.toString(36);
+}
+function hashData(value) {
+    return hashString(stableStringify(value));
+}
+function normalizeStoredData(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const record = raw;
+    // v2
+    if ("data" in record &&
+        typeof record.lastModifiedAt === "number" &&
+        typeof record.lastSyncedAt === "number" &&
+        typeof record.lastSyncedHash === "string") {
+        return record;
+    }
+    // v1 (legacy)
+    if ("data" in record && typeof record.timestamp === "number" && typeof record.version === "number") {
+        const legacy = record;
+        const syncedHash = hashData(legacy.data);
+        return {
+            data: legacy.data,
+            lastModifiedAt: legacy.timestamp,
+            lastSyncedAt: legacy.timestamp,
+            lastSyncedHash: syncedHash,
+        };
+    }
+    return null;
+}
+function getStoredData(key) {
+    try {
+        const raw = localStorage.getItem(key);
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        return normalizeStoredData(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+function setStoredData(key, record) {
+    localStorage.setItem(key, JSON.stringify(record));
+}
+// =============================================================================
+// Hook Implementation
+// =============================================================================
+export function useSync({ key, endpoint, debounce = 2000, initialData, fetcher, saver, onConflict, onError, onSync, }) {
+    // State
+    const [data, setDataState] = useState(initialData ?? null);
+    const [status, setStatus] = useState('synced');
+    const [pendingChanges, setPendingChanges] = useState(0);
+    const [lastSyncedAt, setLastSyncedAt] = useState(null);
+    const [conflict, setConflict] = useState(null);
+    const [isLoaded, setIsLoaded] = useState(false);
+    // Refs
+    const debounceTimerRef = useRef(null);
+    const isSavingRef = useRef(false);
+    // Fetcher / saver are injectable to support custom backends.
+    const doFetch = useCallback(async (url) => {
+        if (fetcher)
+            return fetcher(url);
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        return response.json();
+    }, [fetcher]);
+    const doSave = useCallback(async (url, payload) => {
+        if (saver)
+            return saver(url, payload);
+        const response = await fetch(url, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        return response.json();
+    }, [saver]);
+    // Load initial data
+    useEffect(() => {
+        const loadInitial = async () => {
+            // First, check localStorage for cached data
+            const stored = getStoredData(key);
+            if (stored) {
+                setDataState(stored.data);
+                const storedSyncedAt = stored.lastSyncedAt > 0 ? stored.lastSyncedAt : null;
+                setLastSyncedAt(storedSyncedAt);
+                const hasLocalChanges = stored.lastModifiedAt > stored.lastSyncedAt;
+                if (hasLocalChanges) {
+                    setStatus("pending");
+                    setPendingChanges((c) => Math.max(c, 1));
+                }
+            }
+            // Then fetch from server
+            try {
+                const serverData = await doFetch(endpoint);
+                const remoteTimestamp = Date.now();
+                const remoteHash = hashData(serverData);
+                if (stored) {
+                    const hasLocalChanges = stored.lastModifiedAt > stored.lastSyncedAt;
+                    const baselineHash = stored.lastSyncedHash || hashData(stored.data);
+                    const remoteChangedSinceSync = remoteHash !== baselineHash;
+                    if (hasLocalChanges && remoteChangedSinceSync) {
+                        const localConflict = {
+                            local: stored.data,
+                            remote: serverData,
+                            localTimestamp: stored.lastModifiedAt,
+                            remoteTimestamp,
+                        };
+                        setConflict(localConflict);
+                        setStatus("conflict");
+                        onConflict?.(localConflict);
+                    }
+                    else if (!hasLocalChanges) {
+                        // No local changes, use server data
+                        setDataState(serverData);
+                        setStoredData(key, {
+                            data: serverData,
+                            lastModifiedAt: remoteTimestamp,
+                            lastSyncedAt: remoteTimestamp,
+                            lastSyncedHash: remoteHash,
+                        });
+                        setLastSyncedAt(remoteTimestamp);
+                        setPendingChanges(0);
+                        setStatus("synced");
+                    }
+                    else {
+                        // Local has changes, but server hasn't changed since last sync.
+                        // Keep local data and remain pending until the next save.
+                        setStatus("pending");
+                    }
+                }
+                else {
+                    // No local data, use server data
+                    setDataState(serverData);
+                    setStoredData(key, {
+                        data: serverData,
+                        lastModifiedAt: remoteTimestamp,
+                        lastSyncedAt: remoteTimestamp,
+                        lastSyncedHash: remoteHash,
+                    });
+                    setLastSyncedAt(remoteTimestamp);
+                    setPendingChanges(0);
+                    setStatus("synced");
+                }
+            }
+            catch (error) {
+                // Offline - use cached data
+                setStatus("offline");
+                if (error instanceof Error) {
+                    onError?.(error);
+                }
+            }
+            setIsLoaded(true);
+        };
+        loadInitial();
+    }, [key, endpoint, doFetch, onConflict, onError]);
+    // Save to server
+    const saveToServer = useCallback(async (payload) => {
+        const dataToSave = payload ?? data;
+        if (isSavingRef.current || dataToSave === null)
+            return;
+        isSavingRef.current = true;
+        try {
+            setStatus("pending");
+            const serverData = await doSave(endpoint, dataToSave);
+            const syncedAt = Date.now();
+            const syncedHash = hashData(serverData);
+            setDataState(serverData);
+            setStoredData(key, {
+                data: serverData,
+                lastModifiedAt: syncedAt,
+                lastSyncedAt: syncedAt,
+                lastSyncedHash: syncedHash,
+            });
+            setLastSyncedAt(syncedAt);
+            setPendingChanges(0);
+            setStatus("synced");
+            onSync?.(serverData);
+        }
+        catch (error) {
+            setStatus("offline");
+            if (error instanceof Error) {
+                onError?.(error);
+            }
+        }
+        finally {
+            isSavingRef.current = false;
+        }
+    }, [data, endpoint, key, doSave, onSync, onError]);
+    // Set data with debounced sync
+    const setData = useCallback((updater) => {
+        setDataState((prev) => {
+            const newData = typeof updater === "function" ? updater(prev) : updater;
+            const previousStored = getStoredData(key);
+            const now = Date.now();
+            setStoredData(key, {
+                data: newData,
+                lastModifiedAt: now,
+                lastSyncedAt: previousStored?.lastSyncedAt ?? 0,
+                lastSyncedHash: previousStored?.lastSyncedHash ?? "",
+            });
+            setPendingChanges((c) => c + 1);
+            setStatus("pending");
+            // Clear existing debounce timer
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+            // Set new debounce timer
+            debounceTimerRef.current = setTimeout(() => {
+                saveToServer();
+            }, debounce);
+            return newData;
+        });
+    }, [key, debounce, saveToServer]);
+    // Force save (bypass debounce)
+    const forceSave = useCallback(async () => {
+        if (debounceTimerRef.current) {
+            clearTimeout(debounceTimerRef.current);
+            debounceTimerRef.current = null;
+        }
+        await saveToServer();
+    }, [saveToServer]);
+    // Refresh from server
+    const refresh = useCallback(async () => {
+        try {
+            const serverData = await doFetch(endpoint);
+            const syncedAt = Date.now();
+            const syncedHash = hashData(serverData);
+            setDataState(serverData);
+            setStoredData(key, {
+                data: serverData,
+                lastModifiedAt: syncedAt,
+                lastSyncedAt: syncedAt,
+                lastSyncedHash: syncedHash,
+            });
+            setLastSyncedAt(syncedAt);
+            setPendingChanges(0);
+            setConflict(null);
+            setStatus("synced");
+        }
+        catch (error) {
+            setStatus("offline");
+            if (error instanceof Error) {
+                onError?.(error);
+            }
+        }
+    }, [endpoint, key, doFetch, onError]);
+    // Resolve conflict
+    const resolveConflict = useCallback(async (resolution) => {
+        if (!conflict)
+            return;
+        switch (resolution) {
+            case "keep_local":
+                // Keep local, push to server
+                setDataState(conflict.local);
+                setConflict(null);
+                setStatus("pending");
+                setPendingChanges((c) => Math.max(c, 1));
+                await saveToServer(conflict.local);
+                break;
+            case "use_remote": {
+                // Use remote, discard local
+                const remoteHash = hashData(conflict.remote);
+                setDataState(conflict.remote);
+                setStoredData(key, {
+                    data: conflict.remote,
+                    lastModifiedAt: conflict.remoteTimestamp,
+                    lastSyncedAt: conflict.remoteTimestamp,
+                    lastSyncedHash: remoteHash,
+                });
+                setLastSyncedAt(conflict.remoteTimestamp);
+                setPendingChanges(0);
+                setConflict(null);
+                setStatus("synced");
+                break;
+            }
+            case "create_copy":
+                // Keep local as copy, also keep remote
+                // This would typically save local to a new key/endpoint
+                // For now, we just keep local
+                setDataState(conflict.local);
+                setConflict(null);
+                setStatus("pending");
+                setPendingChanges((c) => Math.max(c, 1));
+                await saveToServer(conflict.local);
+                break;
+        }
+    }, [conflict, key, saveToServer]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+        };
+    }, []);
+    return {
+        data,
+        setData,
+        status,
+        pendingChanges,
+        lastSyncedAt,
+        conflict,
+        resolveConflict,
+        forceSave,
+        refresh,
+        isLoaded,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * bb-ui - Agent-native web UI standard and component library
+ *
+ * Three pillars:
+ * - bb-protocol: Discovery and execution layer for agent-native websites
+ * - bb-components: React primitives for building agentic UIs
+ * - bb-workspace: Agent-composable UI specification runtime
+ *
+ * Plus:
+ * - primitives: UI components (atoms, molecules, organisms)
+ * - theme: Design system with multiple themes
+ */
+export * from './protocol/index.js';
+export * from './components/index.js';
+export * from './hooks/index.js';
+export * from './workspace/index.js';
+export * from './primitives/index.js';
+export * from './theme/index.js';
+export * from './lib/utils.js';
+export * from './emotion/index.js';
+export * from './vision/index.js';
+export * from './audio/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,cAAc,qBAAqB,CAAC;AAMpC,cAAc,uBAAuB,CAAC;AAMtC,cAAc,kBAAkB,CAAC;AAMjC,cAAc,sBAAsB,CAAC;AAMrC,cAAc,uBAAuB,CAAC;AAMtC,cAAc,kBAAkB,CAAC;AAMjC,cAAc,gBAAgB,CAAC;AAM/B,cAAc,oBAAoB,CAAC;AAMnC,cAAc,mBAAmB,CAAC;AAMlC,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,52 @@
+/**
+ * bb-ui - Agent-native web UI standard and component library
+ *
+ * Three pillars:
+ * - bb-protocol: Discovery and execution layer for agent-native websites
+ * - bb-components: React primitives for building agentic UIs
+ * - bb-workspace: Agent-composable UI specification runtime
+ *
+ * Plus:
+ * - primitives: UI components (atoms, molecules, organisms)
+ * - theme: Design system with multiple themes
+ */
+// =============================================================================
+// Protocol (Discovery + Execution)
+// =============================================================================
+export * from './protocol/index.js';
+// =============================================================================
+// Components
+// =============================================================================
+export * from './components/index.js';
+// =============================================================================
+// Hooks
+// =============================================================================
+export * from './hooks/index.js';
+// =============================================================================
+// Workspace (Agent-composable UI)
+// =============================================================================
+export * from './workspace/index.js';
+// =============================================================================
+// Primitives (UI Components)
+// =============================================================================
+export * from './primitives/index.js';
+// =============================================================================
+// Theme
+// =============================================================================
+export * from './theme/index.js';
+// =============================================================================
+// Utilities
+// =============================================================================
+export * from './lib/utils.js';
+// =============================================================================
+// Emotion System
+// =============================================================================
+export * from './emotion/index.js';
+// =============================================================================
+// Vision
+// =============================================================================
+export * from './vision/index.js';
+// =============================================================================
+// Audio
+// =============================================================================
+export * from './audio/index.js';

package/dist/lib/motion.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Motion utilities for framer-motion type compatibility
+ * Provides properly typed cubic-bezier easing functions
+ */
+/** Cubic bezier easing tuple type */
+export type CubicBezier = [number, number, number, number];
+/** Common easing curves */
+export declare const easings: {
+    /** Smooth ease-out curve */
+    readonly smooth: CubicBezier;
+    /** Elastic ease-out */
+    readonly elastic: CubicBezier;
+    /** Quick ease-in-out */
+    readonly quick: CubicBezier;
+    /** Gentle ease */
+    readonly gentle: CubicBezier;
+};
+/**
+ * Creates a properly typed transition config
+ */
+export declare function createTransition(config: {
+    delay?: number;
+    duration?: number;
+    ease?: CubicBezier | string;
+}): {
+    delay?: number;
+    duration?: number;
+    ease?: CubicBezier | string;
+};
+//# sourceMappingURL=motion.d.ts.map

package/dist/lib/motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/lib/motion.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qCAAqC;AACrC,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE3D,2BAA2B;AAC3B,eAAO,MAAM,OAAO;IAClB,4BAA4B;qBACE,WAAW;IACzC,uBAAuB;sBACgB,WAAW;IAClD,wBAAwB;oBACG,WAAW;IACtC,kBAAkB;qBACc,WAAW;CACnC,CAAC;AAEX;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;CAC7B;YAHS,MAAM;eACH,MAAM;WACV,WAAW,GAAG,MAAM;EAG5B"}

package/dist/lib/motion.js

@@ -0,0 +1,21 @@
+/**
+ * Motion utilities for framer-motion type compatibility
+ * Provides properly typed cubic-bezier easing functions
+ */
+/** Common easing curves */
+export const easings = {
+    /** Smooth ease-out curve */
+    smooth: [0.22, 1, 0.36, 1],
+    /** Elastic ease-out */
+    elastic: [0.68, -0.55, 0.265, 1.55],
+    /** Quick ease-in-out */
+    quick: [0.4, 0, 0.2, 1],
+    /** Gentle ease */
+    gentle: [0.25, 0.1, 0.25, 1],
+};
+/**
+ * Creates a properly typed transition config
+ */
+export function createTransition(config) {
+    return config;
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,35 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Generate neon glow shadow styles
+ */
+export declare function glow(color?: "cyan" | "magenta" | "emerald", intensity?: "low" | "medium" | "high"): string;
+/**
+ * Generate HUD-style conic gradient for progress rings
+ */
+export declare function hudGrad(progress?: number, colors?: {
+    start?: string;
+    middle?: string;
+    end?: string;
+}): string;
+/**
+ * Format numbers with appropriate suffixes (K, M, B)
+ */
+export declare function formatNumber(num: number): string;
+/**
+ * Animate number changes with a spring-like effect
+ */
+export declare function animateNumber(from: number, to: number, duration: number | undefined, onUpdate: (value: number) => void, easing?: (t: number) => number): void;
+/**
+ * Animate float changes without rounding (for smooth SVG/progress animations)
+ */
+export declare function animateFloat(from: number, to: number, duration: number | undefined, onUpdate: (value: number) => void, easing?: (t: number) => number): void;
+/**
+ * Debounce function for search/input handling
+ */
+export declare function debounce<T extends (...args: unknown[]) => unknown>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Check if user prefers reduced motion
+ */
+export declare function prefersReducedMotion(): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAQ,MAAM,MAAM,CAAC;AAG7C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC;AAED;;GAEG;AACH,wBAAgB,IAAI,CAClB,KAAK,GAAE,MAAM,GAAG,SAAS,GAAG,SAAkB,EAC9C,SAAS,GAAE,KAAK,GAAG,QAAQ,GAAG,MAAiB,UAgBhD;AAED;;GAEG;AACH,wBAAgB,OAAO,CACrB,QAAQ,GAAE,MAAa,EACvB,MAAM,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,UAgB3D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKhD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,YAAO,EACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EACjC,MAAM,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAA2B,QAmBnD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,YAAO,EACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EACjC,MAAM,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAA2B,QAmBnD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EAChE,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,GACX,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAMlC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAG9C"}

package/dist/lib/utils.js

@@ -0,0 +1,102 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+/**
+ * Generate neon glow shadow styles
+ */
+export function glow(color = "cyan", intensity = "medium") {
+    const colorMap = {
+        cyan: "var(--cyan-neon)",
+        magenta: "var(--magenta-neon)",
+        emerald: "var(--emerald-neon)",
+    };
+    const intensityMap = {
+        low: "0 0 10px",
+        medium: "0 0 20px, 0 0 40px",
+        high: "0 0 20px, 0 0 40px, 0 0 80px",
+    };
+    const hslColor = `hsl(${colorMap[color]})`;
+    return `${intensityMap[intensity]} ${hslColor}`;
+}
+/**
+ * Generate HUD-style conic gradient for progress rings
+ */
+export function hudGrad(progress = 0.75, colors) {
+    const defaultColors = {
+        start: "hsl(var(--cyan-neon))",
+        middle: "hsl(var(--magenta-neon))",
+        end: "hsl(var(--emerald-neon))",
+    };
+    const gradColors = { ...defaultColors, ...colors };
+    const progressDeg = progress * 360;
+    return `conic-gradient(from 0deg at 50% 50%, ${gradColors.start} 0deg, ${gradColors.middle} ${progressDeg / 2}deg, ${gradColors.end} ${progressDeg}deg, transparent ${progressDeg}deg, transparent 360deg)`;
+}
+/**
+ * Format numbers with appropriate suffixes (K, M, B)
+ */
+export function formatNumber(num) {
+    if (num >= 1e9)
+        return (num / 1e9).toFixed(1) + "B";
+    if (num >= 1e6)
+        return (num / 1e6).toFixed(1) + "M";
+    if (num >= 1e3)
+        return (num / 1e3).toFixed(1) + "K";
+    return num.toString();
+}
+/**
+ * Animate number changes with a spring-like effect
+ */
+export function animateNumber(from, to, duration = 1000, onUpdate, easing = (t) => t * (2 - t) // ease-out quad
+) {
+    const startTime = Date.now();
+    const delta = to - from;
+    const animate = () => {
+        const elapsed = Date.now() - startTime;
+        const progress = Math.min(elapsed / duration, 1);
+        const easedProgress = easing(progress);
+        const currentValue = from + delta * easedProgress;
+        onUpdate(Math.round(currentValue));
+        if (progress < 1) {
+            requestAnimationFrame(animate);
+        }
+    };
+    requestAnimationFrame(animate);
+}
+/**
+ * Animate float changes without rounding (for smooth SVG/progress animations)
+ */
+export function animateFloat(from, to, duration = 1000, onUpdate, easing = (t) => t * (2 - t)) {
+    const startTime = Date.now();
+    const delta = to - from;
+    const animate = () => {
+        const elapsed = Date.now() - startTime;
+        const progress = Math.min(elapsed / duration, 1);
+        const easedProgress = easing(progress);
+        const currentValue = from + delta * easedProgress;
+        onUpdate(currentValue);
+        if (progress < 1) {
+            requestAnimationFrame(animate);
+        }
+    };
+    requestAnimationFrame(animate);
+}
+/**
+ * Debounce function for search/input handling
+ */
+export function debounce(func, wait) {
+    let timeout;
+    return (...args) => {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => func(...args), wait);
+    };
+}
+/**
+ * Check if user prefers reduced motion
+ */
+export function prefersReducedMotion() {
+    if (typeof window === "undefined")
+        return false;
+    return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}

package/dist/primitives/ambient/DustMotesLayer.d.ts

@@ -0,0 +1,16 @@
+export interface DustMotesLayerProps {
+    /** Override particle colors */
+    colors?: string[];
+    /** Override density (0-1) */
+    density?: number;
+    /** Override speed multiplier */
+    speed?: number;
+    /** Override size range [min, max] */
+    sizeRange?: [number, number];
+    /** Container className */
+    className?: string;
+    /** Disable animations */
+    disabled?: boolean;
+}
+export declare function DustMotesLayer({ colors: propColors, density: propDensity, speed: propSpeed, sizeRange: propSizeRange, className, disabled, }: DustMotesLayerProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=DustMotesLayer.d.ts.map

package/dist/primitives/ambient/DustMotesLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DustMotesLayer.d.ts","sourceRoot":"","sources":["../../../src/primitives/ambient/DustMotesLayer.tsx"],"names":[],"mappings":"AAuBA,MAAM,WAAW,mBAAmB;IAClC,+BAA+B;IAC/B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,0BAA0B;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yBAAyB;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAwFD,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,aAAa,EACxB,SAAS,EACT,QAAgB,GACjB,EAAE,mBAAmB,kDAkErB"}