@drakkar.software/starfish-client 1.19.0 → 1.19.2

package/dist/index.js

@@ -1,25 +1,1344 @@
-export { configurePlatform } from "@drakkar.software/starfish-protocol";
-export { stableStringify, computeHash } from "@drakkar.software/starfish-protocol";
-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, 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, withConflictMeta, } from "./resolvers.js";
-export { SnapshotHistory } from "./history.js";
-export { startPolling, startAdaptivePolling } from "./polling.js";
-export { createDedupFetch } from "./dedup.js";
-export { fetchServerConfig } from "./config.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";
-export { createDebouncedSync, createDebouncedPush } from "./debounced-sync.js";
-export { createMobileLifecycle } from "./mobile-lifecycle.js";
-export { createMultiStoreSync } from "./multi-store.js";
-export { deriveGroupKeyPair, generateGroupKey, wrapGroupKey, unwrapGroupKey, createGroupKeyring, addGroupMember, rotateGroupKey, createGroupEncryptor, } from "./group-crypto.js";
-export { pullEntitlements } from "./entitlements.js";
+// src/index.ts
+import { configurePlatform } from "@drakkar.software/starfish-protocol";
+import { stableStringify as stableStringify2, computeHash } from "@drakkar.software/starfish-protocol";
+
+// 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";
+  }
+};
+function createSchemaValidator(ajv, schema) {
+  const validate = ajv.compile(schema);
+  return (data) => {
+    if (validate(data)) return true;
+    return [ajv.errorsText(validate.errors)];
+  };
+}
+
+// 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/logger.ts
+var consoleSyncLogger = {
+  pullStart: (s) => console.log(`[starfish:${s}] pull started`),
+  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, 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})`)
+};
+var noopSyncLogger = {
+  pullStart: () => {
+  },
+  pullSuccess: () => {
+  },
+  pullError: () => {
+  },
+  pushStart: () => {
+  },
+  pushSuccess: () => {
+  },
+  pushError: () => {
+  },
+  conflict: () => {
+  }
+};
+function createMetricsCollector() {
+  const stores = /* @__PURE__ */ 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();
+    }
+  };
+}
+
+// src/migrate.ts
+function createMigrator(config) {
+  for (let v = 1; v < config.currentVersion; v++) {
+    if (!config.migrations[v]) {
+      throw new Error(`Missing migration for version ${v} -> ${v + 1}`);
+    }
+  }
+  return (data) => {
+    const version = typeof data._schemaVersion === "number" ? data._schemaVersion : 1;
+    if (version > config.currentVersion) {
+      throw new Error(
+        `Document schema version ${version} is newer than app version ${config.currentVersion}. Update the app.`
+      );
+    }
+    if (version === config.currentVersion) return data;
+    let result = { ...data };
+    for (let v = version; v < config.currentVersion; v++) {
+      const fn = config.migrations[v];
+      if (!fn) {
+        throw new Error(`Missing migration for version ${v} -> ${v + 1}`);
+      }
+      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;
+  };
+}
+
+// src/fetch.ts
+function classifyError(err) {
+  if (err instanceof Response || err && typeof err === "object" && "status" in err) {
+    const status = err.status;
+    if (typeof status !== "number" || isNaN(status)) return "unknown";
+    if (status === 0) return "network";
+    if (status === 401 || status === 403) return "auth";
+    if (status === 409) return "conflict";
+    if (status === 429) return "rate-limited";
+    if (status >= 500) return "server";
+    if (status >= 400) return "client";
+  }
+  if (err instanceof Error && /failed to fetch|fetch failed|network|load failed|ECONNREFUSED|ENOTFOUND/i.test(err.message)) return "network";
+  return "unknown";
+}
+
+// src/resolvers.ts
+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]));
+}
+function withConflictMeta(resolver) {
+  return (local, remote) => {
+    const conflictedFields = [];
+    const allKeys = /* @__PURE__ */ 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);
+    let resolvedBy = "merged";
+    if (shallowEqual(data, local)) resolvedBy = "local";
+    else if (shallowEqual(data, remote)) resolvedBy = "remote";
+    return {
+      data,
+      meta: {
+        conflictedFields,
+        resolvedBy,
+        timestamp: Date.now()
+      }
+    };
+  };
+}
+function compareTimestamps(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a >= b;
+  return String(a ?? "") >= String(b ?? "");
+}
+function createUnionMerge(options) {
+  const idKey = options?.idKey ?? "id";
+  const tsKey = options?.timestampKey ?? "updatedAt";
+  const docTsKey = options?.documentTimestampKey ?? "timestamp";
+  return (local, remote) => {
+    const result = {};
+    const localNewer = compareTimestamps(local[docTsKey], remote[docTsKey]);
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(local), ...Object.keys(remote)]);
+    for (const key of allKeys) {
+      const lv = local[key];
+      const rv = remote[key];
+      if (Array.isArray(lv) && Array.isArray(rv)) {
+        const map = /* @__PURE__ */ new Map();
+        for (const item of rv) {
+          if (item && typeof item === "object" && idKey in item) {
+            map.set(item[idKey], item);
+          } else {
+            map.set(/* @__PURE__ */ Symbol(), item);
+          }
+        }
+        for (const item of lv) {
+          if (item && typeof item === "object" && idKey in item) {
+            const localItem = item;
+            const id = localItem[idKey];
+            const remoteItem = map.get(id);
+            if (!remoteItem) {
+              map.set(id, localItem);
+            } else {
+              if (compareTimestamps(localItem[tsKey], remoteItem[tsKey])) {
+                map.set(id, localItem);
+              }
+            }
+          } else {
+            map.set(/* @__PURE__ */ Symbol(), item);
+          }
+        }
+        result[key] = [...map.values()];
+      } else if (lv !== void 0 && rv !== void 0) {
+        result[key] = localNewer ? lv : rv;
+      } else {
+        result[key] = lv ?? rv;
+      }
+    }
+    return result;
+  };
+}
+function createSoftDeleteResolver(options) {
+  const idKey = options?.idKey ?? "id";
+  const tsKey = options?.timestampKey ?? "updatedAt";
+  const deletedAtKey = options?.deletedAtKey ?? "_deletedAt";
+  const baseMerge = createUnionMerge(options);
+  return (local, remote) => {
+    const merged = baseMerge(local, remote);
+    const tombstones = /* @__PURE__ */ new Map();
+    for (const source of [local, remote]) {
+      for (const key of Object.keys(source)) {
+        const arr = source[key];
+        if (!Array.isArray(arr)) continue;
+        for (const item of arr) {
+          if (item && typeof item === "object" && idKey in item && deletedAtKey in item) {
+            const rec = item;
+            const id = rec[idKey];
+            const deletedAt = rec[deletedAtKey];
+            if (typeof deletedAt === "number" || typeof deletedAt === "string") {
+              const existing = tombstones.get(id);
+              if (existing == null || compareTimestamps(deletedAt, existing)) tombstones.set(id, deletedAt);
+            }
+          }
+        }
+      }
+    }
+    for (const key of Object.keys(merged)) {
+      const value = merged[key];
+      if (!Array.isArray(value)) continue;
+      merged[key] = value.filter((item) => {
+        if (!item || typeof item !== "object" || !(idKey in item)) return true;
+        const rec = item;
+        const id = rec[idKey];
+        const deletedAt = tombstones.get(id);
+        if (deletedAt == null) return true;
+        if (rec[deletedAtKey] != null) return true;
+        return compareTimestamps(rec[tsKey], deletedAt) && rec[tsKey] !== deletedAt;
+      });
+    }
+    return merged;
+  };
+}
+function timestampWinner(timestampKey = "timestamp") {
+  return (local, remote) => {
+    return compareTimestamps(local[timestampKey], remote[timestampKey]) ? local : remote;
+  };
+}
+function pruneTombstones(items, ttlMs = 30 * 24 * 60 * 60 * 1e3, deletedAtKey = "_deletedAt") {
+  const cutoff = Date.now() - ttlMs;
+  return items.filter((item) => {
+    const deletedAt = item[deletedAtKey];
+    if (deletedAt == null) return true;
+    if (typeof deletedAt === "number") return deletedAt > cutoff;
+    if (typeof deletedAt === "string") return new Date(deletedAt).getTime() > cutoff;
+    return false;
+  });
+}
+
+// src/history.ts
+var SnapshotHistory = class {
+  snapshots = [];
+  maxSnapshots;
+  storageKey;
+  constructor(options) {
+    this.maxSnapshots = options?.maxSnapshots ?? 20;
+    this.storageKey = options?.storageKey;
+    if (this.storageKey) {
+      try {
+        const raw = localStorage.getItem(this.storageKey);
+        if (raw) {
+          const parsed = JSON.parse(raw);
+          if (Array.isArray(parsed)) this.snapshots = parsed;
+        }
+      } catch {
+      }
+    }
+  }
+  /** Take a labeled snapshot of the given data. */
+  take(label, data) {
+    this.snapshots.push({
+      timestamp: Date.now(),
+      label,
+      data: JSON.stringify(data)
+    });
+    if (this.snapshots.length > this.maxSnapshots) {
+      this.snapshots = this.snapshots.slice(-this.maxSnapshots);
+    }
+    this.persist();
+  }
+  /** Restore data from a snapshot at the given index. Returns undefined if index is invalid or data is corrupt. */
+  restore(index) {
+    const snapshot = this.snapshots[index];
+    if (!snapshot) return void 0;
+    try {
+      return JSON.parse(snapshot.data);
+    } catch {
+      return void 0;
+    }
+  }
+  /** List available snapshots (metadata only, no data payload). */
+  list() {
+    return this.snapshots.map(({ timestamp, label }) => ({ timestamp, label }));
+  }
+  /** Clear all snapshots. */
+  clear() {
+    this.snapshots = [];
+    this.persist();
+  }
+  persist() {
+    if (!this.storageKey) return;
+    try {
+      localStorage.setItem(this.storageKey, JSON.stringify(this.snapshots));
+    } catch {
+    }
+  }
+};
+
+// src/polling.ts
+var DEFAULT_INTERVALS = {
+  "slow-2g": 12e4,
+  "2g": 6e4,
+  "3g": 3e4,
+  "4g": 1e4
+};
+var DEFAULT_FALLBACK_MS = 15e3;
+function startPolling(pullFn, getState, intervalMs = 3e4) {
+  const timer = setInterval(() => {
+    const { online, syncing } = getState();
+    if (online && !syncing) pullFn().catch((err) => {
+      console.error("[Starfish] poll failed:", err);
+    });
+  }, intervalMs);
+  return () => clearInterval(timer);
+}
+function startAdaptivePolling(pullFn, getState, options) {
+  let intervalMs;
+  if (options?.intervalMs != null) {
+    intervalMs = options.intervalMs;
+  } else {
+    const intervals = options?.intervals ?? DEFAULT_INTERVALS;
+    let effectiveType;
+    if (typeof navigator !== "undefined" && "connection" in navigator) {
+      effectiveType = navigator.connection.effectiveType;
+    }
+    intervalMs = (effectiveType != null ? intervals[effectiveType] : void 0) ?? DEFAULT_FALLBACK_MS;
+  }
+  let paused = false;
+  const timer = setInterval(() => {
+    if (paused) return;
+    const { online, syncing } = getState();
+    if (online && !syncing) pullFn().catch((err) => {
+      console.error("[Starfish] adaptive poll failed:", err);
+    });
+  }, intervalMs);
+  return {
+    pause: () => {
+      paused = true;
+    },
+    resume: () => {
+      paused = false;
+    },
+    stop: () => clearInterval(timer)
+  };
+}
+
+// src/dedup.ts
+function createDedupFetch(baseFetch = globalThis.fetch.bind(globalThis)) {
+  const inflightGets = /* @__PURE__ */ new Map();
+  return (async (input, init) => {
+    const method = (init?.method ?? "GET").toUpperCase();
+    if (method !== "GET") {
+      return baseFetch(input, init);
+    }
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const existing = inflightGets.get(url);
+    if (existing) {
+      return existing.then((res) => res.clone());
+    }
+    const promise = baseFetch(input, init).then((res) => res).finally(() => {
+      inflightGets.delete(url);
+    });
+    inflightGets.set(url, promise);
+    return promise.then((res) => res.clone());
+  });
+}
+
+// src/config.ts
+async function fetchServerConfig(baseUrl, options) {
+  const url = `${baseUrl.replace(/\/$/, "")}/config`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: options?.headers
+  });
+  if (!res.ok) {
+    throw new Error(`fetchServerConfig: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+
+// src/storage/indexeddb.ts
+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);
+  });
+}
+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;
+        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));
+    }
+  };
+}
+
+// src/export.ts
+function exportData(data, opts) {
+  const format = opts?.format ?? "json";
+  if (format === "json") {
+    return opts?.pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+  }
+  return toCsv(data);
+}
+function importData(raw, format = "json") {
+  if (format === "json") {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Expected a JSON object");
+    }
+    return parsed;
+  }
+  return fromCsv(raw);
+}
+function exportToBlob(data, opts) {
+  const format = opts?.format ?? "json";
+  const content = exportData(data, opts);
+  const mimeType = format === "csv" ? "text/csv;charset=utf-8" : "application/json;charset=utf-8";
+  return new Blob([content], { type: mimeType });
+}
+function toCsv(data) {
+  const keys = Object.keys(data);
+  const header = keys.map(escapeCsvField).join(",");
+  const values = keys.map((k) => {
+    const v = data[k];
+    if (v === null || v === void 0) return "";
+    if (typeof v === "object") return escapeCsvField(JSON.stringify(v));
+    return escapeCsvField(String(v));
+  });
+  return `${header}
+${values.join(",")}`;
+}
+function fromCsv(raw) {
+  const lines = raw.trim().split("\n");
+  if (lines.length < 2) {
+    throw new Error("CSV must have at least a header row and a data row");
+  }
+  const headers = parseCsvLine(lines[0]);
+  const values = parseCsvLine(lines[1]);
+  const result = {};
+  for (let i = 0; i < headers.length; i++) {
+    const key = headers[i];
+    const val = values[i] ?? "";
+    try {
+      result[key] = JSON.parse(val);
+    } catch {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function escapeCsvField(field) {
+  if (field.includes(",") || field.includes('"') || field.includes("\n")) {
+    return `"${field.replace(/"/g, '""')}"`;
+  }
+  return field;
+}
+function parseCsvLine(line) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (ch === '"') {
+        inQuotes = false;
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ",") {
+        result.push(current);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+  }
+  result.push(current);
+  return result;
+}
+
+// src/background-sync.ts
+function isBackgroundSyncSupported() {
+  return typeof navigator !== "undefined" && "serviceWorker" in navigator && "SyncManager" in globalThis;
+}
+async function registerBackgroundSync(opts) {
+  if (!isBackgroundSyncSupported()) return false;
+  const tag = opts?.tag ?? "starfish-sync";
+  try {
+    const registration = await navigator.serviceWorker.ready;
+    await registration.sync.register(tag);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/service-worker.ts
+function isServiceWorkerSupported() {
+  return typeof navigator !== "undefined" && "serviceWorker" in navigator;
+}
+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;
+  }
+}
+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;
+  }
+}
+
+// src/bindings/suspense.ts
+function createSuspenseResource(fetcher) {
+  let status = "pending";
+  let result;
+  let error;
+  let promise = null;
+  function init() {
+    if (promise) return promise;
+    promise = fetcher().then(
+      (value) => {
+        status = "resolved";
+        result = value;
+      },
+      (err) => {
+        status = "rejected";
+        error = err;
+      }
+    );
+    return promise;
+  }
+  return {
+    read() {
+      switch (status) {
+        case "pending":
+          throw init();
+        case "resolved":
+          return result;
+        case "rejected":
+          throw error;
+      }
+    }
+  };
+}
+
+// src/debounced-sync.ts
+var DEFAULT_DELAY_MS = 2e3;
+var DEFAULT_WARN_BYTES = 900 * 1024;
+var DEFAULT_MAX_BYTES = 1024 * 1024;
+function checkPayloadSize(doc, opts) {
+  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;
+}
+function createDebouncedSync(store, options = {}) {
+  const {
+    delayMs = DEFAULT_DELAY_MS,
+    warnBytes = DEFAULT_WARN_BYTES,
+    maxBytes = DEFAULT_MAX_BYTES,
+    serialize,
+    onSizeWarning,
+    onSizeExceeded
+  } = options;
+  let timer = null;
+  function cancel() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function notify() {
+    cancel();
+    timer = setTimeout(() => {
+      timer = null;
+      const current = store.getState().data;
+      const doc = serialize ? serialize(current) : current;
+      if (checkPayloadSize(doc, { warnBytes, maxBytes, onSizeWarning, onSizeExceeded })) return;
+      store.getState().set(() => doc);
+    }, delayMs);
+  }
+  return { notify, cancel };
+}
+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;
+      syncManager.push(doc).catch((err) => {
+        if (onError) {
+          onError(err);
+        } else {
+          console.warn("[starfish] Push failed:", err);
+        }
+      });
+    }, delayMs);
+  }
+  return { notify, cancel };
+}
+
+// src/mobile-lifecycle.ts
+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((err) => {
+          console.error("[Starfish] background flush failed:", err);
+        });
+      }
+    } else if (appState === "active" && pullOnForeground) {
+      const { online, syncing } = store.getState();
+      if (online && !syncing) {
+        store.getState().pull().catch((err) => {
+          console.error("[Starfish] foreground pull failed:", err);
+        });
+      }
+    }
+  });
+  let netUnsub = null;
+  if (deps.netInfo) {
+    netUnsub = deps.netInfo.addEventListener(({ isConnected }) => {
+      store.getState().setOnline(!!isConnected);
+    });
+  }
+  return () => {
+    appSub.remove();
+    netUnsub?.();
+  };
+}
+
+// src/multi-store.ts
+function createMultiStoreSync(options) {
+  const { slices, version, migrations = {} } = options;
+  for (const fromVersion of Object.keys(migrations)) {
+    const v = Number(fromVersion);
+    if (isNaN(v) || v < 1) {
+      throw new Error(`Migration key must be a positive integer, got: "${fromVersion}"`);
+    }
+  }
+  function serialize() {
+    const data = {};
+    for (const key of Object.keys(slices)) {
+      data[key] = slices[key].serialize();
+    }
+    return { version, timestamp: Date.now(), data };
+  }
+  function restore(doc) {
+    if (typeof doc !== "object" || doc === null) {
+      throw new Error("restore: expected a BackupDocument object");
+    }
+    const docVersion = doc.version ?? 1;
+    if (typeof docVersion !== "number" || !Number.isInteger(docVersion) || docVersion < 1) {
+      throw new Error(`restore: invalid document version: ${String(doc.version)}`);
+    }
+    if (docVersion > version) {
+      throw new Error(
+        `restore: document version ${docVersion} is newer than current version ${version}. Update the app to restore this backup.`
+      );
+    }
+    let data = typeof doc.data === "object" && doc.data !== null ? { ...doc.data } : {};
+    for (let v = docVersion; v < version; v++) {
+      const migration = migrations[v];
+      if (!migration) continue;
+      try {
+        data = migration(data);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`restore: migration from version ${v} to ${v + 1} failed: ${msg}`);
+      }
+    }
+    for (const key of Object.keys(slices)) {
+      const sliceData = data[key];
+      if (sliceData !== void 0) {
+        slices[key].restore(sliceData);
+      }
+    }
+  }
+  return { serialize, restore, version };
+}
+
+// src/group-crypto.ts
+import { x25519 } from "@noble/curves/ed25519.js";
+import { getCrypto as getCrypto2, getBase64 as getBase642, IV_BYTES as IV_BYTES2, deriveKey as deriveKey2 } from "@drakkar.software/starfish-protocol";
+function bytesToHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+var ALGO2 = "AES-GCM";
+var GROUP_WRAP_SALT = "starfish-group-wrap";
+var GROUP_WRAP_INFO = "starfish-group-wrap";
+var GROUP_ECDH_DOMAIN = "starfish-group-ecdh";
+var GROUP_DATA_INFO = "starfish-group";
+var GEK_BYTES = 32;
+async function deriveGroupKeyPair(passphrase, userId) {
+  const c = getCrypto2();
+  const enc = new TextEncoder();
+  const input = enc.encode(`${passphrase}:${userId}:${GROUP_ECDH_DOMAIN}`);
+  const hash = await c.subtle.digest("SHA-256", input);
+  const privateKeyBytes = new Uint8Array(hash);
+  const publicKeyBytes = x25519.getPublicKey(privateKeyBytes);
+  return { privateKey: bytesToHex(privateKeyBytes), publicKey: bytesToHex(publicKeyBytes) };
+}
+function generateGroupKey() {
+  const c = getCrypto2();
+  return bytesToHex(c.getRandomValues(new Uint8Array(GEK_BYTES)));
+}
+async function wrapGroupKey(gek, memberPublicKey, wrapperPrivateKey) {
+  const sharedSecret = x25519.getSharedSecret(hexToBytes(wrapperPrivateKey), hexToBytes(memberPublicKey));
+  const wrappingKey = await deriveKey2(bytesToHex(sharedSecret), GROUP_WRAP_SALT, GROUP_WRAP_INFO);
+  const c = getCrypto2();
+  const b64 = getBase642();
+  const iv = c.getRandomValues(new Uint8Array(IV_BYTES2));
+  const encrypted = await c.subtle.encrypt({ name: ALGO2, iv }, wrappingKey, hexToBytes(gek).buffer);
+  const combined = new Uint8Array(IV_BYTES2 + encrypted.byteLength);
+  combined.set(iv);
+  combined.set(new Uint8Array(encrypted), IV_BYTES2);
+  return b64.encode(combined);
+}
+async function unwrapGroupKey(wrapped, memberPrivateKey, adminPublicKey) {
+  const sharedSecret = x25519.getSharedSecret(hexToBytes(memberPrivateKey), hexToBytes(adminPublicKey));
+  const wrappingKey = await deriveKey2(bytesToHex(sharedSecret), GROUP_WRAP_SALT, GROUP_WRAP_INFO);
+  const b64 = getBase642();
+  const c = getCrypto2();
+  const combined = b64.decode(wrapped);
+  const iv = combined.slice(0, IV_BYTES2);
+  const ciphertext = combined.slice(IV_BYTES2);
+  try {
+    const decrypted = await c.subtle.decrypt({ name: ALGO2, iv }, wrappingKey, ciphertext);
+    return bytesToHex(new Uint8Array(decrypted));
+  } catch {
+    throw new Error("Failed to unwrap group key: decryption failed (wrong keys or corrupted data)");
+  }
+}
+async function createGroupKeyring(adminKeyPair, members, gek) {
+  const resolvedGek = gek ?? generateGroupKey();
+  const wrappedKeys = {};
+  for (const [memberId, memberPublicKey] of Object.entries(members)) {
+    wrappedKeys[memberId] = await wrapGroupKey(resolvedGek, memberPublicKey, adminKeyPair.privateKey);
+  }
+  const keyring = {
+    currentEpoch: 1,
+    epochs: {
+      "1": { adminPublicKey: adminKeyPair.publicKey, wrappedKeys }
+    }
+  };
+  return { keyring, gek: resolvedGek };
+}
+async function addGroupMember(keyring, adminKeyPair, currentGek, newMemberId, newMemberPublicKey) {
+  const epochKey = String(keyring.currentEpoch);
+  const epochKeyring = keyring.epochs[epochKey];
+  if (!epochKeyring) throw new Error(`Epoch ${keyring.currentEpoch} not found in keyring`);
+  if (epochKeyring.adminPublicKey !== adminKeyPair.publicKey) {
+    throw new Error(`Provided key pair does not match the admin public key stored in epoch ${keyring.currentEpoch}`);
+  }
+  const wrapped = await wrapGroupKey(currentGek, newMemberPublicKey, adminKeyPair.privateKey);
+  return {
+    ...keyring,
+    epochs: {
+      ...keyring.epochs,
+      [epochKey]: {
+        ...epochKeyring,
+        wrappedKeys: { ...epochKeyring.wrappedKeys, [newMemberId]: wrapped }
+      }
+    }
+  };
+}
+async function rotateGroupKey(keyring, adminKeyPair, remainingMembers, newGek) {
+  const epochKey = String(keyring.currentEpoch);
+  const epochKeyring = keyring.epochs[epochKey];
+  if (epochKeyring && epochKeyring.adminPublicKey !== adminKeyPair.publicKey) {
+    throw new Error(
+      `Provided key pair does not match the admin public key stored in epoch ${keyring.currentEpoch}`
+    );
+  }
+  const resolvedGek = newGek ?? generateGroupKey();
+  const newEpoch = keyring.currentEpoch + 1;
+  const wrappedKeys = {};
+  for (const [memberId, memberPublicKey] of Object.entries(remainingMembers)) {
+    wrappedKeys[memberId] = await wrapGroupKey(resolvedGek, memberPublicKey, adminKeyPair.privateKey);
+  }
+  const newKeyring = {
+    currentEpoch: newEpoch,
+    epochs: {
+      ...keyring.epochs,
+      [String(newEpoch)]: { adminPublicKey: adminKeyPair.publicKey, wrappedKeys }
+    }
+  };
+  return { keyring: newKeyring, gek: resolvedGek };
+}
+async function createGroupEncryptor(keyring, myIdentity, myPrivateKey) {
+  const epochEncryptors = /* @__PURE__ */ new Map();
+  for (const [epochStr, epochKeyring] of Object.entries(keyring.epochs)) {
+    const epoch = parseInt(epochStr, 10);
+    const wrapped = epochKeyring.wrappedKeys[myIdentity];
+    if (!wrapped) continue;
+    const gek = await unwrapGroupKey(wrapped, myPrivateKey, epochKeyring.adminPublicKey);
+    epochEncryptors.set(epoch, createEncryptor(gek, `epoch-${epoch}`, GROUP_DATA_INFO));
+  }
+  const currentEpoch = keyring.currentEpoch;
+  const currentEncryptor = epochEncryptors.get(currentEpoch);
+  if (!currentEncryptor) {
+    throw new Error(
+      `No wrapped key found for identity "${myIdentity}" in epoch ${currentEpoch}. Ensure the admin has added this member to the keyring.`
+    );
+  }
+  return {
+    async encrypt(data) {
+      const encrypted = await currentEncryptor.encrypt(data);
+      return { ...encrypted, _epoch: currentEpoch };
+    },
+    async decrypt(wrapper) {
+      const epoch = typeof wrapper._epoch === "number" ? wrapper._epoch : currentEpoch;
+      const encryptor = epochEncryptors.get(epoch);
+      if (!encryptor) {
+        throw new Error(
+          `No key available for epoch ${epoch}. This document was encrypted in a different epoch. Ensure your keyring is up to date.`
+        );
+      }
+      return encryptor.decrypt(wrapper);
+    }
+  };
+}
+
+// src/entitlements.ts
+async function pullEntitlements(client, userId, opts) {
+  const path = (opts?.path ?? "/pull/users/{userId}/entitlements").replace("{userId}", userId);
+  const field = opts?.field ?? "features";
+  try {
+    const result = await client.pull(path);
+    const list = result.data?.[field];
+    if (!Array.isArray(list)) return [];
+    return list.filter((s) => typeof s === "string");
+  } catch (err) {
+    if (err instanceof StarfishHttpError && err.status === 404) return [];
+    throw err;
+  }
+}
+export {
+  ConflictError,
+  ENCRYPTED_KEY,
+  SnapshotHistory,
+  StarfishClient,
+  StarfishHttpError,
+  SyncManager,
+  ValidationError,
+  addGroupMember,
+  classifyError,
+  computeHash,
+  configurePlatform,
+  consoleSyncLogger,
+  createDebouncedPush,
+  createDebouncedSync,
+  createDedupFetch,
+  createEncryptor,
+  createGroupEncryptor,
+  createGroupKeyring,
+  createIndexedDBStorage,
+  createMetricsCollector,
+  createMigrator,
+  createMobileLifecycle,
+  createMultiStoreSync,
+  createSchemaValidator,
+  createSoftDeleteResolver,
+  createSuspenseResource,
+  createUnionMerge,
+  deriveGroupKeyPair,
+  exportData,
+  exportToBlob,
+  fetchServerConfig,
+  generateGroupKey,
+  importData,
+  isBackgroundSyncSupported,
+  isServiceWorkerSupported,
+  noopSyncLogger,
+  pruneTombstones,
+  pullEntitlements,
+  registerBackgroundSync,
+  registerServiceWorker,
+  rotateGroupKey,
+  stableStringify2 as stableStringify,
+  startAdaptivePolling,
+  startPolling,
+  timestampWinner,
+  unregisterServiceWorkers,
+  unwrapGroupKey,
+  withConflictMeta,
+  wrapGroupKey
+};
+//# sourceMappingURL=index.js.map