@fleox-agent-crm/agentcrm 0.3.3 → 0.5.0

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/{automations-DwWruxmu.mjs → automations-BqY8EwfJ.mjs}

@@ -8,16 +8,16 @@ import { toIsoDate, recordLabel, formatFieldValue, normalizeEmail } from "./fiel
 import { n as newId } from "./ids-CvnmrMJX.mjs";
 import { plugins } from "./pluginRegistry-DyHtlkcr.mjs";
 import { r as resolveField, m as matchesFilter } from "./query-C5nJB_3C.mjs";
-import { queryContext, setRecordOwner, updateRecord } from "./records-DcHFelq5.mjs";
+import { queryContext, setRecordOwner, updateRecord } from "./records-CCTxxMWF.mjs";
 import { getSettings } from "./settings-Di8nzNEL.mjs";
 import { userOf, automationRunsOf, asDoc, requireRecord, requireObject, automationsOf, objectOf, recordsOf, thaw, recordOf, usersOf } from "./store-5gqRSKXg.mjs";
 import { F as FILTER_OPS } from "../agentcrm.mjs";
 import { lastActivityAt, addNote, createTask } from "./activities-Cj_SIOay.mjs";
 import { OpsError, assertCan } from "./context-CxFfqS4D.mjs";
-import { pipelineOfRecord } from "./pipelines-BAKpPk1w.mjs";
+import { pipelineOfRecord } from "./pipelines-DiJ2dLqQ.mjs";
 import { getAutomationAction, listAutomationActions } from "./extensionActions-D2HtpQz4.mjs";
 import { registerAutomationAction, subscribeAutomationActions } from "./extensionActions-D2HtpQz4.mjs";
-import "./standardObjects-CheqfDqa.mjs";
+import "./standardObjects-vrmqIVLH.mjs";
 import "./relations-B9TynBmA.mjs";
 import "./runtimeConfig-CCOFg1RM.mjs";
 import "node:util";

package/dist/agent/chunks/{backup-W3CjgkAJ.mjs → backup-CO0EzdF_.mjs}

@@ -7,7 +7,7 @@ const __dirname = __acrmDirname(__filename);
 import { J as JSZip } from "./index-w03ReRs4.mjs";
 import { F as FILE_ID_RE } from "./ids-u-noYcy5.mjs";
 import { assertCan, OpsError } from "./context-CxFfqS4D.mjs";
-import { exportJson, importJson, planImportJson } from "./exportCsv-C6e6XEmB.mjs";
+import { exportJson, importJson, planImportJson } from "./exportCsv-C-fIHLm1.mjs";
 import { filesOf } from "./store-5gqRSKXg.mjs";
 import "./_commonjsHelpers-ClciMIcB.mjs";
 import "stream";
@@ -19,9 +19,9 @@ import "./papaparse-Df7i1dHr.mjs";
 import "./fields-B0bitgmr.mjs";
 import "./query-C5nJB_3C.mjs";
 import "./types-BOy9PUl7.mjs";
-import "./records-DcHFelq5.mjs";
+import "./records-CCTxxMWF.mjs";
 import "./ids-CvnmrMJX.mjs";
-import "./standardObjects-CheqfDqa.mjs";
+import "./standardObjects-vrmqIVLH.mjs";
 import "./relations-B9TynBmA.mjs";
 const BACKUP_DATA_FILE = "data.json";
 const BACKUP_FILES_DIR = "files/";

package/dist/agent/chunks/{compact-BGHI92tm.mjs → compact-qF5t42ko.mjs}

@@ -6,8 +6,8 @@ const __filename = __acrmPath(import.meta.url);
 const __dirname = __acrmDirname(__filename);
 import { assertCan } from "./context-CxFfqS4D.mjs";
 import { b as fileCleanupMutations } from "./relations-B9TynBmA.mjs";
-import { purgeFiles } from "./files-D1daDgY0.mjs";
-import { hardDeleteMutations } from "./records-DcHFelq5.mjs";
+import { purgeFiles } from "./files-C4YONVqQ.mjs";
+import { hardDeleteMutations } from "./records-CCTxxMWF.mjs";
 import { recordsOf, activitiesOf, automationRunsOf } from "./store-5gqRSKXg.mjs";
 import "./pluginRegistry-DyHtlkcr.mjs";
 import "./fields-B0bitgmr.mjs";
