@drakkar.software/starfish-client 1.4.0 → 1.5.0

package/dist/index.js

@@ -4,10 +4,16 @@ export { StarfishClient } from "./client.js";
 export { SyncManager } from "./sync.js";
 export { createEncryptor, ENCRYPTED_KEY } from "./crypto.js";
 export { ConflictError, StarfishHttpError, } from "./types.js";
-export { consoleSyncLogger, noopSyncLogger } from "./logger.js";
+export { consoleSyncLogger, noopSyncLogger, createMetricsCollector } from "./logger.js";
 export { createMigrator } from "./migrate.js";
 export { ValidationError, createSchemaValidator } from "./validate.js";
 export { classifyError } from "./fetch.js";
-export { createUnionMerge, createSoftDeleteResolver, timestampWinner, pruneTombstones, } from "./resolvers.js";
+export { createUnionMerge, createSoftDeleteResolver, timestampWinner, pruneTombstones, withConflictMeta, } from "./resolvers.js";
 export { SnapshotHistory } from "./history.js";
 export { startPolling, startAdaptivePolling } from "./polling.js";
+export { createDedupFetch } from "./dedup.js";
+export { createIndexedDBStorage } from "./storage/indexeddb.js";
+export { exportData, importData, exportToBlob } from "./export.js";
+export { isBackgroundSyncSupported, registerBackgroundSync } from "./background-sync.js";
+export { isServiceWorkerSupported, registerServiceWorker, unregisterServiceWorkers } from "./service-worker.js";
+export { createSuspenseResource } from "./bindings/suspense.js";

package/dist/logger.d.ts

@@ -1,10 +1,18 @@
+/** Extended metrics for sync operations. */
+export interface SyncMetrics {
+    bytesTransferred?: number;
+    compressedSize?: number;
+    conflictCount?: number;
+    retryCount?: number;
+    cacheHit?: boolean;
+}
 /** Structured logger for sync operations. */
 export interface SyncLogger {
     pullStart(store: string): void;
-    pullSuccess(store: string, durationMs: number): void;
+    pullSuccess(store: string, durationMs: number, metrics?: SyncMetrics): void;
     pullError(store: string, error: string): void;
     pushStart(store: string): void;
-    pushSuccess(store: string, durationMs: number): void;
+    pushSuccess(store: string, durationMs: number, metrics?: SyncMetrics): void;
     pushError(store: string, error: string): void;
     conflict(store: string, attempt: number): void;
 }
