@fleox-agent-crm/agentcrm 0.3.2 → 0.4.0

package/dist/admin/index.html

@@ -120,7 +120,7 @@
         }
       }
     </script>
-    <script type="module" crossorigin src="./assets/index-BpaxrJx9.js"></script>
+    <script type="module" crossorigin src="./assets/index-0ejjkW0z.js"></script>
     <link rel="stylesheet" crossorigin href="./assets/index-TcjySLVg.css">
   </head>
   <body>

package/dist/agent/agentcrm.mjs

@@ -142,7 +142,7 @@ const output = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   toCliError
 }, Symbol.toStringTag, { value: "Module" }));
 const name = "@fleox-agent-crm/agentcrm";
-const version = "0.3.2";
+const version = "0.4.0";
 const type = "module";
 const description = "The static CRM your AI agent can run: a Twenty / HubSpot-style CRM that runs entirely in the browser or headless through the agentcrm CLI, with data on storage you own.";
 const license = "SEE LICENSE IN LICENSE";
@@ -608,7 +608,7 @@ async function openStore(runtime, opts) {
   }
   if (runtime.backend === "journal") {
     if (!opts.dataTarget) throw new CliError("internal", "journal store without a data location");
-    const { buildConnector } = await import("./chunks/hosting-Dnn1k3cV.mjs");
+    const { buildConnector } = await import("./chunks/hosting-C_UDyMkm.mjs");
     const { createJournalStore } = await import("./chunks/index-B-4W0-P4.mjs");
     const { publicSettings, secrets } = rc.splitSecretSettings(opts.dataTarget.settings);
     rc.setConnectorSecrets(runtime, secrets);
@@ -629,8 +629,9 @@ async function openStore(runtime, opts) {
     const { prepareFirebaseSession: prepareFirebaseSession2 } = await Promise.resolve().then(() => firebaseSession);
     await prepareFirebaseSession2(opts.account, runtime.firebase, opts.secrets.email);
   }
-  const { createDataStore } = await import("./chunks/index-rut-KC39.mjs");
-  return createDataStore(runtime, { secrets: opts.secrets ?? {}, passphrase: opts.passphrase ?? null, clientId: cliClientId() });
+  const { createDataStore } = await import("./chunks/index-DWecFbTi.mjs");
+  const firebaseCache = runtime.backend === "firebase" ? (await import("./chunks/firebaseCache-sK4jA0ru.mjs")).fileFirebaseCache() : void 0;
+  return createDataStore(runtime, { secrets: opts.secrets ?? {}, passphrase: opts.passphrase ?? null, clientId: cliClientId(), firebaseCache });
 }
 function siteSecrets(site) {
   const passphrase = site.credentials.passphrase ? requireCredential(site.credentials.passphrase).values.passphrase : null;
@@ -707,14 +708,14 @@ async function openSession(alias, opts = {}) {
       })();
       if (target) {
         const { setStorageConfigSource, registerStorageConnector } = await import("./chunks/registry-DijAKZ24.mjs").then((n) => n.r);
-        const { buildConnector } = await import("./chunks/hosting-Dnn1k3cV.mjs");
+        const { buildConnector } = await import("./chunks/hosting-C_UDyMkm.mjs");
         if (target.connectorId === "local-folder") registerStorageConnector({ id: "local-folder", create: (s) => buildConnector({ connectorId: "local-folder", settings: s }) });
         setStorageConfigSource(async () => target);
       }
     }
     {
       const forms = await import("./chunks/forms-BfuWaQjA.mjs");
-      const { buildConnector } = await import("./chunks/hosting-Dnn1k3cV.mjs");
+      const { buildConnector } = await import("./chunks/hosting-C_UDyMkm.mjs");
       forms.setInboxSourceResolver((_ctx, form) => {
         if (form.inbox.kind !== "s3") return null;
         const settings = form.inbox.settings ?? {};
@@ -1713,7 +1714,7 @@ function filePersistence(account, email) {
   };
 }
 async function prepareFirebaseSession(account, options, email) {
-  const { getFirebaseApp } = await import("./chunks/sdk-CYgNyuoK.mjs");
+  const { getFirebaseApp } = await import("./chunks/sdk-NYUHv7WG.mjs");
   const { initializeAuth } = await import("./chunks/index-Dio0aBWA.mjs").then((n) => n.x);
   try {
     initializeAuth(getFirebaseApp(options), { persistence: filePersistence(account, email.trim().toLowerCase()) });
@@ -2595,7 +2596,7 @@ const formsCommand = {
           const target = s.hostingTarget();
           if (!target) usage(`${s.site.alias} has no hosting to publish the form to.`);
           if (options.yes !== true) return { needsConfirmation: true, plan: { form: id, path: built.path, hosting: s.site.hosting?.type, bytes: built.html.length } };
-          const { buildConnector } = await import("./chunks/hosting-Dnn1k3cV.mjs");
+          const { buildConnector } = await import("./chunks/hosting-C_UDyMkm.mjs");
           const connector = buildConnector(target);
           const siteUrl = typeof s.site.hosting?.settings.siteUrl === "string" ? s.site.hosting.settings.siteUrl.replace(/\/+$/, "") : "";
           return forms.publishForm(s.ctx, id, { put: (input) => connector.put(input), publicUrl: async (path) => siteUrl ? `${siteUrl}/${path}` : connector.publicUrl(path) });
@@ -2740,7 +2741,7 @@ const deployAdminCommand = {
     const sites = options.all === true ? listSites().sites.filter((s) => s.hosting) : [resolveSite(strOpt(options, "site"))];
     if (!sites.length) throw new CliError("no-sites", "No registered CRM has a hosting.");
     installBrowserEnv();
-    const { adminOps, applyOps, buildConnector } = await import("./chunks/hosting-Dnn1k3cV.mjs");
+    const { adminOps, applyOps, buildConnector } = await import("./chunks/hosting-C_UDyMkm.mjs");
     const { hostingTargetOf: hostingTargetOf2 } = await Promise.resolve().then(() => session);
     const plans = [];
     for (const site of sites) {
@@ -2844,7 +2845,7 @@ async function runDoctor(site, opts = {}) {
   installBrowserEnv();
   try {
     if (site.runtime.backend === "journal" && site.runtime.journal.connectorId === "git-pages") {
-      const { probeTarget } = await import("./chunks/install-BBTA4nMm.mjs");
+      const { probeTarget } = await import("./chunks/install-BLNflFes.mjs");
       const { dataTargetOf: dataTargetOf2 } = await Promise.resolve().then(() => session);
       const probe = await probeTarget(dataTargetOf2(site), { requireSiteUrl: false, requirePrivate: true });
       add(probe.ok ? { id: "data-repo", status: "ok", message: probe.detail } : { id: "data-repo", status: "fail", message: probe.detail, fix: "Make the data repository private and check the token's Contents permission." });
@@ -2854,6 +2855,15 @@ async function runDoctor(site, opts = {}) {
     try {
       const store = session$1.store;
       add({ id: "data-access", status: "ok", message: `Dataset opened (${store.kind}${session$1.user ? `, acting as ${session$1.user.email} (${session$1.user.role})` : ""}).` });
+      const { isFirebaseStore } = await import("./chunks/firebase-Bknru2pE.mjs");
+      const load2 = isFirebaseStore(store) ? store.lastLoad() : null;
+      if (load2) {
+        add({
+          id: "firestore-reads",
+          status: "ok",
+          message: load2.mode === "incremental" ? `Loaded from the local cache + changes: ${load2.reads} Firestore reads.` : `Full read: ${load2.reads} Firestore reads (the next commands read only what changed).`
+        });
+      }
       const { usersOf, objectsOf, pipelinesOf, settingsDoc, recordsOf } = await import("./chunks/store-5gqRSKXg.mjs");
       const missing = [];
       for (const id of ["companies", "people", "deals"]) if (!objectsOf(store).some((o) => o.id === id)) missing.push(`object ${id}`);
@@ -3004,7 +3014,7 @@ const installCommand = {
     const { resolvePlan } = await import("./chunks/plan-BmTat6-T.mjs");
     const plan = resolvePlan(readPlan(planPath));
     if (getSite(plan.alias)) throw new CliError("site-exists", `A site named "${plan.alias}" is already registered.`, "Use another alias, or `agentcrm site forget` it first.");
-    const { checkPlan, runInstall } = await import("./chunks/install-BBTA4nMm.mjs");
+    const { checkPlan, runInstall } = await import("./chunks/install-BLNflFes.mjs");
     io.err("Checking access…");
     const checks = await checkPlan(plan);
     const summary = {
@@ -3360,7 +3370,7 @@ const optionsCommand = {
   async run({ io, options }) {
     const rulesEmail = strOpt(options, "firebase-rules");
     if (rulesEmail) {
-      const { buildFirestoreRules } = await import("./chunks/firebaseRules-iori-s7U.mjs");
+      const { buildFirestoreRules } = await import("./chunks/firebaseRules-Jq85MBBN.mjs");
       const rules = buildFirestoreRules({ adminEmail: rulesEmail });
       printResult(io, { email: rulesEmail, rules, where: "Firebase console → Firestore Database → Rules → paste → Publish (or `firebase deploy --only firestore:rules`)." }, () => rules);
       return;
@@ -4102,14 +4112,17 @@ export {
   findHosting as e,
   findBackend as f,
   getCredential as g,
-  openStore as h,
-  installBrowserEnv as i,
-  distRoot as j,
+  readJsonFile as h,
+  homePath as i,
+  openStore as j,
+  installBrowserEnv as k,
+  distRoot as l,
   nodeImportBundle as n,
   ownPackageRoot as o,
   packageRoot as p,
   readVersionInfo as r,
   setCredential as s,
   toCliError as t,
-  validateAlias as v
+  validateAlias as v,
+  writeJsonFile as w
 };

package/dist/agent/chunks/api-BEl_EKwf.mjs

@@ -0,0 +1,79 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+const DELETE_FIELD = Symbol("deleteField");
+const TS_FIELD = "_ts";
+const DELETIONS_COLLECTION = "deletions";
+const SERVER_TIMESTAMP = Symbol("serverTimestamp");
+let trackedCollections = /* @__PURE__ */ new Set();
+function setTrackedCollections(collections) {
+  trackedCollections = new Set(collections);
+}
+function tombstoneId(collection, id) {
+  return `${collection}__${id}`;
+}
+function withChangeTracking(ops) {
+  const out = [];
+  for (const op of ops) {
+    if (!trackedCollections.has(op.collection)) {
+      out.push(op);
+    } else if (op.type === "delete") {
+      out.push(op, { type: "set", collection: DELETIONS_COLLECTION, id: tombstoneId(op.collection, op.id), data: { collection: op.collection, id: op.id, [TS_FIELD]: SERVER_TIMESTAMP } });
+    } else {
+      out.push({ ...op, data: { ...op.data, [TS_FIELD]: SERVER_TIMESTAMP } });
+    }
+  }
+  return out;
+}
+function splitTs(id, raw) {
+  const { [TS_FIELD]: ts, ...data } = raw;
+  return typeof ts === "number" ? { id, data, ts } : { id, data };
+}
+function errorCode(err) {
+  return err?.code ?? "";
+}
+function isPermissionDenied(err) {
+  const code = errorCode(err);
+  return code === "permission-denied" || code === "firestore/permission-denied";
+}
+const FIRESTORE_BATCH_LIMIT = 500;
+function chunkForCommit(ops) {
+  const out = [];
+  let part = [];
+  let weight = 0;
+  for (const op of ops) {
+    const w = op.type === "delete" && trackedCollections.has(op.collection) ? 2 : 1;
+    if (weight + w > FIRESTORE_BATCH_LIMIT) {
+      out.push(part);
+      part = [];
+      weight = 0;
+    }
+    part.push(op);
+    weight += w;
+  }
+  if (part.length) out.push(part);
+  return out;
+}
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+export {
+  DELETE_FIELD as D,
+  FIRESTORE_BATCH_LIMIT as F,
+  SERVER_TIMESTAMP as S,
+  TS_FIELD as T,
+  DELETIONS_COLLECTION as a,
+  chunk as b,
+  chunkForCommit as c,
+  splitTs as d,
+  errorCode as e,
+  isPermissionDenied as i,
+  setTrackedCollections as s,
+  tombstoneId as t,
+  withChangeTracking as w
+};

package/dist/agent/chunks/{firebase-BciZWdc6.mjs → firebase-Bknru2pE.mjs}

@@ -7,7 +7,8 @@ const __dirname = __acrmDirname(__filename);
 import "./jsx-runtime-Ca2uwGDr.mjs";
 import { r as reactExports } from "./index-Bnmav-Oh.mjs";
 import { c as createStoreCore, p as plainCopy, e as emptySnapshot, n as normalizeDoc } from "./core-Dy7vY9H6.mjs";
-import { i as isPermissionDenied, D as DELETE_FIELD, e as errorCode, c as chunk, F as FIRESTORE_BATCH_LIMIT } from "./api-Dwb4xz1k.mjs";
+import { i as isPermissionDenied, D as DELETE_FIELD, a as DELETIONS_COLLECTION, e as errorCode, c as chunkForCommit, s as setTrackedCollections } from "./api-BEl_EKwf.mjs";
+import { F, S, T, b, d, t, w } from "./api-BEl_EKwf.mjs";
 import { w as withFileStore, F as FileStoreUnavailableError } from "./index-RCmo-uld.mjs";
 import { COLLECTIONS } from "./types-BOy9PUl7.mjs";
 import { a as assertFileId } from "./ids-u-noYcy5.mjs";
@@ -17,10 +18,70 @@ function registerAuthAdapter(backend, adapter) {
   adapters.set(backend, adapter);
 }
 reactExports.createContext(null);
+const FIREBASE_CACHE_VERSION = 1;
+const FULL_RELOAD_MS = 7 * 24 * 3600 * 1e3;
+function firebaseCacheKey(projectId, uid) {
+  return `${projectId}:${uid}`;
+}
+function isUsableCache(state, now) {
+  return !!state && state.v === FIREBASE_CACHE_VERSION && typeof state.cursor === "number" && now - state.fullAt < FULL_RELOAD_MS;
+}
+const DB_NAME = "agentcrm-firebase-cache";
+const STORE = "datasets";
+function openDb() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, 1);
+    req.onupgradeneeded = () => req.result.createObjectStore(STORE);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function run(mode, fn) {
+  return openDb().then(
+    (db) => new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE, mode);
+      const req = fn(tx.objectStore(STORE));
+      tx.oncomplete = () => {
+        db.close();
+        resolve(req.result);
+      };
+      tx.onerror = () => {
+        db.close();
+        reject(tx.error);
+      };
+    })
+  );
+}
+function indexedDbFirebaseCache() {
+  if (typeof indexedDB === "undefined") return null;
+  return {
+    async read(key) {
+      try {
+        return await run("readonly", (s) => s.get(key)) ?? null;
+      } catch {
+        return null;
+      }
+    },
+    async write(key, state) {
+      try {
+        await run("readwrite", (s) => s.put(state, key));
+      } catch {
+      }
+    },
+    async clear(key) {
+      try {
+        await run("readwrite", (s) => s.delete(key));
+      } catch {
+      }
+    }
+  };
+}
 const INVITES_COLLECTION = "invites";
 const EXTENSION_CHUNKS_COLLECTION = "extensionChunks";
 const EXTENSION_CHUNK_CHARS = 3e5;
 const INBOX_COLLECTION = "inbox";
+const TRACKED = [...COLLECTIONS, EXTENSION_CHUNKS_COLLECTION];
+setTrackedCollections(TRACKED);
 const ROLES = ["admin", "member", "viewer"];
 class FirebaseAccessError extends Error {
   constructor(reason, message, email) {
@@ -37,8 +98,8 @@ function toData(doc) {
   const { id: _id, ...rest } = plainCopy(doc);
   return rest;
 }
-function fromData(d) {
-  return normalizeDoc({ ...d.data, id: d.id });
+function fromData(d2) {
+  return normalizeDoc({ ...d2.data, id: d2.id });
 }
 function isRole(v) {
   return typeof v === "string" && ROLES.includes(v);
@@ -103,18 +164,18 @@ function assembleExtensionDocs(docs, chunks) {
     const ext = String(c.data.ext ?? "");
     byExt.set(ext, [...byExt.get(ext) ?? [], c]);
   }
-  return docs.map((d) => {
-    const counts = d.data.chunks;
-    if (!counts || typeof counts !== "object") return d;
+  return docs.map((d2) => {
+    const counts = d2.data.chunks;
+    if (!counts || typeof counts !== "object") return d2;
     const files = {};
-    const parts = byExt.get(d.id) ?? [];
+    const parts = byExt.get(d2.id) ?? [];
     for (const [file, n] of Object.entries(counts)) {
-      const pieces = parts.filter((p) => p.data.file === file).sort((a, b) => Number(a.data.index) - Number(b.data.index));
+      const pieces = parts.filter((p) => p.data.file === file).sort((a, b2) => Number(a.data.index) - Number(b2.data.index));
       if (pieces.length !== n) continue;
       files[file] = pieces.map((p) => String(p.data.data ?? "")).join("");
     }
-    const { chunks: _chunks, ...rest } = d.data;
-    return { id: d.id, data: { ...rest, files } };
+    const { chunks: _chunks, ...rest } = d2.data;
+    return { id: d2.id, data: { ...rest, files } };
   });
 }
 function mutationOps(mutations, before) {
@@ -187,8 +248,8 @@ function createFirebaseStoreWith(opts) {
   function buildSnapshot(raw, chunks) {
     const s = emptySnapshot();
     for (const c of COLLECTIONS) {
-      const docs = c === "extensions" ? assembleExtensionDocs(raw.get(c) ?? [], chunks) : raw.get(c) ?? [];
-      for (const d of docs) s[c].set(d.id, fromData(d));
+      const docs2 = c === "extensions" ? assembleExtensionDocs(raw.get(c) ?? [], chunks) : raw.get(c) ?? [];
+      for (const d2 of docs2) s[c].set(d2.id, fromData(d2));
     }
     rawUsers = new Map(s.users);
     for (const u of [...s.users.values()]) {
@@ -259,10 +320,21 @@ function createFirebaseStoreWith(opts) {
       return null;
     }
   }
+  function getIdentity() {
+    if (!identityPromise) {
+      identityPromise = resolveIdentity().then((id) => {
+        currentIdentity = id;
+        if (!id) identityPromise = null;
+        return id;
+      });
+    }
+    return identityPromise;
+  }
   async function persist(mutations, before, after) {
     const ops = mutationOps(mutations, before);
+    if (!currentIdentity && mutations.some((m) => m.collection === "users")) await getIdentity();
     if (currentIdentity?.role === "admin") ops.push(...inviteOps(mutations, (id) => before.users.get(id) ?? rawUsers.get(id), after));
-    for (const part of chunk(ops, FIRESTORE_BATCH_LIMIT)) await api.commit(part);
+    for (const part of chunkForCommit(ops)) await api.commit(part);
     for (const m of mutations) {
       if (m.collection !== "users") continue;
       const id = m.op === "set" ? m.doc.id : m.id;
@@ -271,63 +343,145 @@ function createFirebaseStoreWith(opts) {
       else rawUsers.delete(id);
     }
   }
+  const docs = new Map(TRACKED.map((c) => [c, /* @__PURE__ */ new Map()]));
+  let cursor = 0;
+  let fullAt = 0;
+  let cacheKey = null;
+  let loadInfo = null;
+  let markLoaded = () => void 0;
+  const loadedOnce = new Promise((resolve) => markLoaded = resolve);
+  let saveTimer = null;
+  const advance = (d2) => {
+    if (typeof d2.ts === "number" && d2.ts > cursor) cursor = d2.ts;
+  };
+  function upsert(c, list) {
+    const m = docs.get(c);
+    for (const d2 of list) {
+      m.set(d2.id, d2);
+      advance(d2);
+    }
+  }
+  function applyTombstones(list) {
+    for (const t2 of list) {
+      advance(t2);
+      const c = t2.data.collection;
+      const id = t2.data.id;
+      if (typeof c === "string" && typeof id === "string") docs.get(c)?.delete(id);
+    }
+  }
+  function snapshotFromDocsMap() {
+    const raw = new Map(COLLECTIONS.map((c) => [c, [...docs.get(c).values()]]));
+    return buildSnapshot(raw, [...docs.get(EXTENSION_CHUNKS_COLLECTION).values()]);
+  }
+  async function saveCache() {
+    if (!opts.cache || !cacheKey) return;
+    const collections = Object.fromEntries(TRACKED.map((c) => [c, [...docs.get(c).values()]]));
+    await opts.cache.write(cacheKey, { v: FIREBASE_CACHE_VERSION, cursor, fullAt, collections });
+  }
+  function scheduleSave() {
+    if (saveTimer) return;
+    saveTimer = setTimeout(() => {
+      saveTimer = null;
+      void saveCache();
+    }, 1e3);
+    saveTimer.unref?.();
+  }
+  async function readSince(c, since) {
+    try {
+      return await api.listSince(c, since);
+    } catch (err) {
+      if (isPermissionDenied(err)) return null;
+      throw err;
+    }
+  }
   const core = createStoreCore({
     kind: "firebase",
     async load() {
-      const raw = /* @__PURE__ */ new Map();
-      let chunks = [];
-      await Promise.all([...COLLECTIONS.map(async (c) => raw.set(c, await readCollection(c))), readCollection(EXTENSION_CHUNKS_COLLECTION).then((d) => chunks = d)]);
-      const snap = buildSnapshot(raw, chunks);
+      const readsBefore = api.readCount();
+      const user = await api.auth.currentUser();
+      cacheKey = opts.cache && opts.projectId && user ? firebaseCacheKey(opts.projectId, user.uid) : null;
+      const cached = cacheKey ? await opts.cache.read(cacheKey) : null;
+      let mode = "full";
+      if (isUsableCache(cached, now())) {
+        mode = "incremental";
+        cursor = cached.cursor;
+        fullAt = cached.fullAt;
+        for (const c of TRACKED) docs.set(c, new Map((cached.collections[c] ?? []).map((d2) => [d2.id, d2])));
+        const since = cursor;
+        const changed = await Promise.all(TRACKED.map(async (c) => [c, await readSince(c, since)]));
+        for (const [c, list] of changed) {
+          if (list === null) docs.set(c, /* @__PURE__ */ new Map());
+          else upsert(c, list);
+        }
+        applyTombstones(await readSince(DELETIONS_COLLECTION, since) ?? []);
+      } else {
+        cursor = 0;
+        const all = await Promise.all(TRACKED.map(async (c) => [c, await readCollection(c)]));
+        for (const [c, list] of all) {
+          docs.set(c, /* @__PURE__ */ new Map());
+          upsert(c, list);
+        }
+        fullAt = now();
+      }
+      loadInfo = { mode, reads: api.readCount() - readsBefore };
+      globalThis.__AGENTCRM_FIRESTORE__ = { ...loadInfo, cursor, totalReads: api.readCount };
+      await saveCache();
+      markLoaded();
+      const snap = snapshotFromDocsMap();
       scheduleReconcile();
       return snap;
     },
     persist: (mutations, before, after) => persist(mutations, before, after),
+    // Live updates: one listener per collection on documents written after
+    // the load's cursor — only changes are read (and billed).
     watch(onRemote) {
-      const raw = /* @__PURE__ */ new Map();
-      let chunks = null;
+      let offs = [];
+      let stopped = false;
       const emit = () => {
-        if (raw.size < COLLECTIONS.length || chunks === null) return;
-        onRemote(buildSnapshot(raw, chunks));
+        onRemote(snapshotFromDocsMap());
         scheduleReconcile();
+        scheduleSave();
+      };
+      void loadedOnce.then(() => {
+        if (stopped) return;
+        const since = cursor;
+        offs = TRACKED.map(
+          (c) => api.watchSince(
+            c,
+            since,
+            (ch) => {
+              upsert(c, ch.upserts);
+              for (const id of ch.removed) docs.get(c).delete(id);
+              emit();
+            },
+            (err) => {
+              if (isPermissionDenied(err)) {
+                docs.set(c, /* @__PURE__ */ new Map());
+                emit();
+              } else console.warn(`[firebase] live updates of ${c} stopped:`, err);
+            }
+          )
+        );
+        offs.push(
+          api.watchSince(
+            DELETIONS_COLLECTION,
+            since,
+            (ch) => {
+              applyTombstones(ch.upserts);
+              emit();
+            },
+            (err) => {
+              if (!isPermissionDenied(err)) console.warn("[firebase] live deletions stopped:", err);
+            }
+          )
+        );
+      });
+      return () => {
+        stopped = true;
+        offs.forEach((off) => off());
       };
-      const offs = COLLECTIONS.map(
-        (c) => api.watchCollection(
-          c,
-          (docs) => {
-            raw.set(c, docs);
-            emit();
-          },
-          (err) => {
-            if (isPermissionDenied(err)) raw.set(c, []);
-            else console.warn(`[firebase] live updates of ${c} stopped:`, err);
-          }
-        )
-      );
-      offs.push(
-        api.watchCollection(
-          EXTENSION_CHUNKS_COLLECTION,
-          (docs) => {
-            chunks = docs;
-            emit();
-          },
-          (err) => {
-            if (isPermissionDenied(err)) chunks = [];
-            else console.warn("[firebase] live updates of extension chunks stopped:", err);
-          }
-        )
-      );
-      return () => offs.forEach((off) => off());
-    },
-    identity() {
-      if (!identityPromise) {
-        identityPromise = resolveIdentity().then((id) => {
-          currentIdentity = id;
-          if (!id) identityPromise = null;
-          return id;
-        });
-      }
-      return identityPromise;
     },
+    identity: getIdentity,
     close() {
       offAuth();
     }
@@ -381,9 +535,23 @@ function createFirebaseStoreWith(opts) {
       console.warn("[firebase] could not link invited users:", err);
     }
   }
+  const closeCore = core.close?.bind(core);
+  core.close = () => {
+    if (saveTimer) {
+      clearTimeout(saveTimer);
+      saveTimer = null;
+      void saveCache();
+    }
+    closeCore?.();
+  };
   withFileStore(core, firebaseFileStore(api));
+  activeCacheClear = async () => {
+    if (opts.cache && cacheKey) await opts.cache.clear(cacheKey);
+  };
   return Object.assign(core, {
     api,
+    readCount: () => api.readCount(),
+    lastLoad: () => loadInfo,
     accessError: () => lastAccessError,
     resetSession() {
       identityPromise = null;
@@ -397,15 +565,17 @@ function firebaseApiFor(config) {
   const key = config.firebase.projectId ?? "default";
   let api = apis.get(key);
   if (!api) {
-    api = import("./sdk-CYgNyuoK.mjs").then((m) => m.createSdkFirebaseApi(config.firebase));
+    api = import("./sdk-NYUHv7WG.mjs").then((m) => m.createSdkFirebaseApi(config.firebase));
     apis.set(key, api);
     api.catch(() => apis.delete(key));
   }
   return api;
 }
 let activeApi = null;
+let activeCacheClear = null;
 registerAuthAdapter("firebase", {
   async signOut() {
+    await activeCacheClear?.();
     await activeApi?.auth.signOut();
   }
 });
@@ -449,21 +619,26 @@ async function createFirebaseStore(config, opts = {}) {
   const api = await firebaseApiFor(cfg);
   activeApi = api;
   await signInWithSecrets(api, opts.secrets);
-  return createFirebaseStoreWith({ api });
+  const cache = opts.firebaseCache === void 0 ? indexedDbFirebaseCache() : opts.firebaseCache;
+  return createFirebaseStoreWith({ api, cache, projectId: cfg.firebase.projectId });
 }
 export {
   DELETE_FIELD,
+  DELETIONS_COLLECTION,
   EXTENSION_CHUNKS_COLLECTION,
   EXTENSION_CHUNK_CHARS,
-  FIRESTORE_BATCH_LIMIT,
+  F as FIRESTORE_BATCH_LIMIT,
   FirebaseAccessError,
   INBOX_COLLECTION,
   INVITES_COLLECTION,
+  S as SERVER_TIMESTAMP,
   STORAGE_FILES_DIR,
   STORAGE_NOT_ENABLED,
+  T as TS_FIELD,
   assembleExtensionDocs,
   checkFirebaseAccess,
-  chunk,
+  b as chunk,
+  chunkForCommit,
   createFirebaseStore,
   createFirebaseStoreWith,
   emailKey,
@@ -474,5 +649,9 @@ export {
   isFirebaseStore,
   isPermissionDenied,
   mutationOps,
-  signInWithSecrets
+  setTrackedCollections,
+  signInWithSecrets,
+  d as splitTs,
+  t as tombstoneId,
+  w as withChangeTracking
 };