@@ -27,7 +27,7 @@ import "node:crypto";
 import "node:os";
 import "node:child_process";
 import "node:http";
-import "./standardObjects-CheqfDqa.mjs";
+import "./standardObjects-vrmqIVLH.mjs";
 async function compactData(ctx, opts = {}) {
   assertCan(ctx, "compact");
   const cutoff = ctx.now() - (opts.olderThanDays ?? 0) * 864e5;

package/dist/agent/chunks/{exportCsv-C6e6XEmB.mjs → exportCsv-C-fIHLm1.mjs}

@@ -9,13 +9,13 @@ import { formatAddress, formatFieldValue } from "./fields-B0bitgmr.mjs";
 import { a as applySorts, b as applyFilters, r as resolveField, g as getRecordValue } from "./query-C5nJB_3C.mjs";
 import { COLLECTIONS } from "./types-BOy9PUl7.mjs";
 import { assertCan, OpsError } from "./context-CxFfqS4D.mjs";
-import { queryContext } from "./records-DcHFelq5.mjs";
+import { queryContext } from "./records-CCTxxMWF.mjs";
 import { requireObject, recordsOf, userOf } from "./store-5gqRSKXg.mjs";
 import "./_commonjsHelpers-ClciMIcB.mjs";
 import "stream";
 import "./pluginRegistry-DyHtlkcr.mjs";
 import "./ids-CvnmrMJX.mjs";
-import "./standardObjects-CheqfDqa.mjs";
+import "./standardObjects-vrmqIVLH.mjs";
 import "./relations-B9TynBmA.mjs";
 function exportCsv(ctx, objectId, opts = {}) {
   assertCan(ctx, "export");

package/dist/agent/chunks/{extCheck-GgHG1dYB.mjs → extCheck-BcbUc7eB.mjs}

@@ -93,11 +93,11 @@ async function loadInSandbox(report, manifest, files, opts) {
     import("./memory-WNR3VHUJ.mjs"),
     import("./context-CxFfqS4D.mjs"),
     import("./pluginRegistry-DyHtlkcr.mjs"),
-    import("./seed-6MRmQQBR.mjs"),
+    import("./seed-Bb26Zsni.mjs"),
     import("./store-5gqRSKXg.mjs"),
-    import("./loader-MPD9iAvh.mjs"),
-    import("./registry-COfJrSmg.mjs"),
-    import("./tools-iSH-yMpl.mjs"),
+    import("./loader-Cv0UJf6b.mjs"),
+    import("./registry-ClzNZv9Z.mjs"),
+    import("./tools-CCk24tdh.mjs"),
     import("./extensionActions-D2HtpQz4.mjs"),
     import("./featureRegistry-DSsZbhrh.mjs"),
     import("./themes-DPZFv3yc.mjs"),

package/dist/agent/chunks/{files-D1daDgY0.mjs → files-C4YONVqQ.mjs}

@@ -11,7 +11,7 @@ import { m as mapLimit } from "./http-Bk9ICb7I.mjs";
 import { assertCan, OpsError, actorId } from "./context-CxFfqS4D.mjs";
 import { s as sameTarget, e as fileFieldIds, g as fileIdsIn, f as fileTargetPatch, h as referencedFileIds } from "./relations-B9TynBmA.mjs";
 import { timelineScope } from "./activities-Cj_SIOay.mjs";
-import { updateRecord } from "./records-DcHFelq5.mjs";
+import { updateRecord } from "./records-CCTxxMWF.mjs";
 import { fileOf, requireFile, filesOf, recordOf, activitiesOf, settingsDoc, asDoc, requireRecord, objectOf, requireObject, recordsOf } from "./store-5gqRSKXg.mjs";
 import "./index-BM8qeGOb.mjs";
 import "./pluginRegistry-DyHtlkcr.mjs";
@@ -26,7 +26,7 @@ import "node:crypto";
 import "node:os";
 import "node:child_process";
 import "node:http";
-import "./standardObjects-CheqfDqa.mjs";
+import "./standardObjects-vrmqIVLH.mjs";
 const ORPHAN_GRACE_MS = 864e5;
 function maxUploadBytes(ctx) {
   const mb = settingsDoc(ctx.store)?.maxUploadMb;

package/dist/agent/chunks/{firebase-DWR0K1OC.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()]) {
@@ -273,7 +334,7 @@ function createFirebaseStoreWith(opts) {
     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;
@@ -282,52 +343,143 @@ 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: getIdentity,
     close() {
@@ -383,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;
@@ -399,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();
   }
 });
@@ -451,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,
@@ -476,5 +649,9 @@ export {
   isFirebaseStore,
   isPermissionDenied,
   mutationOps,
-  signInWithSecrets
+  setTrackedCollections,
+  signInWithSecrets,
+  d as splitTs,
+  t as tombstoneId,
+  w as withChangeTracking
 };

package/dist/agent/chunks/firebaseCache-sK4jA0ru.mjs

@@ -0,0 +1,39 @@
+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);
+import { existsSync, rmSync } from "node:fs";
+import { w as writeJsonFile, h as readJsonFile, i as homePath } from "../agentcrm.mjs";
+import "node:util";
+import "node:path";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+function cacheFile(key) {
+  return homePath("cache", `firebase-${key.replace(/[^a-z0-9._-]+/gi, "_")}.json`);
+}
+function fileFirebaseCache() {
+  return {
+    async read(key) {
+      try {
+        return readJsonFile(cacheFile(key), null);
+      } catch {
+        return null;
+      }
+    },
+    async write(key, state) {
+      writeJsonFile(cacheFile(key), state, 384);
+    },
+    async clear(key) {
+      const f = cacheFile(key);
+      if (existsSync(f)) rmSync(f, { force: true });
+    }
+  };
+}
+export {
+  fileFirebaseCache
+};

package/dist/agent/chunks/{firebaseRules-iori-s7U.mjs → firebaseRules-Jq85MBBN.mjs}

@@ -124,7 +124,7 @@ function buildFirestoreRules(input) {
     "      // Nobody changes their own role / email / disabled flag.",
     "      allow update: if (isAdmin() && validRole(request.resource.data.role))",
     "        || (isActive() && request.auth.uid == uid",
-    "            && request.resource.data.diff(resource.data).affectedKeys().hasOnly(['name', 'avatarUrl', 'updatedAt']));",
+    "            && request.resource.data.diff(resource.data).affectedKeys().hasOnly(['name', 'avatarUrl', 'updatedAt', '_ts']));",
     "      allow delete: if isAdmin();",
     "    }",
     "",
@@ -152,7 +152,7 @@ function buildFirestoreRules(input) {
     "      allow read: if isActive();",
     "      allow create, delete: if isAdmin();",
     "      allow update: if isAdmin()",
-    "        || (isMember() && request.resource.data.diff(resource.data).affectedKeys().hasOnly(['lastRunAt', 'updatedAt']));",
+    "        || (isMember() && request.resource.data.diff(resource.data).affectedKeys().hasOnly(['lastRunAt', 'updatedAt', '_ts']));",
     "    }",
     "",
     "    match /automationRuns/{id} {",
@@ -180,6 +180,17 @@ function buildFirestoreRules(input) {
     "      allow write: if isAdmin();",
     "    }",
     "",
+    "    // Tombstones of deleted documents, so cached copies drop them on the",
+    "    // next incremental read (src/data/firebase/api.ts, withChangeTracking).",
+    "    // Written in the same batch as the delete, which the rules above judge.",
+    "    match /deletions/{id} {",
+    "      allow read: if isActive();",
+    "      allow create, update: if isMember()",
+    "        && request.resource.data.keys().hasOnly(['collection', 'id', '_ts'])",
+    "        && request.resource.data._ts == request.time;",
+    "      allow delete: if isAdmin();",
+    "    }",
+    "",
     "    // ─── inbox/{id}: public lead-form submissions ──────────────────────",
     "    function validSubmission(d) {",
     "      return d.keys().hasAll(['formId', 'data', 'createdAt'])",
@@ -213,7 +224,7 @@ function buildFirestoreRules(input) {
   );
   return lines.join("\n");
 }
-[...MEMBER_WRITE, "views", "automations", "automationRuns", "files", ...ADMIN_WRITE, "users"];
+[...MEMBER_WRITE, "views", "automations", "automationRuns", "files", ...ADMIN_WRITE, "users", "deletions"];
 export {
   INBOX_LIMITS,
   buildFirestoreRules,