@drakkar.software/starfish-client 1.6.0 → 1.11.0

package/dist/bindings/broadcast.d.ts

@@ -0,0 +1,19 @@
+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;

package/dist/bindings/broadcast.js

@@ -0,0 +1,65 @@
+/**
+ * Syncs a Zustand Starfish store across browser tabs using BroadcastChannel.
+ * Returns a cleanup function that closes the channel.
+ */
+export function setupBroadcastSync(store, name) {
+    const channel = new BroadcastChannel(`starfish-${name}`);
+    let lastReceivedData = null;
+    channel.onmessage = (event) => {
+        lastReceivedData = event.data.data;
+        store.setState({ data: event.data.data, dirty: event.data.dirty });
+    };
+    const unsub = store.subscribe((state, prev) => {
+        if (state.data === lastReceivedData)
+            return;
+        if (state.data !== prev.data || state.dirty !== prev.dirty) {
+            channel.postMessage({ data: state.data, dirty: state.dirty });
+        }
+    });
+    return () => {
+        unsub();
+        channel.close();
+    };
+}
+/**
+ * Syncs a Zustand Starfish store across browser tabs using storage events.
+ * Fallback for environments without BroadcastChannel.
+ * Returns a cleanup function.
+ */
+export function setupStorageFallback(store, name) {
+    const storageKey = `starfish-broadcast-${name}`;
+    let lastReceivedData = null;
+    const onStorage = (e) => {
+        if (e.key !== storageKey || !e.newValue)
+            return;
+        const payload = JSON.parse(e.newValue);
+        lastReceivedData = payload.data;
+        store.setState({ data: payload.data, dirty: payload.dirty });
+    };
+    globalThis.addEventListener("storage", onStorage);
+    const unsub = store.subscribe((state, prev) => {
+        if (state.data === lastReceivedData)
+            return;
+        if (state.data !== prev.data || state.dirty !== prev.dirty) {
+            localStorage.setItem(storageKey, JSON.stringify({ data: state.data, dirty: state.dirty }));
+        }
+    });
+    return () => {
+        unsub();
+        globalThis.removeEventListener("storage", onStorage);
+    };
+}
+/**
+ * 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 function setupCrossTabSync(store, name) {
+    if (typeof BroadcastChannel !== "undefined") {
+        return setupBroadcastSync(store, name);
+    }
+    if (typeof globalThis.addEventListener === "function" && typeof localStorage !== "undefined") {
+        return setupStorageFallback(store, name);
+    }
+    return () => { };
+}

package/dist/bindings/react.d.ts

@@ -0,0 +1,12 @@
+import type { StoreApi } from "zustand/vanilla";
+import type { StarfishStore, StarfishState } from "./zustand.js";
+/** Derived sync status for UI display. */
+export type SyncStatus = "synced" | "syncing" | "pending" | "error" | "offline";
+/** Derive a single sync status from store state. */
+export declare function deriveSyncStatus(state: StarfishState): SyncStatus;
+/** Use the full Starfish store state and actions. */
+export declare function useStarfish(store: StoreApi<StarfishStore>): StarfishStore;
+/** Use only the synced data, with an optional selector for fine-grained subscriptions. */
+export declare function useStarfishData<T = Record<string, unknown>>(store: StoreApi<StarfishStore>, selector?: (data: Record<string, unknown>) => T): T;
+/** Use the derived sync status (synced | syncing | pending | error | offline). */
+export declare function useSyncStatus(store: StoreApi<StarfishStore>): SyncStatus;

package/dist/bindings/react.js

@@ -0,0 +1,25 @@
+import { useStore } from "zustand";
+/** Derive a single sync status from store state. */
+export function deriveSyncStatus(state) {
+    if (!state.online)
+        return "offline";
+    if (state.error)
+        return "error";
+    if (state.syncing)
+        return "syncing";
+    if (state.dirty)
+        return "pending";
+    return "synced";
+}
+/** Use the full Starfish store state and actions. */
+export function useStarfish(store) {
+    return useStore(store);
+}
+/** Use only the synced data, with an optional selector for fine-grained subscriptions. */
+export function useStarfishData(store, selector) {
+    return useStore(store, (state) => selector ? selector(state.data) : state.data);
+}
+/** Use the derived sync status (synced | syncing | pending | error | offline). */
+export function useSyncStatus(store) {
+    return useStore(store, deriveSyncStatus);
+}