@@ -12,3 +20,19 @@ export interface SyncLogger {
 export declare const consoleSyncLogger: SyncLogger;
 /** Silent sync logger (no output). */
 export declare const noopSyncLogger: SyncLogger;
+/** Collects sync metrics over time. */
+export interface MetricsCollector {
+    recordPull(name: string, durationMs: number, metrics?: SyncMetrics): void;
+    recordPush(name: string, durationMs: number, metrics?: SyncMetrics): void;
+    recordConflict(name: string): void;
+    getSummary(): Record<string, {
+        totalPulls: number;
+        totalPushes: number;
+        avgDurationMs: number;
+        totalBytes: number;
+        totalConflicts: number;
+    }>;
+    reset(): void;
+}
+/** Create a metrics collector that accumulates sync statistics. */
+export declare function createMetricsCollector(): MetricsCollector;

package/dist/logger.js

@@ -1,10 +1,22 @@
 /** Console-based sync logger with structured output. */
 export const consoleSyncLogger = {
     pullStart: (s) => console.log(`[starfish:${s}] pull started`),
-    pullSuccess: (s, ms) => console.log(`[starfish:${s}] pull OK (${ms}ms)`),
+    pullSuccess: (s, ms, m) => {
+        let msg = `[starfish:${s}] pull OK (${ms}ms)`;
+        if (m?.bytesTransferred)
+            msg += ` ${m.bytesTransferred}B`;
+        if (m?.cacheHit)
+            msg += ` (cache hit)`;
+        console.log(msg);
+    },
     pullError: (s, err) => console.error(`[starfish:${s}] pull failed: ${err}`),
     pushStart: (s) => console.log(`[starfish:${s}] push started`),
-    pushSuccess: (s, ms) => console.log(`[starfish:${s}] push OK (${ms}ms)`),
+    pushSuccess: (s, ms, m) => {
+        let msg = `[starfish:${s}] push OK (${ms}ms)`;
+        if (m?.bytesTransferred)
+            msg += ` ${m.bytesTransferred}B`;
+        console.log(msg);
+    },
     pushError: (s, err) => console.error(`[starfish:${s}] push failed: ${err}`),
     conflict: (s, n) => console.warn(`[starfish:${s}] conflict (attempt ${n})`),
 };
@@ -18,3 +30,51 @@ export const noopSyncLogger = {
     pushError: () => { },
     conflict: () => { },
 };
+/** Create a metrics collector that accumulates sync statistics. */
+export function createMetricsCollector() {
+    const stores = new Map();
+    function ensureStore(name) {
+        let s = stores.get(name);
+        if (!s) {
+            s = { totalPulls: 0, totalPushes: 0, totalDurationMs: 0, totalBytes: 0, totalConflicts: 0 };
+            stores.set(name, s);
+        }
+        return s;
+    }
+    return {
+        recordPull(name, durationMs, metrics) {
+            const s = ensureStore(name);
+            s.totalPulls++;
+            s.totalDurationMs += durationMs;
+            if (metrics?.bytesTransferred)
+                s.totalBytes += metrics.bytesTransferred;
+        },
+        recordPush(name, durationMs, metrics) {
+            const s = ensureStore(name);
+            s.totalPushes++;
+            s.totalDurationMs += durationMs;
+            if (metrics?.bytesTransferred)
+                s.totalBytes += metrics.bytesTransferred;
+        },
+        recordConflict(name) {
+            ensureStore(name).totalConflicts++;
+        },
+        getSummary() {
+            const result = {};
+            for (const [name, s] of stores) {
+                const totalOps = s.totalPulls + s.totalPushes;
+                result[name] = {
+                    totalPulls: s.totalPulls,
+                    totalPushes: s.totalPushes,
+                    avgDurationMs: totalOps > 0 ? Math.round(s.totalDurationMs / totalOps) : 0,
+                    totalBytes: s.totalBytes,
+                    totalConflicts: s.totalConflicts,
+                };
+            }
+            return result;
+        },
+        reset() {
+            stores.clear();
+        },
+    };
+}

package/dist/migrate.js

@@ -25,7 +25,12 @@ export function createMigrator(config) {
             if (!fn) {
                 throw new Error(`Missing migration for version ${v} -> ${v + 1}`);
             }
-            result = fn(result);
+            try {
+                result = fn(result);
+            }
+            catch (err) {
+                throw new Error(`Migration from version ${v} to ${v + 1} failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+            }
         }
         result._schemaVersion = config.currentVersion;
         return result;

package/dist/platform.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Platform abstraction for crypto and base64 operations.
+ *
+ * Browser and Node.js >= 15 work with zero configuration (globalThis.crypto).
+ * React Native users must call configurePlatform() before using the SDK.
+ */
+/** Minimal crypto interface required by the SDK (subset of Web Crypto API). */
+export interface CryptoProvider {
+    subtle: {
+        digest(algorithm: string, data: BufferSource): Promise<ArrayBuffer>;
+        importKey(format: "raw", keyData: BufferSource, algorithm: string | Algorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+        deriveKey(algorithm: HkdfParams, baseKey: CryptoKey, derivedKeyType: AesKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+        encrypt(algorithm: AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
+        decrypt(algorithm: AesGcmParams, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
+    };
+    getRandomValues<T extends ArrayBufferView>(array: T): T;
+}
+/** Base64 encode/decode for Uint8Array <-> string. */
+export interface Base64Provider {
+    encode(data: Uint8Array): string;
+    decode(encoded: string): Uint8Array;
+}
+export interface PlatformConfig {
+    crypto?: CryptoProvider;
+    base64?: Base64Provider;
+}
+/**
+ * Configure platform-specific providers for environments
+ * that lack the Web Crypto API (e.g., React Native).
+ *
+ * Call once at app startup, before using any SDK functions.
+ * Not needed for browser or Node.js >= 15.
+ *
+ * @example
+ * ```ts
+ * import { configurePlatform } from "@satellite/client"
+ * import QuickCrypto from "react-native-quick-crypto"
+ *
+ * configurePlatform({
+ *   crypto: QuickCrypto,
+ *   base64: {
+ *     encode: (data) => Buffer.from(data).toString("base64"),
+ *     decode: (str) => new Uint8Array(Buffer.from(str, "base64")),
+ *   },
+ * })
+ * ```
+ */
+export declare function configurePlatform(config: PlatformConfig): void;
+/** Resolve the active crypto provider. */
+export declare function getCrypto(): CryptoProvider;
+/** Resolve the active base64 provider. */
+export declare function getBase64(): Base64Provider;

package/dist/platform.js

@@ -0,0 +1,62 @@
+/**
+ * Platform abstraction for crypto and base64 operations.
+ *
+ * Browser and Node.js >= 15 work with zero configuration (globalThis.crypto).
+ * React Native users must call configurePlatform() before using the SDK.
+ */
+let _crypto;
+let _base64;
+/**
+ * Configure platform-specific providers for environments
+ * that lack the Web Crypto API (e.g., React Native).
+ *
+ * Call once at app startup, before using any SDK functions.
+ * Not needed for browser or Node.js >= 15.
+ *
+ * @example
+ * ```ts
+ * import { configurePlatform } from "@satellite/client"
+ * import QuickCrypto from "react-native-quick-crypto"
+ *
+ * configurePlatform({
+ *   crypto: QuickCrypto,
+ *   base64: {
+ *     encode: (data) => Buffer.from(data).toString("base64"),
+ *     decode: (str) => new Uint8Array(Buffer.from(str, "base64")),
+ *   },
+ * })
+ * ```
+ */
+export function configurePlatform(config) {
+    if (config.crypto)
+        _crypto = config.crypto;
+    if (config.base64)
+        _base64 = config.base64;
+}
+/** Resolve the active crypto provider. */
+export function getCrypto() {
+    if (_crypto)
+        return _crypto;
+    if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle) {
+        return globalThis.crypto;
+    }
+    throw new Error("@satellite/client: No crypto provider available. " +
+        "In React Native, call configurePlatform({ crypto: ... }) before using the SDK.");
+}
+/** Resolve the active base64 provider. */
+export function getBase64() {
+    if (_base64)
+        return _base64;
+    if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+        return {
+            encode(data) {
+                return btoa(String.fromCharCode(...data));
+            },
+            decode(encoded) {
+                return Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
+            },
+        };
+    }
+    throw new Error("@satellite/client: No base64 provider available. " +
+        "In React Native, call configurePlatform({ base64: ... }) before using the SDK.");
+}

package/dist/polling.js

@@ -14,7 +14,7 @@ export function startPolling(pullFn, getState, intervalMs = 30_000) {
     const timer = setInterval(() => {
         const { online, syncing } = getState();
         if (online && !syncing)
-            pullFn();
+            pullFn().catch(() => { });
     }, intervalMs);
     return () => clearInterval(timer);
 }
@@ -42,7 +42,7 @@ export function startAdaptivePolling(pullFn, getState, options) {
             return;
         const { online, syncing } = getState();
         if (online && !syncing)
-            pullFn();
+            pullFn().catch(() => { });
     }, intervalMs);
     return {
         pause: () => { paused = true; },

package/dist/resolvers.d.ts

@@ -1,4 +1,23 @@
 import type { ConflictResolver } from "./types.js";
+/** Metadata about which fields were affected during conflict resolution. */
+export interface ConflictMeta {
+    /** Field names that differed between local and remote. */
+    conflictedFields: string[];
+    /** How the conflict was resolved. */
+    resolvedBy: "local" | "remote" | "merged";
+    /** Timestamp of resolution. */
+    timestamp: number;
+}
+/** Conflict resolver that also returns metadata about the resolution. */
+export type ConflictResolverWithMeta = (local: Record<string, unknown>, remote: Record<string, unknown>) => {
+    data: Record<string, unknown>;
+    meta: ConflictMeta;
+};
+/**
+ * Wrap a standard ConflictResolver to also return metadata about which fields conflicted.
+ * Compares local and remote keys to detect differing fields.
+ */
+export declare function withConflictMeta(resolver: ConflictResolver): ConflictResolverWithMeta;
 /**
  * Creates a conflict resolver that merges arrays by ID with per-item
  * timestamp comparison, and uses document-level timestamp for scalars.

package/dist/resolvers.js

@@ -1,3 +1,60 @@
+/** Shallow structural comparison of two values. Handles objects, arrays, and primitives. */
+function shallowEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return a === b;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a !== "object")
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((v, i) => shallowEqual(v, b[i]));
+    }
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    return aKeys.every((k) => shallowEqual(aObj[k], bObj[k]));
+}
+/**
+ * Wrap a standard ConflictResolver to also return metadata about which fields conflicted.
+ * Compares local and remote keys to detect differing fields.
+ */
+export function withConflictMeta(resolver) {
+    return (local, remote) => {
+        const conflictedFields = [];
+        const allKeys = new Set([...Object.keys(local), ...Object.keys(remote)]);
+        for (const key of allKeys) {
+            const lv = local[key];
+            const rv = remote[key];
+            if (!shallowEqual(lv, rv)) {
+                conflictedFields.push(key);
+            }
+        }
+        const data = resolver(local, remote);
+        // Determine how it was resolved using structural comparison
+        let resolvedBy = "merged";
+        if (shallowEqual(data, local))
+            resolvedBy = "local";
+        else if (shallowEqual(data, remote))
+            resolvedBy = "remote";
+        return {
+            data,
+            meta: {
+                conflictedFields,
+                resolvedBy,
+                timestamp: Date.now(),
+            },
+        };
+    };
+}
 /** Compare two timestamp values. Handles both numeric (epoch) and string (ISO-8601) timestamps. */
 function compareTimestamps(a, b) {
     if (typeof a === "number" && typeof b === "number")
@@ -99,9 +156,9 @@ export function createSoftDeleteResolver(options) {
                         const rec = item;
                         const id = rec[idKey];
                         const deletedAt = rec[deletedAtKey];
-                        if (typeof deletedAt === "number") {
-                            const existing = tombstones.get(id) ?? 0;
-                            if (deletedAt > existing)
+                        if (typeof deletedAt === "number" || typeof deletedAt === "string") {
+                            const existing = tombstones.get(id);
+                            if (existing == null || compareTimestamps(deletedAt, existing))
                                 tombstones.set(id, deletedAt);
                         }
                     }
@@ -157,6 +214,10 @@ export function pruneTombstones(items, ttlMs = 30 * 24 * 60 * 60 * 1000, deleted
         const deletedAt = item[deletedAtKey];
         if (deletedAt == null)
             return true;
-        return typeof deletedAt === "number" && deletedAt > cutoff;
+        if (typeof deletedAt === "number")
+            return deletedAt > cutoff;
+        if (typeof deletedAt === "string")
+            return new Date(deletedAt).getTime() > cutoff;
+        return false;
     });
 }

package/dist/service-worker.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Service Worker utilities for offline support and PWA functionality.
+ */
+export interface ServiceWorkerOptions {
+    /** Scope for the service worker registration. */
+    scope?: string;
+    /** Called when an updated service worker is available. */
+    onUpdate?: (registration: ServiceWorkerRegistration) => void;
+}
+/** Check if service workers are supported in the current environment. */
+export declare function isServiceWorkerSupported(): boolean;
+/**
+ * Register a service worker for offline support.
+ * Returns the registration, or null if not supported.
+ */
+export declare function registerServiceWorker(scriptUrl: string, opts?: ServiceWorkerOptions): Promise<ServiceWorkerRegistration | null>;
+/** Unregister all service worker registrations. Returns true if any were unregistered. */
+export declare function unregisterServiceWorkers(): Promise<boolean>;

package/dist/service-worker.js

@@ -0,0 +1,55 @@
+/**
+ * Service Worker utilities for offline support and PWA functionality.
+ */
+/** Check if service workers are supported in the current environment. */
+export function isServiceWorkerSupported() {
+    return typeof navigator !== "undefined" && "serviceWorker" in navigator;
+}
+/**
+ * Register a service worker for offline support.
+ * Returns the registration, or null if not supported.
+ */
+export async function registerServiceWorker(scriptUrl, opts) {
+    if (!isServiceWorkerSupported())
+        return null;
+    try {
+        const registration = await navigator.serviceWorker.register(scriptUrl, {
+            scope: opts?.scope,
+        });
+        if (opts?.onUpdate) {
+            registration.onupdatefound = () => {
+                const installingWorker = registration.installing;
+                if (installingWorker) {
+                    installingWorker.onstatechange = () => {
+                        if (installingWorker.state === "installed" &&
+                            navigator.serviceWorker.controller) {
+                            opts.onUpdate(registration);
+                        }
+                    };
+                }
+            };
+        }
+        return registration;
+    }
+    catch {
+        return null;
+    }
+}
+/** Unregister all service worker registrations. Returns true if any were unregistered. */
+export async function unregisterServiceWorkers() {
+    if (!isServiceWorkerSupported())
+        return false;
+    try {
+        const registrations = await navigator.serviceWorker.getRegistrations();
+        let unregistered = false;
+        for (const registration of registrations) {
+            const result = await registration.unregister();
+            if (result)
+                unregistered = true;
+        }
+        return unregistered;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/storage/indexeddb.d.ts

@@ -0,0 +1,17 @@
+/**
+ * IndexedDB-based storage adapter for Zustand persistence.
+ * Implements the same interface as Zustand's StateStorage (getItem/setItem/removeItem).
+ * Supports larger data than localStorage (typically 50MB+).
+ */
+export interface IndexedDBStorageOptions {
+    /** Database name. Default: "starfish" */
+    dbName?: string;
+    /** Object store name. Default: "state" */
+    storeName?: string;
+}
+export interface AsyncStateStorage {
+    getItem: (name: string) => Promise<string | null>;
+    setItem: (name: string, value: string) => Promise<void>;
+    removeItem: (name: string) => Promise<void>;
+}
+export declare function createIndexedDBStorage(opts?: IndexedDBStorageOptions): AsyncStateStorage;

package/dist/storage/indexeddb.js

@@ -0,0 +1,59 @@
+/**
+ * IndexedDB-based storage adapter for Zustand persistence.
+ * Implements the same interface as Zustand's StateStorage (getItem/setItem/removeItem).
+ * Supports larger data than localStorage (typically 50MB+).
+ */
+function openDB(dbName, storeName) {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(dbName, 1);
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(storeName)) {
+                db.createObjectStore(storeName);
+            }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+function idbRequest(request) {
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+export function createIndexedDBStorage(opts) {
+    const dbName = opts?.dbName ?? "starfish";
+    const storeName = opts?.storeName ?? "state";
+    let dbPromise = null;
+    function getDB() {
+        if (!dbPromise) {
+            dbPromise = openDB(dbName, storeName).catch((err) => {
+                dbPromise = null; // Reset so next call retries
+                throw err;
+            });
+        }
+        return dbPromise;
+    }
+    return {
+        async getItem(name) {
+            const db = await getDB();
+            const tx = db.transaction(storeName, "readonly");
+            const store = tx.objectStore(storeName);
+            const result = await idbRequest(store.get(name));
+            return result ?? null;
+        },
+        async setItem(name, value) {
+            const db = await getDB();
+            const tx = db.transaction(storeName, "readwrite");
+            const store = tx.objectStore(storeName);
+            await idbRequest(store.put(value, name));
+        },
+        async removeItem(name) {
+            const db = await getDB();
+            const tx = db.transaction(storeName, "readwrite");
+            const store = tx.objectStore(storeName);
+            await idbRequest(store.delete(name));
+        },
+    };
+}

package/dist/sync.js

@@ -52,6 +52,7 @@ export class SyncManager {
             }
             else if (this.lastCheckpoint > 0) {
                 this.localData = deepMerge(this.localData, result.data);
+                result.data = this.localData;
             }
             else {
                 this.localData = result.data;
@@ -62,7 +63,7 @@ export class SyncManager {
             return result;
         }
         catch (err) {
-            this.logger?.pullError(this.loggerName, err.message);
+            this.logger?.pullError(this.loggerName, err instanceof Error ? err.message : String(err));
             throw err;
         }
     }
@@ -93,17 +94,24 @@ export class SyncManager {
             }
             catch (err) {
                 if (!(err instanceof ConflictError) || attempt >= this.maxRetries) {
-                    this.logger?.pushError(this.loggerName, err.message);
+                    this.logger?.pushError(this.loggerName, err instanceof Error ? err.message : String(err));
                     throw err;
                 }
                 this.logger?.conflict(this.loggerName, attempt + 1);
-                const remote = await this.client.pull(this.pullPath);
-                this.lastHash = remote.hash;
-                this.lastCheckpoint = remote.timestamp;
-                const remoteData = this.encryptor
-                    ? await this.encryptor.decrypt(remote.data)
-                    : remote.data;
-                pendingData = this.onConflict(pendingData, remoteData);
+                try {
+                    const remote = await this.client.pull(this.pullPath);
+                    const remoteData = this.encryptor
+                        ? await this.encryptor.decrypt(remote.data)
+                        : remote.data;
+                    this.lastHash = remote.hash;
+                    this.lastCheckpoint = remote.timestamp;
+                    pendingData = this.onConflict(pendingData, remoteData);
+                }
+                catch (resolveErr) {
+                    const msg = resolveErr instanceof Error ? resolveErr.message : String(resolveErr);
+                    this.logger?.pushError(this.loggerName, `Conflict resolution failed (attempt ${attempt + 1}): ${msg}`);
+                    throw resolveErr;
+                }
                 await new Promise(resolve => setTimeout(resolve, Math.min(100 * Math.pow(2, attempt), 2000) + Math.random() * 100));
                 attempt++;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakkar.software/starfish-client",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/Drakkar-Software/starfish.git",
@@ -60,7 +60,7 @@
     }
   },
   "dependencies": {
-    "@drakkar.software/starfish-protocol": "1.4.0"
+    "@drakkar.software/starfish-protocol": "1.5.0"
   },
   "devDependencies": {
     "@legendapp/state": "^2.0.0",

package/dist/bindings/broadcast.d.ts

@@ -1,19 +0,0 @@
-import type { StoreApi } from "zustand/vanilla";
-import type { StarfishStore } from "./zustand.js";
-/**
- * Syncs a Zustand Starfish store across browser tabs using BroadcastChannel.
- * Returns a cleanup function that closes the channel.
- */
-export declare function setupBroadcastSync(store: StoreApi<StarfishStore>, name: string): () => void;
-/**
- * Syncs a Zustand Starfish store across browser tabs using storage events.
- * Fallback for environments without BroadcastChannel.
- * Returns a cleanup function.
- */
-export declare function setupStorageFallback(store: StoreApi<StarfishStore>, name: string): () => void;
-/**
- * Auto-detects the best cross-tab sync mechanism and sets it up.
- * Uses BroadcastChannel when available, falls back to storage events.
- * Returns a cleanup function.
- */
-export declare function setupCrossTabSync(store: StoreApi<StarfishStore>, name: string): () => void;