@drakkar.software/starfish-client 1.19.0 → 1.19.2

package/dist/bindings/zustand.js

@@ -1,266 +1,801 @@
+// src/bindings/zustand.ts
 import { createStore } from "zustand/vanilla";
 import { useStore } from "zustand";
-import { persist, subscribeWithSelector, createJSONStorage, } from "zustand/middleware";
-import { useEffect, useRef, useState, useCallback } from "react";
-import { StarfishClient } from "../client.js";
-import { SyncManager } from "../sync.js";
-import { setupCrossTabSync } from "../broadcast.js";
-export function createStarfishStore(options) {
-    const { name, syncManager, storage } = options;
-    const storeCreator = (rawSet, get) => {
-        const set = rawSet;
-        return {
-            data: {},
-            syncing: false,
-            online: true,
-            dirty: false,
-            error: null,
-            pull: async () => {
-                set({ syncing: true, error: null }, false, "pull/start");
-                try {
-                    await syncManager.pull();
-                    const newData = syncManager.getData();
-                    set({ data: newData, syncing: false }, false, "pull/success");
-                    // Fire after state update so domain stores can read the updated Starfish state if needed.
-                    // Calling set() inside onRemoteUpdate does NOT re-enter pull(), so no feedback loop.
-                    options.onRemoteUpdate?.(newData);
-                }
-                catch (err) {
-                    set({ syncing: false, error: err instanceof Error ? err.message : String(err) }, false, "pull/error");
-                }
-            },
-            set: (modifier) => {
-                try {
-                    const next = options.produce
-                        ? options.produce(get().data, modifier)
-                        : modifier(get().data);
-                    set({ data: next, dirty: true, error: null }, false, "set");
-                    if (get().online)
-                        get().flush().catch(() => { });
-                }
-                catch (err) {
-                    set({ error: err instanceof Error ? err.message : String(err) }, false, "set/error");
-                }
-            },
-            restore: (data) => {
-                set({ data }, false, "restore");
-            },
-            flush: async () => {
-                if (get().syncing || !get().dirty)
-                    return;
-                set({ syncing: true, error: null }, false, "flush/start");
-                try {
-                    await syncManager.push(get().data);
-                    set({ data: syncManager.getData(), syncing: false, dirty: false }, false, "flush/success");
-                }
-                catch (err) {
-                    set({ syncing: false, error: err instanceof Error ? err.message : String(err) }, false, "flush/error");
-                }
-            },
-            setOnline: (online) => {
-                set({ online }, false, "setOnline");
-                if (online && get().dirty)
-                    get().flush().catch(() => { });
-            },
-        };
+
+// ../../../node_modules/.pnpm/zustand@5.0.11_@types+react@19.2.14_immer@11.1.4_react@19.2.4_use-sync-external-store@1.6.0_react@19.2.4_/node_modules/zustand/esm/middleware.mjs
+var subscribeWithSelectorImpl = (fn) => (set, get, api) => {
+  const origSubscribe = api.subscribe;
+  api.subscribe = ((selector, optListener, options) => {
+    let listener = selector;
+    if (optListener) {
+      const equalityFn = (options == null ? void 0 : options.equalityFn) || Object.is;
+      let currentSlice = selector(api.getState());
+      listener = (state) => {
+        const nextSlice = selector(state);
+        if (!equalityFn(currentSlice, nextSlice)) {
+          const previousSlice = currentSlice;
+          optListener(currentSlice = nextSlice, previousSlice);
+        }
+      };
+      if (options == null ? void 0 : options.fireImmediately) {
+        optListener(currentSlice, currentSlice);
+      }
+    }
+    return origSubscribe(listener);
+  });
+  const initialState = fn(set, get, api);
+  return initialState;
+};
+var subscribeWithSelector = subscribeWithSelectorImpl;
+function createJSONStorage(getStorage, options) {
+  let storage;
+  try {
+    storage = getStorage();
+  } catch (e) {
+    return;
+  }
+  const persistStorage = {
+    getItem: (name) => {
+      var _a;
+      const parse = (str2) => {
+        if (str2 === null) {
+          return null;
+        }
+        return JSON.parse(str2, options == null ? void 0 : options.reviver);
+      };
+      const str = (_a = storage.getItem(name)) != null ? _a : null;
+      if (str instanceof Promise) {
+        return str.then(parse);
+      }
+      return parse(str);
+    },
+    setItem: (name, newValue) => storage.setItem(name, JSON.stringify(newValue, options == null ? void 0 : options.replacer)),
+    removeItem: (name) => storage.removeItem(name)
+  };
+  return persistStorage;
+}
+var toThenable = (fn) => (input) => {
+  try {
+    const result = fn(input);
+    if (result instanceof Promise) {
+      return result;
+    }
+    return {
+      then(onFulfilled) {
+        return toThenable(onFulfilled)(result);
+      },
+      catch(_onRejected) {
+        return this;
+      }
+    };
+  } catch (e) {
+    return {
+      then(_onFulfilled) {
+        return this;
+      },
+      catch(onRejected) {
+        return toThenable(onRejected)(e);
+      }
     };
-    const withPersist = storage === false
-        ? storeCreator
-        : persist(storeCreator, {
-            name: `starfish-${name}`,
-            storage: storage ? createJSONStorage(() => storage) : undefined,
-            partialize: (state) => ({
-                data: state.data,
-                dirty: state.dirty,
-            }),
+  }
+};
+var persistImpl = (config, baseOptions) => (set, get, api) => {
+  let options = {
+    storage: createJSONStorage(() => window.localStorage),
+    partialize: (state) => state,
+    version: 0,
+    merge: (persistedState, currentState) => ({
+      ...currentState,
+      ...persistedState
+    }),
+    ...baseOptions
+  };
+  let hasHydrated = false;
+  let hydrationVersion = 0;
+  const hydrationListeners = /* @__PURE__ */ new Set();
+  const finishHydrationListeners = /* @__PURE__ */ new Set();
+  let storage = options.storage;
+  if (!storage) {
+    return config(
+      (...args) => {
+        console.warn(
+          `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
+        );
+        set(...args);
+      },
+      get,
+      api
+    );
+  }
+  const setItem = () => {
+    const state = options.partialize({ ...get() });
+    return storage.setItem(options.name, {
+      state,
+      version: options.version
+    });
+  };
+  const savedSetState = api.setState;
+  api.setState = (state, replace) => {
+    savedSetState(state, replace);
+    return setItem();
+  };
+  const configResult = config(
+    (...args) => {
+      set(...args);
+      return setItem();
+    },
+    get,
+    api
+  );
+  api.getInitialState = () => configResult;
+  let stateFromStorage;
+  const hydrate = () => {
+    var _a, _b;
+    if (!storage) return;
+    const currentVersion = ++hydrationVersion;
+    hasHydrated = false;
+    hydrationListeners.forEach((cb) => {
+      var _a2;
+      return cb((_a2 = get()) != null ? _a2 : configResult);
+    });
+    const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
+    return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
+      if (deserializedStorageValue) {
+        if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
+          if (options.migrate) {
+            const migration = options.migrate(
+              deserializedStorageValue.state,
+              deserializedStorageValue.version
+            );
+            if (migration instanceof Promise) {
+              return migration.then((result) => [true, result]);
+            }
+            return [true, migration];
+          }
+          console.error(
+            `State loaded from storage couldn't be migrated since no migrate function was provided`
+          );
+        } else {
+          return [false, deserializedStorageValue.state];
+        }
+      }
+      return [false, void 0];
+    }).then((migrationResult) => {
+      var _a2;
+      if (currentVersion !== hydrationVersion) {
+        return;
+      }
+      const [migrated, migratedState] = migrationResult;
+      stateFromStorage = options.merge(
+        migratedState,
+        (_a2 = get()) != null ? _a2 : configResult
+      );
+      set(stateFromStorage, true);
+      if (migrated) {
+        return setItem();
+      }
+    }).then(() => {
+      if (currentVersion !== hydrationVersion) {
+        return;
+      }
+      postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
+      stateFromStorage = get();
+      hasHydrated = true;
+      finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
+    }).catch((e) => {
+      if (currentVersion !== hydrationVersion) {
+        return;
+      }
+      postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
+    });
+  };
+  api.persist = {
+    setOptions: (newOptions) => {
+      options = {
+        ...options,
+        ...newOptions
+      };
+      if (newOptions.storage) {
+        storage = newOptions.storage;
+      }
+    },
+    clearStorage: () => {
+      storage == null ? void 0 : storage.removeItem(options.name);
+    },
+    getOptions: () => options,
+    rehydrate: () => hydrate(),
+    hasHydrated: () => hasHydrated,
+    onHydrate: (cb) => {
+      hydrationListeners.add(cb);
+      return () => {
+        hydrationListeners.delete(cb);
+      };
+    },
+    onFinishHydration: (cb) => {
+      finishHydrationListeners.add(cb);
+      return () => {
+        finishHydrationListeners.delete(cb);
+      };
+    }
+  };
+  if (!options.skipHydration) {
+    hydrate();
+  }
+  return stateFromStorage || configResult;
+};
+var persist = persistImpl;
+
+// src/bindings/zustand.ts
+import { useEffect, useRef, useState, useCallback } from "react";
+
+// src/types.ts
+var ConflictError = class extends Error {
+  constructor() {
+    super("hash_mismatch");
+    this.name = "ConflictError";
+  }
+};
+var StarfishHttpError = class extends Error {
+  constructor(status, body) {
+    super(`HTTP ${status}: ${body}`);
+    this.status = status;
+    this.body = body;
+    this.name = "StarfishHttpError";
+  }
+};
+
+// src/client.ts
+var StarfishClient = class {
+  baseUrl;
+  auth;
+  fetch;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.auth = options.auth;
+    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  /**
+   * Pull synced data from the server.
+   * @param path - The pull endpoint path (e.g. "/pull/users/abc/settings")
+   * @param checkpoint - Only return data updated after this timestamp (0 = full pull)
+   */
+  async pull(path, checkpoint) {
+    const url = checkpoint ? `${this.baseUrl}${path}?checkpoint=${checkpoint}` : `${this.baseUrl}${path}`;
+    const authHeaders = this.auth ? await this.auth({ method: "GET", path, body: null }) : {};
+    const res = await this.fetch(url, {
+      method: "GET",
+      headers: { Accept: "application/json", ...authHeaders }
+    });
+    if (!res.ok) {
+      throw new StarfishHttpError(res.status, await res.text());
+    }
+    return res.json();
+  }
+  /**
+   * Push synced data to the server.
+   * @param path - The push endpoint path (e.g. "/push/users/abc/settings")
+   * @param data - The full document data to push
+   * @param baseHash - Hash of the document this push is based on (null for first push)
+   * @param authorSignature - Optional author signature for provenance
+   * @throws {ConflictError} if the server detects a hash mismatch (409)
+   */
+  async push(path, data, baseHash, authorSignature) {
+    const body = JSON.stringify({
+      data,
+      baseHash,
+      ...authorSignature && { authorSignature }
+    });
+    const authHeaders = this.auth ? await this.auth({ method: "POST", path, body }) : {};
+    const res = await this.fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...authHeaders
+      },
+      body
+    });
+    if (res.status === 409) {
+      throw new ConflictError();
+    }
+    if (!res.ok) {
+      throw new StarfishHttpError(res.status, await res.text());
+    }
+    return res.json();
+  }
+  /**
+   * Pull binary data from a blob collection.
+   * Returns raw bytes with the content hash from the ETag header.
+   */
+  async pullBlob(path) {
+    const authHeaders = this.auth ? await this.auth({ method: "GET", path, body: null }) : {};
+    const res = await this.fetch(`${this.baseUrl}${path}`, {
+      method: "GET",
+      headers: { Accept: "*/*", ...authHeaders }
+    });
+    if (!res.ok) {
+      throw new StarfishHttpError(res.status, await res.text());
+    }
+    const etag = res.headers.get("ETag")?.replace(/"/g, "") ?? null;
+    const contentType = res.headers.get("Content-Type") ?? "application/octet-stream";
+    const data = await res.arrayBuffer();
+    return { data, hash: etag, contentType };
+  }
+  /**
+   * Push binary data to a blob collection.
+   * Binary collections use last-write-wins (no conflict detection).
+   */
+  async pushBlob(path, data, contentType) {
+    const authHeaders = this.auth ? await this.auth({ method: "POST", path, body: null }) : {};
+    const res = await this.fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": contentType,
+        Accept: "application/json",
+        ...authHeaders
+      },
+      body: data
+    });
+    if (!res.ok) {
+      throw new StarfishHttpError(res.status, await res.text());
+    }
+    return res.json();
+  }
+};
+
+// src/sync.ts
+import { deepMerge, stableStringify } from "@drakkar.software/starfish-protocol";
+
+// src/crypto.ts
+import { getCrypto, getBase64, IV_BYTES, ENCRYPTED_KEY, deriveKey } from "@drakkar.software/starfish-protocol";
+var ALGO = "AES-GCM";
+function createEncryptor(secret, salt, info = "starfish-e2e") {
+  if (!secret) throw new Error("encryptionSecret must not be empty");
+  if (!salt) throw new Error("encryptionSalt must not be empty");
+  const keyPromise = deriveKey(secret, salt, info);
+  return {
+    async encrypt(data) {
+      const key = await keyPromise;
+      const c = getCrypto();
+      const b64 = getBase64();
+      const plaintext = new TextEncoder().encode(JSON.stringify(data));
+      const iv = c.getRandomValues(new Uint8Array(IV_BYTES));
+      const ciphertext = await c.subtle.encrypt({ name: ALGO, iv }, key, plaintext);
+      const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+      combined.set(iv);
+      combined.set(new Uint8Array(ciphertext), iv.length);
+      return { [ENCRYPTED_KEY]: b64.encode(combined) };
+    },
+    async decrypt(wrapper) {
+      const encoded = wrapper[ENCRYPTED_KEY];
+      if (typeof encoded !== "string") {
+        throw new Error("Expected encrypted data but received unencrypted document");
+      }
+      const key = await keyPromise;
+      const c = getCrypto();
+      const b64 = getBase64();
+      const combined = b64.decode(encoded);
+      if (combined.length < IV_BYTES) {
+        throw new Error("Encrypted data is too short");
+      }
+      const iv = combined.slice(0, IV_BYTES);
+      const ciphertext = combined.slice(IV_BYTES);
+      try {
+        const plaintext = await c.subtle.decrypt({ name: ALGO, iv }, key, ciphertext);
+        return JSON.parse(new TextDecoder().decode(plaintext));
+      } catch (err) {
+        throw new Error("Decryption failed: data may be tampered or key is incorrect", { cause: err });
+      }
+    }
+  };
+}
+
+// src/validate.ts
+var ValidationError = class extends Error {
+  constructor(errors) {
+    super(`Validation failed: ${errors.join("; ")}`);
+    this.errors = errors;
+    this.name = "ValidationError";
+  }
+};
+
+// src/sync.ts
+var SyncManager = class {
+  client;
+  pullPath;
+  pushPath;
+  onConflict;
+  maxRetries;
+  encryptor;
+  signData;
+  logger;
+  loggerName;
+  validate;
+  lastHash = null;
+  lastCheckpoint = 0;
+  localData = {};
+  constructor(options) {
+    this.client = options.client;
+    this.pullPath = options.pullPath;
+    this.pushPath = options.pushPath;
+    this.onConflict = options.onConflict ?? deepMerge;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.signData = options.signData;
+    this.logger = options.logger;
+    this.loggerName = options.loggerName ?? options.pullPath.split("/").filter(Boolean).pop() ?? options.pullPath;
+    this.validate = options.validate;
+    this.encryptor = options.encryptor ?? (options.encryptionSecret && options.encryptionSalt ? createEncryptor(options.encryptionSecret, options.encryptionSalt, options.encryptionInfo) : null);
+  }
+  getData() {
+    return { ...this.localData };
+  }
+  getHash() {
+    return this.lastHash;
+  }
+  getCheckpoint() {
+    return this.lastCheckpoint;
+  }
+  async pull() {
+    this.logger?.pullStart(this.loggerName);
+    const start = performance.now();
+    try {
+      const result = await this.client.pull(this.pullPath, this.lastCheckpoint);
+      if (this.encryptor) {
+        const decrypted = await this.encryptor.decrypt(result.data);
+        this.localData = decrypted;
+        result.data = decrypted;
+      } else if (this.lastCheckpoint > 0) {
+        this.localData = deepMerge(this.localData, result.data);
+        result.data = this.localData;
+      } else {
+        this.localData = result.data;
+      }
+      this.lastHash = result.hash;
+      this.lastCheckpoint = result.timestamp;
+      this.logger?.pullSuccess(this.loggerName, Math.round(performance.now() - start));
+      return result;
+    } catch (err) {
+      this.logger?.pullError(this.loggerName, err instanceof Error ? err.message : String(err));
+      throw err;
+    }
+  }
+  async push(data) {
+    if (this.validate) {
+      const result = this.validate(data);
+      if (result !== true) throw new ValidationError(result);
+    }
+    this.logger?.pushStart(this.loggerName);
+    const start = performance.now();
+    let attempt = 0;
+    let pendingData = data;
+    while (attempt <= this.maxRetries) {
+      try {
+        const payload = this.encryptor ? await this.encryptor.encrypt(pendingData) : pendingData;
+        const sig = this.signData ? await this.signData(stableStringify(payload)) : void 0;
+        const result = await this.client.push(
+          this.pushPath,
+          payload,
+          this.lastHash,
+          sig
+        );
+        this.lastHash = result.hash;
+        this.lastCheckpoint = result.timestamp;
+        this.localData = pendingData;
+        this.logger?.pushSuccess(this.loggerName, Math.round(performance.now() - start));
+        return result;
+      } catch (err) {
+        if (!(err instanceof ConflictError) || attempt >= this.maxRetries) {
+          this.logger?.pushError(this.loggerName, err instanceof Error ? err.message : String(err));
+          throw err;
+        }
+        this.logger?.conflict(this.loggerName, attempt + 1);
+        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), 2e3) + Math.random() * 100));
+        attempt++;
+      }
+    }
+    throw new ConflictError();
+  }
+  async update(modifier) {
+    await this.pull();
+    const updated = modifier(this.localData);
+    return this.push(updated);
+  }
+};
+
+// src/broadcast.ts
+function setupBroadcastSync(store, name) {
+  const channel = new BroadcastChannel(`starfish-${name}`);
+  let lastReceivedData = null;
+  channel.onmessage = (event) => {
+    const payload = event.data;
+    if (!payload || typeof payload !== "object" || !payload.data || typeof payload.data !== "object") return;
+    lastReceivedData = payload.data;
+    store.setState({ data: payload.data, dirty: !!payload.dirty });
+  };
+  const unsub = store.subscribe((state, prev) => {
+    if (state.data === lastReceivedData) return;
+    if (state.data !== prev.data || state.dirty !== prev.dirty) {
+      try {
+        channel.postMessage({ data: state.data, dirty: state.dirty });
+      } catch {
+      }
+    }
+  });
+  return () => {
+    unsub();
+    channel.close();
+  };
+}
+function setupStorageFallback(store, name) {
+  const storageKey = `starfish-broadcast-${name}`;
+  let lastReceivedData = null;
+  const onStorage = (e) => {
+    if (e.key !== storageKey || !e.newValue) return;
+    let payload;
+    try {
+      payload = JSON.parse(e.newValue);
+    } catch {
+      return;
+    }
+    if (!payload || typeof payload !== "object" || !payload.data || typeof payload.data !== "object") return;
+    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) {
+      try {
+        localStorage.setItem(
+          storageKey,
+          JSON.stringify({ data: state.data, dirty: state.dirty })
+        );
+      } catch {
+      }
+    }
+  });
+  return () => {
+    unsub();
+    globalThis.removeEventListener("storage", onStorage);
+  };
+}
+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 () => {
+  };
+}
+
+// src/bindings/zustand.ts
+function createStarfishStore(options) {
+  const { name, syncManager, storage } = options;
+  const storeCreator = (rawSet, get) => {
+    const set = rawSet;
+    return {
+      data: {},
+      syncing: false,
+      online: true,
+      dirty: false,
+      error: null,
+      pull: async () => {
+        set({ syncing: true, error: null }, false, "pull/start");
+        try {
+          await syncManager.pull();
+          const newData = syncManager.getData();
+          set({ data: newData, syncing: false }, false, "pull/success");
+          options.onRemoteUpdate?.(newData);
+        } catch (err) {
+          set({ syncing: false, error: err instanceof Error ? err.message : String(err) }, false, "pull/error");
+        }
+      },
+      set: (modifier) => {
+        try {
+          const next = options.produce ? options.produce(get().data, modifier) : modifier(get().data);
+          set({ data: next, dirty: true, error: null }, false, "set");
+          if (get().online) get().flush().catch(() => {
+          });
+        } catch (err) {
+          set({ error: err instanceof Error ? err.message : String(err) }, false, "set/error");
+        }
+      },
+      restore: (data) => {
+        set({ data }, false, "restore");
+      },
+      flush: async () => {
+        if (get().syncing || !get().dirty) return;
+        set({ syncing: true, error: null }, false, "flush/start");
+        try {
+          await syncManager.push(get().data);
+          set({ data: syncManager.getData(), syncing: false, dirty: false }, false, "flush/success");
+        } catch (err) {
+          set({ syncing: false, error: err instanceof Error ? err.message : String(err) }, false, "flush/error");
+        }
+      },
+      setOnline: (online) => {
+        set({ online }, false, "setOnline");
+        if (online && get().dirty) get().flush().catch(() => {
         });
-    const withSelector = subscribeWithSelector(withPersist);
-    return createStore()(options.devtools ? options.devtools(withSelector) : withSelector);
+      }
+    };
+  };
+  const withPersist = storage === false ? storeCreator : persist(storeCreator, {
+    name: `starfish-${name}`,
+    storage: storage ? createJSONStorage(() => storage) : void 0,
+    partialize: (state) => ({
+      data: state.data,
+      dirty: state.dirty
+    })
+  });
+  const withSelector = subscribeWithSelector(withPersist);
+  return createStore()(
+    options.devtools ? options.devtools(withSelector) : withSelector
+  );
 }