package/dist/debounced-sync.d.ts

@@ -1,5 +1,6 @@
 import type { StoreApi } from "zustand/vanilla";
 import type { StarfishStore } from "./bindings/zustand.js";
+import type { SyncManager } from "./sync.js";
 export interface DebouncedSyncOptions {
     /**
      * How long to wait after the last `notify()` call before pushing (default: 2000 ms).
@@ -44,6 +45,48 @@ export interface DebouncedSync {
     /** Cancel any pending debounced push. Does not affect an already-in-flight push. */
     cancel: () => void;
 }
+export interface DebouncedPushOptions {
+    /**
+     * How long to wait after the last `notify()` call before pushing (default: 2000 ms).
+     */
+    delayMs?: number;
+    /**
+     * Required: provides the document to push when the debounce timer fires.
+     * Called inside the timer so it always captures the latest state.
+     */
+    serialize: () => Record<string, unknown>;
+    /**
+     * Emit a warning when the estimated encrypted payload exceeds this byte count (default: 900 KB).
+     * Set to `Infinity` to disable.
+     */
+    warnBytes?: number;
+    /**
+     * Block the push when the estimated encrypted payload exceeds this byte count (default: 1 MB).
+     * Set to `Infinity` to disable.
+     */
+    maxBytes?: number;
+    /**
+     * Called when the estimated payload size exceeds `warnBytes` but is below `maxBytes`.
+     */
+    onSizeWarning?: (estimatedBytes: number) => void;
+    /**
+     * Called when the estimated payload size exceeds `maxBytes`. The push is blocked.
+     * If omitted, a console error is printed.
+     */
+    onSizeExceeded?: (estimatedBytes: number) => void;
+    /**
+     * Called when `syncManager.push()` throws. Default: `console.warn`.
+     */
+    onError?: (err: unknown) => void;
+}
+export interface DebouncedPush {
+    /**
+     * Schedule a push. If called again within `delayMs`, the timer resets.
+     */
+    notify: () => void;
+    /** Cancel any pending debounced push. Does not affect an already-in-flight push. */
+    cancel: () => void;
+}
 /**
  * Creates a debounced push helper that coalesces rapid mutations into a single sync.
  *
@@ -64,3 +107,25 @@ export interface DebouncedSync {
  * ```
  */
 export declare function createDebouncedSync(store: StoreApi<StarfishStore>, options?: DebouncedSyncOptions): DebouncedSync;
+/**
+ * Creates a debounced push helper that calls `syncManager.push()` directly,
+ * without requiring a Zustand store.
+ *
+ * Use this for one-way publishing workflows: public pages, derived snapshots,
+ * or any case where you want to push data without a full `createStarfishStore` setup.
+ *
+ * ```ts
+ * const syncManager = new SyncManager({ client, pullPath, pushPath })
+ *
+ * const { notify, cancel } = createDebouncedPush(syncManager, {
+ *   serialize: () => buildPublicPageDocument(),
+ * })
+ *
+ * // Push after every relevant store mutation:
+ * planningStore.subscribe(() => notify())
+ *
+ * // Clean up on teardown:
+ * cancel()
+ * ```
+ */
+export declare function createDebouncedPush(syncManager: SyncManager, options: DebouncedPushOptions): DebouncedPush;

package/dist/debounced-sync.js

@@ -2,6 +2,32 @@
 const DEFAULT_DELAY_MS = 2000;
 const DEFAULT_WARN_BYTES = 900 * 1024; // 900 KB
 const DEFAULT_MAX_BYTES = 1024 * 1024; // 1 MB
