@revealui/sync 0.0.0-canary-20260409021642

package/dist/hooks/useConversations.d.ts

@@ -0,0 +1,31 @@
+import type { MutationResult } from '../mutations.js';
+export interface ConversationRecord {
+    id: string;
+    user_id: string;
+    agent_id: string;
+    title?: string | null;
+    status: string;
+    device_id?: string | null;
+    version: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface CreateConversationInput {
+    agent_id: string;
+    title?: string;
+    device_id?: string;
+}
+export interface UpdateConversationInput {
+    title?: string;
+    status?: string;
+}
+export interface UseConversationsResult {
+    conversations: ConversationRecord[];
+    isLoading: boolean;
+    error: Error | null;
+    create: (data: CreateConversationInput) => Promise<MutationResult<ConversationRecord>>;
+    update: (id: string, data: UpdateConversationInput) => Promise<MutationResult<ConversationRecord>>;
+    remove: (id: string) => Promise<MutationResult<void>>;
+}
+export declare function useConversations(_userId: string): UseConversationsResult;
+//# sourceMappingURL=useConversations.d.ts.map

package/dist/hooks/useConversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversations.d.ts","sourceRoot":"","sources":["../../src/hooks/useConversations.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAKtD,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,kBAAkB,EAAE,CAAC;IACpC,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,CAAC,IAAI,EAAE,uBAAuB,KAAK,OAAO,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC;IACvF,MAAM,EAAE,CACN,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,uBAAuB,KAC1B,OAAO,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC;IACjD,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;CACvD;AAID,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,sBAAsB,CAuBxE"}

package/dist/hooks/useConversations.js

@@ -0,0 +1,26 @@
+'use client';
+import { useShape } from '@electric-sql/react';
+import { fetchWithTimeout } from '../fetch-with-timeout.js';
+import { useSyncMutations } from '../mutations.js';
+import { useElectricConfig } from '../provider/index.js';
+import { toRecords } from '../shape-utils.js';
+// _userId kept for API compatibility — filtering is enforced by the server-side
+// proxy at /api/shapes/conversations, which reads the session cookie directly.
+export function useConversations(_userId) {
+    const { proxyBaseUrl } = useElectricConfig();
+    // The proxy validates the session and enforces row-level filtering server-side.
+    // Client-provided params are not forwarded — the proxy overrides them.
+    const { data, isLoading, error } = useShape({
+        url: `${proxyBaseUrl}/api/shapes/conversations`,
+        fetchClient: fetchWithTimeout,
+    });
+    const { create, update, remove } = useSyncMutations('conversations');
+    return {
+        conversations: toRecords(data),
+        isLoading,
+        error: error || null,
+        create,
+        update,
+        remove,
+    };
+}

package/dist/hooks/useCoordinationSessions.d.ts

@@ -0,0 +1,35 @@
+import type { MutationResult } from '../mutations.js';
+export interface CoordinationSessionRecord {
+    id: string;
+    agent_id: string;
+    started_at: string;
+    ended_at: string | null;
+    task: string;
+    status: string;
+    pid: number | null;
+    tools: Record<string, number> | null;
+    metadata: Record<string, unknown> | null;
+}
+export interface CreateCoordinationSessionInput {
+    agent_id: string;
+    task?: string;
+    pid?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateCoordinationSessionInput {
+    task?: string;
+    status?: string;
+    ended_at?: string;
+    tools?: Record<string, number>;
+    metadata?: Record<string, unknown>;
+}
+export interface UseCoordinationSessionsResult {
+    sessions: CoordinationSessionRecord[];
+    isLoading: boolean;
+    error: Error | null;
+    create: (data: CreateCoordinationSessionInput) => Promise<MutationResult<CoordinationSessionRecord>>;
+    update: (id: string, data: UpdateCoordinationSessionInput) => Promise<MutationResult<CoordinationSessionRecord>>;
+    remove: (id: string) => Promise<MutationResult<void>>;
+}
+export declare function useCoordinationSessions(): UseCoordinationSessionsResult;
+//# sourceMappingURL=useCoordinationSessions.d.ts.map

package/dist/hooks/useCoordinationSessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCoordinationSessions.d.ts","sourceRoot":"","sources":["../../src/hooks/useCoordinationSessions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAKtD,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC1C;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,8BAA8B;IAC7C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,yBAAyB,EAAE,CAAC;IACtC,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,CACN,IAAI,EAAE,8BAA8B,KACjC,OAAO,CAAC,cAAc,CAAC,yBAAyB,CAAC,CAAC,CAAC;IACxD,MAAM,EAAE,CACN,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,8BAA8B,KACjC,OAAO,CAAC,cAAc,CAAC,yBAAyB,CAAC,CAAC,CAAC;IACxD,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;CACvD;AAED,wBAAgB,uBAAuB,IAAI,6BAA6B,CAqBvE"}

package/dist/hooks/useCoordinationSessions.js

@@ -0,0 +1,22 @@
+'use client';
+import { useShape } from '@electric-sql/react';
+import { fetchWithTimeout } from '../fetch-with-timeout.js';
+import { useSyncMutations } from '../mutations.js';
+import { useElectricConfig } from '../provider/index.js';
+import { toRecords } from '../shape-utils.js';
+export function useCoordinationSessions() {
+    const { proxyBaseUrl } = useElectricConfig();
+    const { data, isLoading, error } = useShape({
+        url: `${proxyBaseUrl}/api/shapes/coordination-sessions`,
+        fetchClient: fetchWithTimeout,
+    });
+    const { create, update, remove } = useSyncMutations('coordination-sessions');
+    return {
+        sessions: toRecords(data),
+        isLoading,
+        error: error || null,
+        create,
+        update,
+        remove,
+    };
+}

package/dist/hooks/useCoordinationWorkItems.d.ts

@@ -0,0 +1,41 @@
+import type { MutationResult } from '../mutations.js';
+export interface CoordinationWorkItemRecord {
+    id: string;
+    title: string;
+    description: string | null;
+    status: string;
+    priority: number;
+    owner_agent: string | null;
+    owner_session: string | null;
+    parent_id: string | null;
+    metadata: Record<string, unknown> | null;
+    created_at: string;
+    updated_at: string;
+    completed_at: string | null;
+}
+export interface CreateCoordinationWorkItemInput {
+    title: string;
+    description?: string;
+    priority?: number;
+    owner_agent?: string;
+    parent_id?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateCoordinationWorkItemInput {
+    title?: string;
+    description?: string;
+    status?: string;
+    priority?: number;
+    owner_agent?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UseCoordinationWorkItemsResult {
+    workItems: CoordinationWorkItemRecord[];
+    isLoading: boolean;
+    error: Error | null;
+    create: (data: CreateCoordinationWorkItemInput) => Promise<MutationResult<CoordinationWorkItemRecord>>;
+    update: (id: string, data: UpdateCoordinationWorkItemInput) => Promise<MutationResult<CoordinationWorkItemRecord>>;
+    remove: (id: string) => Promise<MutationResult<void>>;
+}
+export declare function useCoordinationWorkItems(): UseCoordinationWorkItemsResult;
+//# sourceMappingURL=useCoordinationWorkItems.d.ts.map

package/dist/hooks/useCoordinationWorkItems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCoordinationWorkItems.d.ts","sourceRoot":"","sources":["../../src/hooks/useCoordinationWorkItems.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAKtD,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,+BAA+B;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,+BAA+B;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,8BAA8B;IAC7C,SAAS,EAAE,0BAA0B,EAAE,CAAC;IACxC,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,CACN,IAAI,EAAE,+BAA+B,KAClC,OAAO,CAAC,cAAc,CAAC,0BAA0B,CAAC,CAAC,CAAC;IACzD,MAAM,EAAE,CACN,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,+BAA+B,KAClC,OAAO,CAAC,cAAc,CAAC,0BAA0B,CAAC,CAAC,CAAC;IACzD,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;CACvD;AAED,wBAAgB,wBAAwB,IAAI,8BAA8B,CAqBzE"}

package/dist/hooks/useCoordinationWorkItems.js

@@ -0,0 +1,22 @@
+'use client';
+import { useShape } from '@electric-sql/react';
+import { fetchWithTimeout } from '../fetch-with-timeout.js';
+import { useSyncMutations } from '../mutations.js';
+import { useElectricConfig } from '../provider/index.js';
+import { toRecords } from '../shape-utils.js';
+export function useCoordinationWorkItems() {
+    const { proxyBaseUrl } = useElectricConfig();
+    const { data, isLoading, error } = useShape({
+        url: `${proxyBaseUrl}/api/shapes/coordination-work-items`,
+        fetchClient: fetchWithTimeout,
+    });
+    const { create, update, remove } = useSyncMutations('coordination-work-items');
+    return {
+        workItems: toRecords(data),
+        isLoading,
+        error: error || null,
+        create,
+        update,
+        remove,
+    };
+}

package/dist/hooks/useOfflineCache.d.ts

@@ -0,0 +1,32 @@
+interface UseOfflineCacheOptions {
+    /** ElectricSQL shape subscription URL. */
+    shapeUrl: string;
+    /** Unique key for the localStorage cache entry. */
+    cacheKey: string;
+    /** How long cached data is considered fresh (seconds). Defaults to 3600. */
+    ttlSeconds?: number;
+}
+interface UseOfflineCacheResult<T> {
+    /** The current data — live from the shape when online, cached when offline. */
+    data: T[];
+    /** Whether the browser has network connectivity. */
+    isOnline: boolean;
+    /** Whether the shape subscription is currently loading fresh data. */
+    isSyncing: boolean;
+    /** Timestamp of the most recent successful sync to cache. */
+    lastSyncedAt: Date | null;
+    /** Shape subscription or cache-read error, if any. */
+    error: Error | null;
+}
+/**
+ * Wrap an ElectricSQL `useShape` subscription with offline-first caching.
+ *
+ * When online the hook delegates to `useShape` and mirrors results into
+ * `localStorage`. When offline (or during initial load) it returns the
+ * most recent cached snapshot if one exists within the TTL window.
+ *
+ * @typeParam T - Row type returned by the shape subscription.
+ */
+export declare function useOfflineCache<T>(options: UseOfflineCacheOptions): UseOfflineCacheResult<T>;
+export {};
+//# sourceMappingURL=useOfflineCache.d.ts.map

package/dist/hooks/useOfflineCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOfflineCache.d.ts","sourceRoot":"","sources":["../../src/hooks/useOfflineCache.ts"],"names":[],"mappings":"AAmBA,UAAU,sBAAsB;IAC9B,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,qBAAqB,CAAC,CAAC;IAC/B,+EAA+E;IAC/E,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,oDAAoD;IACpD,QAAQ,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,SAAS,EAAE,OAAO,CAAC;IACnB,6DAA6D;IAC7D,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;IAC1B,sDAAsD;IACtD,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAqED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,sBAAsB,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAiD5F"}

package/dist/hooks/useOfflineCache.js

@@ -0,0 +1,129 @@
+'use client';
+import { useShape } from '@electric-sql/react';
+import { useEffect, useRef, useState } from 'react';
+import { fetchWithTimeout } from '../fetch-with-timeout.js';
+import { toRecords } from '../shape-utils.js';
+import { useOnlineStatus } from './useOnlineStatus.js';
+/** Prefix for all offline-cache localStorage keys. */
+const CACHE_PREFIX = 'revealui:cache:';
+/** Default time-to-live for cached data (seconds). */
+const DEFAULT_TTL_SECONDS = 3600;
+/**
+ * Check whether `localStorage` is usable.
+ */
+function hasLocalStorage() {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    try {
+        const testKey = '__revealui_oc_test__';
+        window.localStorage.setItem(testKey, '1');
+        window.localStorage.removeItem(testKey);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read cached data from localStorage. Returns `null` when the entry is
+ * missing, expired, or unreadable.
+ */
+function readCache(cacheKey, ttlSeconds) {
+    if (!hasLocalStorage()) {
+        return null;
+    }
+    try {
+        const raw = window.localStorage.getItem(CACHE_PREFIX + cacheKey);
+        if (raw === null) {
+            return null;
+        }
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.data)) {
+            return null;
+        }
+        // Check TTL.
+        const cachedTime = new Date(parsed.cachedAt).getTime();
+        if (Number.isNaN(cachedTime)) {
+            return null;
+        }
+        const ageSeconds = (Date.now() - cachedTime) / 1_000;
+        if (ageSeconds > ttlSeconds) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write data to the localStorage cache. Silently ignores failures.
+ */
+function writeCache(cacheKey, data) {
+    if (!hasLocalStorage()) {
+        return;
+    }
+    try {
+        const payload = {
+            data,
+            cachedAt: new Date().toISOString(),
+        };
+        window.localStorage.setItem(CACHE_PREFIX + cacheKey, JSON.stringify(payload));
+    }
+    catch {
+        // Quota exceeded or private browsing — drop silently.
+    }
+}
+/**
+ * Wrap an ElectricSQL `useShape` subscription with offline-first caching.
+ *
+ * When online the hook delegates to `useShape` and mirrors results into
+ * `localStorage`. When offline (or during initial load) it returns the
+ * most recent cached snapshot if one exists within the TTL window.
+ *
+ * @typeParam T - Row type returned by the shape subscription.
+ */
+export function useOfflineCache(options) {
+    const { shapeUrl, cacheKey, ttlSeconds = DEFAULT_TTL_SECONDS } = options;
+    const { isOnline } = useOnlineStatus();
+    // Shape subscription — runs continuously; ElectricSQL handles reconnection.
+    const shape = useShape({ url: shapeUrl, fetchClient: fetchWithTimeout });
+    const [lastSyncedAt, setLastSyncedAt] = useState(null);
+    // Keep a ref to avoid stale closures in the sync effect.
+    const cacheKeyRef = useRef(cacheKey);
+    cacheKeyRef.current = cacheKey;
+    // Persist live data to cache whenever the shape delivers fresh rows.
+    const shapeData = shape.data;
+    useEffect(() => {
+        if (!isOnline) {
+            return;
+        }
+        if (!Array.isArray(shapeData) || shapeData.length === 0) {
+            return;
+        }
+        const typed = toRecords(shapeData);
+        writeCache(cacheKeyRef.current, typed);
+        setLastSyncedAt(new Date());
+    }, [shapeData, isOnline]);
+    // Determine what to return.
+    if (isOnline && Array.isArray(shapeData) && shapeData.length > 0) {
+        return {
+            data: toRecords(shapeData),
+            isOnline,
+            isSyncing: shape.isLoading,
+            lastSyncedAt,
+            error: shape.error || null,
+        };
+    }
+    // Offline or shape has not loaded yet — try the cache.
+    const cached = readCache(cacheKey, ttlSeconds);
+    const cachedSyncDate = cached !== null ? new Date(cached.cachedAt) : null;
+    return {
+        data: cached?.data ?? [],
+        isOnline,
+        isSyncing: isOnline && shape.isLoading,
+        lastSyncedAt: lastSyncedAt ?? cachedSyncDate,
+        error: shape.error || null,
+    };
+}

package/dist/hooks/useOnlineStatus.d.ts

@@ -0,0 +1,21 @@
+export interface OnlineStatusResult {
+    /** Whether the browser currently has network connectivity. */
+    isOnline: boolean;
+    /** Whether the connection was recently restored (resets after 5 s). */
+    wasOffline: boolean;
+    /** Timestamp of the last time the browser was confirmed online. */
+    lastOnlineAt: Date | null;
+}
+/**
+ * Track browser online/offline status with reconnection awareness.
+ *
+ * - `isOnline` reflects `navigator.onLine` and live `online`/`offline` events.
+ * - `wasOffline` becomes `true` when connectivity is restored and resets to
+ *   `false` after 5 seconds.
+ * - `lastOnlineAt` records the most recent reconnection timestamp.
+ *
+ * During SSR (when `window` is not available) the hook returns
+ * `{ isOnline: true, wasOffline: false, lastOnlineAt: null }`.
+ */
+export declare function useOnlineStatus(): OnlineStatusResult;
+//# sourceMappingURL=useOnlineStatus.d.ts.map

package/dist/hooks/useOnlineStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnlineStatus.d.ts","sourceRoot":"","sources":["../../src/hooks/useOnlineStatus.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,kBAAkB;IACjC,8DAA8D;IAC9D,QAAQ,EAAE,OAAO,CAAC;IAClB,uEAAuE;IACvE,UAAU,EAAE,OAAO,CAAC;IACpB,mEAAmE;IACnE,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;CAC3B;AAiBD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,IAAI,kBAAkB,CAuDpD"}

package/dist/hooks/useOnlineStatus.js

@@ -0,0 +1,74 @@
+'use client';
+import { useEffect, useRef, useState } from 'react';
+/** Duration in ms before `wasOffline` resets after reconnection. */
+const WAS_OFFLINE_RESET_MS = 5_000;
+/** SSR-safe default: assume online when `window` is unavailable. */
+const SSR_DEFAULT = {
+    isOnline: true,
+    wasOffline: false,
+    lastOnlineAt: null,
+};
+/**
+ * Check whether the current environment is a browser.
+ * Returns `false` during SSR / Node.js test runs without a DOM.
+ */
+function isBrowser() {
+    return typeof window !== 'undefined';
+}
+/**
+ * Track browser online/offline status with reconnection awareness.
+ *
+ * - `isOnline` reflects `navigator.onLine` and live `online`/`offline` events.
+ * - `wasOffline` becomes `true` when connectivity is restored and resets to
+ *   `false` after 5 seconds.
+ * - `lastOnlineAt` records the most recent reconnection timestamp.
+ *
+ * During SSR (when `window` is not available) the hook returns
+ * `{ isOnline: true, wasOffline: false, lastOnlineAt: null }`.
+ */
+export function useOnlineStatus() {
+    const [isOnline, setIsOnline] = useState(() => (isBrowser() ? navigator.onLine : true));
+    const [wasOffline, setWasOffline] = useState(false);
+    const [lastOnlineAt, setLastOnlineAt] = useState(null);
+    const resetTimerRef = useRef(null);
+    useEffect(() => {
+        // No-op during SSR — the effect only runs in the browser.
+        if (!isBrowser()) {
+            return;
+        }
+        function handleOnline() {
+            setIsOnline(true);
+            setLastOnlineAt(new Date());
+            setWasOffline(true);
+            // Clear any existing timer before setting a new one.
+            if (resetTimerRef.current !== null) {
+                clearTimeout(resetTimerRef.current);
+            }
+            resetTimerRef.current = setTimeout(() => {
+                setWasOffline(false);
+                resetTimerRef.current = null;
+            }, WAS_OFFLINE_RESET_MS);
+        }
+        function handleOffline() {
+            setIsOnline(false);
+            setWasOffline(false);
+            if (resetTimerRef.current !== null) {
+                clearTimeout(resetTimerRef.current);
+                resetTimerRef.current = null;
+            }
+        }
+        window.addEventListener('online', handleOnline);
+        window.addEventListener('offline', handleOffline);
+        return () => {
+            window.removeEventListener('online', handleOnline);
+            window.removeEventListener('offline', handleOffline);
+            if (resetTimerRef.current !== null) {
+                clearTimeout(resetTimerRef.current);
+            }
+        };
+    }, []);
+    if (!isBrowser()) {
+        return SSR_DEFAULT;
+    }
+    return { isOnline, wasOffline, lastOnlineAt };
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @revealui/sync — Real-time collaboration and sync primitives.
+ *
+ * The collab layer (Yjs-based) is fully functional.
+ * ElectricProvider provides proxyBaseUrl config to child hooks. All hooks route
+ * through the authenticated CMS proxy at /api/shapes/* — no direct Electric client.
+ *
+ * Reads use ElectricSQL shape subscriptions for real-time updates.
+ * Writes use REST mutations via /api/sync/* — changes propagate to all
+ * subscribers automatically through ElectricSQL replication.
+ */
+export type { CollabDocumentState, UseCollaborationOptions, UseCollaborationResult, } from './collab/index.js';
+export { CollabProvider, useCollabDocument, useCollaboration, } from './collab/index.js';
+export type { AgentContextRecord, CreateAgentContextInput, UpdateAgentContextInput, UseAgentContextsResult, } from './hooks/useAgentContexts.js';
+export { useAgentContexts } from './hooks/useAgentContexts.js';
+export type { AgentMemoryRecord, CreateAgentMemoryInput, UpdateAgentMemoryInput, UseAgentMemoryResult, } from './hooks/useAgentMemory.js';
+export { useAgentMemory } from './hooks/useAgentMemory.js';
+export type { ConversationRecord, CreateConversationInput, UpdateConversationInput, UseConversationsResult, } from './hooks/useConversations.js';
+export { useConversations } from './hooks/useConversations.js';
+export type { CoordinationSessionRecord, CreateCoordinationSessionInput, UpdateCoordinationSessionInput, UseCoordinationSessionsResult, } from './hooks/useCoordinationSessions.js';
+export { useCoordinationSessions } from './hooks/useCoordinationSessions.js';
+export type { CoordinationWorkItemRecord, CreateCoordinationWorkItemInput, UpdateCoordinationWorkItemInput, UseCoordinationWorkItemsResult, } from './hooks/useCoordinationWorkItems.js';
+export { useCoordinationWorkItems } from './hooks/useCoordinationWorkItems.js';
+export type { MutationResult } from './mutations.js';
+export { ElectricProvider, useElectricConfig } from './provider/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;;;;;;;;;;GAUG;AAEH,YAAY,EACV,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,YAAY,EACV,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,YAAY,EACV,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,YAAY,EACV,yBAAyB,EACzB,8BAA8B,EAC9B,8BAA8B,EAC9B,6BAA6B,GAC9B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,YAAY,EACV,0BAA0B,EAC1B,+BAA+B,EAC/B,+BAA+B,EAC/B,8BAA8B,GAC/B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAC/E,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+/**
+ * @revealui/sync — Real-time collaboration and sync primitives.
+ *
+ * The collab layer (Yjs-based) is fully functional.
+ * ElectricProvider provides proxyBaseUrl config to child hooks. All hooks route
+ * through the authenticated CMS proxy at /api/shapes/* — no direct Electric client.
+ *
+ * Reads use ElectricSQL shape subscriptions for real-time updates.
+ * Writes use REST mutations via /api/sync/* — changes propagate to all
+ * subscribers automatically through ElectricSQL replication.
+ */
+export { CollabProvider, useCollabDocument, useCollaboration, } from './collab/index.js';
+export { useAgentContexts } from './hooks/useAgentContexts.js';
+export { useAgentMemory } from './hooks/useAgentMemory.js';
+export { useConversations } from './hooks/useConversations.js';
+export { useCoordinationSessions } from './hooks/useCoordinationSessions.js';
+export { useCoordinationWorkItems } from './hooks/useCoordinationWorkItems.js';
+export { ElectricProvider, useElectricConfig } from './provider/index.js';

package/dist/mutations.d.ts

@@ -0,0 +1,14 @@
+export interface MutationResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+/**
+ * Hook that returns mutation functions for a given sync API endpoint.
+ */
+export declare function useSyncMutations<TCreate, TUpdate, TRecord>(endpoint: string): {
+    create: (data: TCreate) => Promise<MutationResult<TRecord>>;
+    update: (id: string, data: TUpdate) => Promise<MutationResult<TRecord>>;
+    remove: (id: string) => Promise<MutationResult<void>>;
+};
+//# sourceMappingURL=mutations.d.ts.map

package/dist/mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../src/mutations.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA0CD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM;mBAK3D,OAAO,KAAG,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;iBAO5C,MAAM,QAAQ,OAAO,KAAG,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;iBAOxD,MAAM,KAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;EAOpD"}

package/dist/mutations.js

@@ -0,0 +1,53 @@
+'use client';
+import { useCallback } from 'react';
+import { useElectricConfig } from './provider/index.js';
+/** Default timeout for mutation fetch requests (milliseconds). */
+const MUTATION_FETCH_TIMEOUT_MS = 10_000;
+/**
+ * Make an authenticated mutation request to the CMS API.
+ * Credentials are included so the session cookie is sent cross-origin.
+ * Requests are aborted after {@link MUTATION_FETCH_TIMEOUT_MS} (10 s).
+ */
+async function mutationFetch(url, method, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), MUTATION_FETCH_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch(url, {
+            method,
+            credentials: 'include',
+            signal: controller.signal,
+            headers: body !== undefined ? { 'Content-Type': 'application/json' } : undefined,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    if (!response.ok) {
+        const errorData = (await response.json().catch(() => null));
+        return {
+            success: false,
+            error: errorData?.error ?? `Request failed with status ${response.status}`,
+        };
+    }
+    const data = (await response.json());
+    return { success: true, data };
+}
+/**
+ * Hook that returns mutation functions for a given sync API endpoint.
+ */
+export function useSyncMutations(endpoint) {
+    const { proxyBaseUrl } = useElectricConfig();
+    const baseUrl = `${proxyBaseUrl}/api/sync/${endpoint}`;
+    const create = useCallback(async (data) => {
+        return mutationFetch(baseUrl, 'POST', data);
+    }, [baseUrl]);
+    const update = useCallback(async (id, data) => {
+        return mutationFetch(`${baseUrl}/${encodeURIComponent(id)}`, 'PATCH', data);
+    }, [baseUrl]);
+    const remove = useCallback(async (id) => {
+        return mutationFetch(`${baseUrl}/${encodeURIComponent(id)}`, 'DELETE');
+    }, [baseUrl]);
+    return { create, update, remove };
+}

package/dist/offline-queue.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Offline mutation queue — stores pending mutations in localStorage
+ * so they survive page reloads and can be flushed when connectivity returns.
+ */
+/** A single pending mutation waiting to be sent to the server. */
+export interface OfflineMutation {
+    /** Unique identifier for this mutation (UUID). */
+    id: string;
+    /** Database table the mutation targets. */
+    table: string;
+    /** Type of operation. */
+    operation: 'insert' | 'update' | 'delete';
+    /** Mutation payload (row data or partial update). */
+    data: Record<string, unknown>;
+    /** ISO-8601 timestamp when the mutation was enqueued. */
+    timestamp: string;
+}
+/**
+ * Manages a FIFO queue of mutations that were created while the browser
+ * was offline. Mutations are persisted in `localStorage` under the key
+ * `revealui:offline-queue`.
+ *
+ * All operations are no-ops when `localStorage` is unavailable (SSR,
+ * private browsing that throws, etc.).
+ */
+export declare class OfflineMutationQueue {
+    /**
+     * Add a mutation to the end of the queue.
+     *
+     * @param mutation - The mutation to enqueue (must include a unique `id`).
+     */
+    enqueue(mutation: OfflineMutation): void;
+    /**
+     * Execute all queued mutations in order via the provided executor.
+     * Each mutation is removed from the persisted queue only after the
+     * executor resolves successfully. Processing stops at the first failure
+     * so ordering is preserved.
+     *
+     * @param executor - Async function that sends a single mutation to the server.
+     */
+    flush(executor: (mutation: OfflineMutation) => Promise<void>): Promise<void>;
+    /**
+     * Return all pending mutations without removing them.
+     */
+    peek(): OfflineMutation[];
+    /**
+     * Number of mutations currently in the queue.
+     */
+    get size(): number;
+    /**
+     * Remove all pending mutations from the queue.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=offline-queue.d.ts.map

package/dist/offline-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-queue.d.ts","sourceRoot":"","sources":["../src/offline-queue.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,kEAAkE;AAClE,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAC;IACX,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,yBAAyB;IACzB,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC1C,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;CACnB;AA0DD;;;;;;;GAOG;AACH,qBAAa,oBAAoB;IAC/B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAMxC;;;;;;;OAOG;IACG,KAAK,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAYlF;;OAEG;IACH,IAAI,IAAI,eAAe,EAAE;IAIzB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,KAAK,IAAI,IAAI;CAUd"}