-/** 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";
+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";
 }
-/**
- * Aggregate multiple sync statuses into a single worst-case status.
- * Priority (worst first): error > syncing > pending > offline > synced.
- */
-export function aggregateSyncStatus(statuses) {
-    if (statuses.includes("error"))
-        return "error";
-    if (statuses.includes("syncing"))
-        return "syncing";
-    if (statuses.includes("pending"))
-        return "pending";
-    if (statuses.includes("offline"))
-        return "offline";
-    return "synced";
+function aggregateSyncStatus(statuses) {
+  if (statuses.includes("error")) return "error";
+  if (statuses.includes("syncing")) return "syncing";
+  if (statuses.includes("pending")) return "pending";
+  if (statuses.includes("offline")) return "offline";
+  return "synced";
 }
-/** Use the full Starfish store state and actions. */
-export function useStarfish(store) {
-    return useStore(store);
+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);
+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);
+function useSyncStatus(store) {
+  return useStore(store, deriveSyncStatus);
 }
-/**
- * Subscribe to sync status changes outside of React.
- *
- * Framework-agnostic — works in React Native, Node.js, or anywhere hooks are unavailable.
- * The callback is invoked immediately with the current status and then on every change.
- *
- * ```ts
- * const unsub = subscribeSyncStatus(store, (status) => {
- *   updateStatusBar(status)
- * })
- *
- * // Later, to stop listening:
- * unsub()
- * ```
- */
-export function subscribeSyncStatus(store, callback) {
-    let prev = deriveSyncStatus(store.getState());
-    callback(prev);
-    return store.subscribe((state) => {
-        const next = deriveSyncStatus(state);
-        if (next !== prev) {
-            prev = next;
-            callback(next);
-        }
-    });
+function subscribeSyncStatus(store, callback) {
+  let prev = deriveSyncStatus(store.getState());
+  callback(prev);
+  return store.subscribe((state) => {
+    const next = deriveSyncStatus(state);
+    if (next !== prev) {
+      prev = next;
+      callback(next);
+    }
+  });
 }
-/** Sets up cross-tab sync for a Starfish store. Cleans up on unmount. */
-export function useCrossTabSync(store, name) {
-    useEffect(() => {
-        return setupCrossTabSync(store, name);
-    }, [store, name]);
+function useCrossTabSync(store, name) {
+  useEffect(() => {
+    return setupCrossTabSync(store, name);
+  }, [store, name]);
 }
-/** Binds browser online/offline events to the store's setOnline action. Cleans up on unmount. */
-export function useConnectivity(store) {
-    useEffect(() => {
-        const handleOnline = () => store.getState().setOnline(true);
-        const handleOffline = () => store.getState().setOnline(false);
-        window.addEventListener("online", handleOnline);
-        window.addEventListener("offline", handleOffline);
-        return () => {
-            window.removeEventListener("online", handleOnline);
-            window.removeEventListener("offline", handleOffline);
-        };
-    }, [store]);
+function useConnectivity(store) {
+  useEffect(() => {
+    const handleOnline = () => store.getState().setOnline(true);
+    const handleOffline = () => store.getState().setOnline(false);
+    window.addEventListener("online", handleOnline);
+    window.addEventListener("offline", handleOffline);
+    return () => {
+      window.removeEventListener("online", handleOnline);
+      window.removeEventListener("offline", handleOffline);
+    };
+  }, [store]);
 }
-/** Returns a human-readable "last synced" label that updates every 5 seconds. */
-export function useLastSynced(store) {
-    const lastSyncedAt = useRef(null);
-    const [label, setLabel] = useState("Never synced");
-    const computeLabel = useCallback(() => {
-        if (lastSyncedAt.current === null)
-            return "Never synced";
-        const seconds = Math.floor((Date.now() - lastSyncedAt.current) / 1000);
-        if (seconds < 10)
-            return "Just now";
-        if (seconds < 60)
-            return `${seconds}s ago`;
-        return `${Math.floor(seconds / 60)}m ago`;
-    }, []);
-    // Track sync completion
-    useEffect(() => {
-        let prevSyncing = store.getState().syncing;
-        const unsub = store.subscribe((state) => {
-            if (prevSyncing && !state.syncing && !state.error) {
-                lastSyncedAt.current = Date.now();
-                setLabel(computeLabel());
-            }
-            prevSyncing = state.syncing;
-        });
-        return unsub;
-    }, [store, computeLabel]);
-    // Update label periodically
-    useEffect(() => {
-        const timer = setInterval(() => {
-            setLabel(computeLabel());
-        }, 5000);
-        return () => clearInterval(timer);
-    }, [computeLabel]);
-    return label;
+function useLastSynced(store) {
+  const lastSyncedAt = useRef(null);
+  const [label, setLabel] = useState("Never synced");
+  const computeLabel = useCallback(() => {
+    if (lastSyncedAt.current === null) return "Never synced";
+    const seconds = Math.floor((Date.now() - lastSyncedAt.current) / 1e3);
+    if (seconds < 10) return "Just now";
+    if (seconds < 60) return `${seconds}s ago`;
+    return `${Math.floor(seconds / 60)}m ago`;
+  }, []);
+  useEffect(() => {
+    let prevSyncing = store.getState().syncing;
+    const unsub = store.subscribe((state) => {
+      if (prevSyncing && !state.syncing && !state.error) {
+        lastSyncedAt.current = Date.now();
+        setLabel(computeLabel());
+      }
+      prevSyncing = state.syncing;
+    });
+    return unsub;
+  }, [store, computeLabel]);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setLabel(computeLabel());
+    }, 5e3);
+    return () => clearInterval(timer);
+  }, [computeLabel]);
+  return label;
 }