+/** Returns true if the push should be blocked. */
+function checkPayloadSize(doc, opts) {
+    // Estimate encrypted payload size. AES-GCM output is similar to input size;
+    // base64 encoding adds ~33% overhead, plus a small IV/tag overhead.
+    const estimatedBytes = Math.ceil(JSON.stringify(doc).length * 1.34);
+    if (estimatedBytes > opts.maxBytes) {
+        if (opts.onSizeExceeded) {
+            opts.onSizeExceeded(estimatedBytes);
+        }
+        else {
+            console.error(`[starfish] Push blocked: estimated payload ${(estimatedBytes / 1024).toFixed(0)} KB ` +
+                `exceeds limit of ${(opts.maxBytes / 1024).toFixed(0)} KB. Prune your data before syncing.`);
+        }
+        return true;
+    }
+    if (estimatedBytes > opts.warnBytes) {
+        if (opts.onSizeWarning) {
+            opts.onSizeWarning(estimatedBytes);
+        }
+        else {
+            console.warn(`[starfish] Payload approaching limit: estimated ${(estimatedBytes / 1024).toFixed(0)} KB ` +
+                `(warn threshold: ${(opts.warnBytes / 1024).toFixed(0)} KB).`);
+        }
+    }
+    return false;
+}
 /**
  * Creates a debounced push helper that coalesces rapid mutations into a single sync.
  *
@@ -36,29 +62,58 @@ export function createDebouncedSync(store, options = {}) {
             timer = null;
             const current = store.getState().data;
             const doc = serialize ? serialize(current) : current;
-            // Estimate encrypted payload size. AES-GCM output is similar to input size;
-            // base64 encoding adds ~33% overhead, plus a small IV/tag overhead.
-            const estimatedBytes = Math.ceil(JSON.stringify(doc).length * 1.34);
-            if (estimatedBytes > maxBytes) {
-                if (onSizeExceeded) {
-                    onSizeExceeded(estimatedBytes);
-                }
-                else {
-                    console.error(`[starfish] Push blocked: estimated payload ${(estimatedBytes / 1024).toFixed(0)} KB ` +
-                        `exceeds limit of ${(maxBytes / 1024).toFixed(0)} KB. Prune your data before syncing.`);
-                }
+            if (checkPayloadSize(doc, { warnBytes, maxBytes, onSizeWarning, onSizeExceeded }))
+                return;
+            store.getState().set(() => doc);
+        }, delayMs);
+    }
+    return { notify, cancel };
+}
+/**
+ * Creates a debounced push helper that calls `syncManager.push()` directly,
+ * without requiring a Zustand store.
+ *
+ * Use this for one-way publishing workflows: public pages, derived snapshots,
+ * or any case where you want to push data without a full `createStarfishStore` setup.
+ *
+ * ```ts
+ * const syncManager = new SyncManager({ client, pullPath, pushPath })
+ *
+ * const { notify, cancel } = createDebouncedPush(syncManager, {
+ *   serialize: () => buildPublicPageDocument(),
+ * })
+ *
+ * // Push after every relevant store mutation:
+ * planningStore.subscribe(() => notify())
+ *
+ * // Clean up on teardown:
+ * cancel()
+ * ```
+ */
+export function createDebouncedPush(syncManager, options) {
+    const { delayMs = DEFAULT_DELAY_MS, warnBytes = DEFAULT_WARN_BYTES, maxBytes = DEFAULT_MAX_BYTES, serialize, onSizeWarning, onSizeExceeded, onError, } = options;
+    let timer = null;
+    function cancel() {
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+    }
+    function notify() {
+        cancel();
+        timer = setTimeout(() => {
+            timer = null;
+            const doc = serialize();
+            if (checkPayloadSize(doc, { warnBytes, maxBytes, onSizeWarning, onSizeExceeded }))
                 return;
-            }
-            if (estimatedBytes > warnBytes) {
-                if (onSizeWarning) {
-                    onSizeWarning(estimatedBytes);
+            syncManager.push(doc).catch((err) => {
+                if (onError) {
+                    onError(err);
                 }
                 else {
-                    console.warn(`[starfish] Payload approaching limit: estimated ${(estimatedBytes / 1024).toFixed(0)} KB ` +
-                        `(warn threshold: ${(warnBytes / 1024).toFixed(0)} KB).`);
+                    console.warn("[starfish] Push failed:", err);
                 }
-            }
-            store.getState().set(() => doc);
+            });
         }, delayMs);
     }
     return { notify, cancel };

package/dist/index.d.ts

@@ -34,7 +34,9 @@ export type { BackgroundSyncOptions } from "./background-sync.js";
 export { isServiceWorkerSupported, registerServiceWorker, unregisterServiceWorkers } from "./service-worker.js";
 export type { ServiceWorkerOptions } from "./service-worker.js";
 export { createSuspenseResource } from "./bindings/suspense.js";
-export { createDebouncedSync } from "./debounced-sync.js";
-export type { DebouncedSyncOptions, DebouncedSync } from "./debounced-sync.js";
+export { createDebouncedSync, createDebouncedPush } from "./debounced-sync.js";
+export type { DebouncedSyncOptions, DebouncedSync, DebouncedPushOptions, DebouncedPush } from "./debounced-sync.js";
+export { createMobileLifecycle } from "./mobile-lifecycle.js";
+export type { AppStateModule, NetInfoModule, MobileLifecycleDeps, MobileLifecycleOptions } from "./mobile-lifecycle.js";
 export { createMultiStoreSync } from "./multi-store.js";
 export type { StoreSlice, BackupDocument, MultiStoreMigrationFn, MultiStoreSyncOptions, MultiStoreSync, } from "./multi-store.js";

package/dist/index.js

@@ -17,5 +17,6 @@ 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";
-export { createDebouncedSync } from "./debounced-sync.js";
+export { createDebouncedSync, createDebouncedPush } from "./debounced-sync.js";
+export { createMobileLifecycle } from "./mobile-lifecycle.js";
 export { createMultiStoreSync } from "./multi-store.js";

package/dist/mobile-lifecycle.d.ts

@@ -0,0 +1,71 @@
+import type { StoreApi } from "zustand/vanilla";
+import type { StarfishStore } from "./bindings/zustand.js";
+/**
+ * Minimal interface matching React Native's `AppState` module.
+ * Pass `AppState` from `react-native` directly.
+ */
+export interface AppStateModule {
+    addEventListener: (type: "change", listener: (state: string) => void) => {
+        remove: () => void;
+    };
+}
+/**
+ * Minimal interface matching `@react-native-community/netinfo`'s default export.
+ * Pass `NetInfo` from `@react-native-community/netinfo` directly.
+ */
+export interface NetInfoModule {
+    addEventListener: (listener: (state: {
+        isConnected: boolean | null;
+    }) => void) => () => void;
+}
+export interface MobileLifecycleDeps {
+    /** React Native `AppState` module. */
+    appState: AppStateModule;
+    /**
+     * Optional: NetInfo module from `@react-native-community/netinfo`.
+     * When provided, connectivity changes are forwarded to `store.getState().setOnline()`.
+     */
+    netInfo?: NetInfoModule;
+}
+export interface MobileLifecycleOptions {
+    /**
+     * Pull remote changes when the app returns to the foreground.
+     * Only pulls if the store is online and not already syncing.
+     * Default: `true`.
+     */
+    pullOnForeground?: boolean;
+    /**
+     * Flush dirty data when the app transitions to the background.
+     * Only flushes if the store has unsaved changes.
+     * Default: `true`.
+     */
+    flushOnBackground?: boolean;
+}
+/**
+ * Wires React Native app lifecycle events to a Starfish store.
+ *
+ * - **Background**: flushes pending changes before the OS suspends the app.
+ * - **Foreground**: pulls remote changes when the user returns to the app.
+ * - **NetInfo**: forwards connectivity changes to `store.getState().setOnline()`.
+ *
+ * Uses dependency injection so no `react-native` or `netinfo` imports are needed
+ * in this package. Pass the modules directly:
+ *
+ * ```ts
+ * import { AppState } from "react-native"
+ * import NetInfo from "@react-native-community/netinfo"
+ * import { createMobileLifecycle } from "@drakkar.software/starfish-client"
+ *
+ * // Call once, after the store is created:
+ * const cleanup = createMobileLifecycle(
+ *   store,
+ *   { appState: AppState, netInfo: NetInfo },
+ * )
+ *
+ * // In a React component (e.g. root layout):
+ * useEffect(() => cleanup, [])
+ * ```
+ *
+ * @returns A cleanup function that removes all event listeners.
+ */
+export declare function createMobileLifecycle(store: StoreApi<StarfishStore>, deps: MobileLifecycleDeps, options?: MobileLifecycleOptions): () => void;

package/dist/mobile-lifecycle.js

@@ -0,0 +1,55 @@
+// ── Implementation ────────────────────────────────────────────────────────────
+/**
+ * Wires React Native app lifecycle events to a Starfish store.
+ *
+ * - **Background**: flushes pending changes before the OS suspends the app.
+ * - **Foreground**: pulls remote changes when the user returns to the app.
+ * - **NetInfo**: forwards connectivity changes to `store.getState().setOnline()`.
+ *
+ * Uses dependency injection so no `react-native` or `netinfo` imports are needed
+ * in this package. Pass the modules directly:
+ *
+ * ```ts
+ * import { AppState } from "react-native"
+ * import NetInfo from "@react-native-community/netinfo"
+ * import { createMobileLifecycle } from "@drakkar.software/starfish-client"
+ *
+ * // Call once, after the store is created:
+ * const cleanup = createMobileLifecycle(
+ *   store,
+ *   { appState: AppState, netInfo: NetInfo },
+ * )
+ *
+ * // In a React component (e.g. root layout):
+ * useEffect(() => cleanup, [])
+ * ```
+ *
+ * @returns A cleanup function that removes all event listeners.
+ */
+export function createMobileLifecycle(store, deps, options = {}) {
+    const { pullOnForeground = true, flushOnBackground = true } = options;
+    const appSub = deps.appState.addEventListener("change", (appState) => {
+        if (appState === "background" && flushOnBackground) {
+            if (store.getState().dirty) {
+                store.getState().flush().catch(() => { });
+            }
+        }
+        else if (appState === "active" && pullOnForeground) {
+            const { online, syncing } = store.getState();
+            if (online && !syncing) {
+                store.getState().pull().catch(() => { });
+            }
+        }
+        // "inactive" (iOS transition) and other states are intentionally ignored
+    });
+    let netUnsub = null;
+    if (deps.netInfo) {
+        netUnsub = deps.netInfo.addEventListener(({ isConnected }) => {
+            store.getState().setOnline(!!isConnected);
+        });
+    }
+    return () => {
+        appSub.remove();
+        netUnsub?.();
+    };
+}

package/package.json

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

package/dist/hash.d.ts

@@ -1,10 +0,0 @@
-/**
- * Deterministic JSON serialization with sorted keys (recursive).
- * Must produce identical output to the server's stableStringify.
- */
-export declare function stableStringify(value: unknown): string;
-/**
- * Compute SHA-256 hex digest of the stable-stringified data.
- * Works in both browser (crypto.subtle) and Node.js environments.
- */
-export declare function computeHash(data: Record<string, unknown>): Promise<string>;

package/dist/hash.js

@@ -1,34 +0,0 @@
-import { getCrypto } from "./platform.js";
-/**
- * Deterministic JSON serialization with sorted keys (recursive).
- * Must produce identical output to the server's stableStringify.
- */
-export function stableStringify(value) {
-    if (value === null || value === undefined)
-        return "null";
-    if (typeof value === "boolean" || typeof value === "number")
-        return JSON.stringify(value);
-    if (typeof value === "string")
-        return JSON.stringify(value);
-    if (Array.isArray(value)) {
-        return "[" + value.map(v => stableStringify(v)).join(",") + "]";
-    }
-    if (typeof value === "object") {
-        const obj = value;
-        const keys = Object.keys(obj).sort();
-        const pairs = keys.map(k => JSON.stringify(k) + ":" + stableStringify(obj[k]));
-        return "{" + pairs.join(",") + "}";
-    }
-    return "null";
-}
-/**
- * Compute SHA-256 hex digest of the stable-stringified data.
- * Works in both browser (crypto.subtle) and Node.js environments.
- */
-export async function computeHash(data) {
-    const encoded = new TextEncoder().encode(stableStringify(data));
-    const buf = await getCrypto().subtle.digest("SHA-256", encoded);
-    return Array.from(new Uint8Array(buf))
-        .map(b => b.toString(16).padStart(2, "0"))
-        .join("");
-}

package/dist/platform.d.ts

@@ -1,52 +0,0 @@
-/**
- * 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

@@ -1,62 +0,0 @@
-/**
- * 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.");
-}