-/**
- * React hook that manages the full Starfish sync lifecycle.
- *
- * Creates StarfishClient → SyncManager → Zustand store, pulls on mount,
- * calls `onData` when remote data arrives, and tears down on unmount or
- * config change.
- *
- * Pass `null` to disable sync (returns `null`).
- */
-export function useSyncInit(config) {
-    const [store, setStore] = useState(null);
-    const onDataRef = useRef(config?.onData);
-    onDataRef.current = config?.onData;
-    useEffect(() => {
-        if (!config) {
-            setStore(null);
-            return;
+function useSyncInit(config) {
+  const [store, setStore] = useState(null);
+  const onDataRef = useRef(config?.onData);
+  onDataRef.current = config?.onData;
+  useEffect(() => {
+    if (!config) {
+      setStore(null);
+      return;
+    }
+    const client = new StarfishClient({
+      baseUrl: config.serverUrl,
+      auth: config.auth,
+      fetch: config.fetch
+    });
+    const syncManager = new SyncManager({
+      client,
+      pullPath: config.pullPath,
+      pushPath: config.pushPath,
+      encryptionSecret: config.encryptionSecret,
+      encryptionSalt: config.encryptionSalt,
+      onConflict: config.onConflict,
+      logger: config.logger,
+      validate: config.validate
+    });
+    const newStore = createStarfishStore({
+      name: config.storeName ?? "sync",
+      syncManager,
+      storage: config.storage,
+      // onRemoteUpdate fires only for pull() results, never for local set() writes —
+      // so no isRestoring flag is needed.
+      onRemoteUpdate: (data) => {
+        try {
+          onDataRef.current?.(data);
+        } catch (err) {
+          newStore.setState({
+            error: `onData failed: ${err instanceof Error ? err.message : String(err)}`
+          });
         }
-        const client = new StarfishClient({
-            baseUrl: config.serverUrl,
-            auth: config.auth,
-            fetch: config.fetch,
-        });
-        const syncManager = new SyncManager({
-            client,
-            pullPath: config.pullPath,
-            pushPath: config.pushPath,
-            encryptionSecret: config.encryptionSecret,
-            encryptionSalt: config.encryptionSalt,
-            onConflict: config.onConflict,
-            logger: config.logger,
-            validate: config.validate,
-        });
-        const newStore = createStarfishStore({
-            name: config.storeName ?? "sync",
-            syncManager,
-            storage: config.storage,
-            // onRemoteUpdate fires only for pull() results, never for local set() writes —
-            // so no isRestoring flag is needed.
-            onRemoteUpdate: (data) => {
-                try {
-                    onDataRef.current?.(data);
-                }
-                catch (err) {
-                    newStore.setState({
-                        error: `onData failed: ${err instanceof Error ? err.message : String(err)}`,
-                    });
-                }
-            },
-        });
-        setStore(newStore);
-        // Initial pull — errors are stored in state.error by the pull() action
-        newStore.getState().pull().catch(() => { });
-        return () => {
-            setStore(null);
-        };
-        // Intentionally depend on serializable config values, not the object reference
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [
-        config?.serverUrl,
-        config?.pullPath,
-        config?.pushPath,
-        config?.encryptionSecret,
-        config?.encryptionSalt,
-        config?.storeName,
-    ]);
-    return store;
+      }
+    });
+    setStore(newStore);
+    newStore.getState().pull().catch(() => {
+    });
+    return () => {
+      setStore(null);
+    };
+  }, [
+    config?.serverUrl,
+    config?.pullPath,
+    config?.pushPath,
+    config?.encryptionSecret,
+    config?.encryptionSalt,
+    config?.storeName
+  ]);
+  return store;
 }
+export {
+  aggregateSyncStatus,
+  createStarfishStore,
+  deriveSyncStatus,
+  subscribeSyncStatus,
+  useConnectivity,
+  useCrossTabSync,
+  useLastSynced,
+  useStarfish,
+  useStarfishData,
+  useSyncInit,
+  useSyncStatus
+};
+//# sourceMappingURL=zustand.js.map