@noy-db/hub 0.3.0-pre.5 → 0.3.0-pre.7

package/dist/{chunk-3Y4QLJ6K.js → chunk-EU7HDMT3.js}

@@ -1,6 +1,6 @@
 import {
   QuiesceTimeoutError
-} from "./chunk-U23JUUPX.js";
+} from "./chunk-OJ64XMPJ.js";
 
 // src/port/by/types.ts
 function isQuorum(writers, generation, excludeWriterId) {
@@ -51,4 +51,4 @@ export {
   isQuorum,
   runDrainBarrier
 };
-//# sourceMappingURL=chunk-3Y4QLJ6K.js.map
+//# sourceMappingURL=chunk-EU7HDMT3.js.map

package/dist/{chunk-T65UZXR6.js → chunk-FCOZ7DEC.js}

@@ -6,7 +6,7 @@ import {
   ConflictError,
   InvariantError,
   ValidationError
-} from "./chunk-U23JUUPX.js";
+} from "./chunk-OJ64XMPJ.js";
 
 // src/with-commit/tx/transaction.ts
 var TxContext = class {
@@ -216,7 +216,7 @@ async function runTransaction(db, fn, options, txInvariants) {
     db._clearActiveTxContext(ctx);
   }
   if (ctx._amendment) {
-    const { GuardExecutor } = await import("./executor-DJHNSTIR.js");
+    const { GuardExecutor } = await import("./executor-KZ4B3PRT.js");
     try {
       for (const [vaultName, v] of ctx._amendmentVaults) {
         const registry = v._getGuardRegistry();
@@ -352,4 +352,4 @@ export {
   runTransaction,
   revertExecuted
 };
-//# sourceMappingURL=chunk-T65UZXR6.js.map
+//# sourceMappingURL=chunk-FCOZ7DEC.js.map

package/dist/{chunk-M66NAZA4.js → chunk-G5CFMITA.js}

@@ -1,9 +1,9 @@
 import {
   envelopeBodyForHash
-} from "./chunk-OVO2RZAE.js";
+} from "./chunk-JIW3Q5JN.js";
 import {
   sha256Hex
-} from "./chunk-TLJOJBZD.js";
+} from "./chunk-5HZULLHE.js";
 
 // src/with-commit/history/ledger/entry.ts
 function canonicalJson(value) {
@@ -67,4 +67,4 @@ export {
   parseIndex,
   envelopePayloadHash
 };
-//# sourceMappingURL=chunk-M66NAZA4.js.map
+//# sourceMappingURL=chunk-G5CFMITA.js.map

package/dist/{chunk-ZT4GWVTX.js → chunk-GMZFHDSG.js}

@@ -5,11 +5,11 @@ import {
   readDirectoryConfig,
   readUserVisibility,
   saveUserEnvelope
-} from "./chunk-TB5RNNJ4.js";
+} from "./chunk-3CHNKEFI.js";
 import {
   NOYDB_FORMAT_VERSION,
   NOYDB_KEYRING_VERSION
-} from "./chunk-LN22XH4B.js";
+} from "./chunk-HCK2DFEK.js";
 import {
   base64ToBuffer,
   bufferToBase64,
@@ -20,7 +20,7 @@ import {
   generateSalt,
   unwrapKey,
   wrapKey
-} from "./chunk-TLJOJBZD.js";
+} from "./chunk-5HZULLHE.js";
 import {
   DirectoryDisabledError,
   InvalidKeyError,
@@ -32,7 +32,7 @@ import {
   PrivilegeEscalationError,
   USER_ENVELOPE_COLLECTION,
   ValidationError
-} from "./chunk-U23JUUPX.js";
+} from "./chunk-OJ64XMPJ.js";
 
 // src/kernel/validation.ts
 var WeakPassphraseError = class extends NoydbError {
@@ -774,4 +774,4 @@ export {
   hasImportCapability,
   evaluateImportCapability
 };
-//# sourceMappingURL=chunk-ZT4GWVTX.js.map
+//# sourceMappingURL=chunk-GMZFHDSG.js.map

package/dist/chunk-GYGLAVCX.js

@@ -0,0 +1,19 @@
+// src/with-shape/satellites/existence.ts
+function isEnvelopeLive(env) {
+  return env !== null && !(env._iv === "" && env._data === "");
+}
+async function isBaseLive(adapter, vault, base, id) {
+  return isEnvelopeLive(await adapter.get(vault, base, id));
+}
+async function liveBaseIdSet(adapter, vault, base) {
+  const ids = await adapter.list(vault, base);
+  const out = /* @__PURE__ */ new Set();
+  for (const id of ids) if (await isBaseLive(adapter, vault, base, id)) out.add(id);
+  return out;
+}
+
+export {
+  isBaseLive,
+  liveBaseIdSet
+};
+//# sourceMappingURL=chunk-GYGLAVCX.js.map

package/dist/chunk-GYGLAVCX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-shape/satellites/existence.ts"],"sourcesContent":["import type { NoydbStore, EncryptedEnvelope } from '../../kernel/types.js'\n\n/**\n * Existence authority (spec § Convergence & existence authority, rule 1): the\n * base row is the sole authority on record existence. `null` (absent) and the\n * tombstone shape (`_iv === '' && _data === ''`, per `buildTombstone()`) both\n * read as \"not live\" — undecrypted, envelope-level checks only.\n */\nfunction isEnvelopeLive(env: EncryptedEnvelope | null): boolean {\n  return env !== null && !(env._iv === '' && env._data === '')\n}\n\n/** One undecrypted adapter `get` on the base — the store-shape the spec pins (zero extra crypto). */\nexport async function isBaseLive(adapter: NoydbStore, vault: string, base: string, id: string): Promise<boolean> {\n  return isEnvelopeLive(await adapter.get(vault, base, id))\n}\n\n/** The set of base ids that are currently live — used to id-filter satellite `list()` results. */\nexport async function liveBaseIdSet(adapter: NoydbStore, vault: string, base: string): Promise<Set<string>> {\n  const ids = await adapter.list(vault, base)\n  const out = new Set<string>()\n  for (const id of ids) if (await isBaseLive(adapter, vault, base, id)) out.add(id)\n  return out\n}\n"],"mappings":";AAQA,SAAS,eAAe,KAAwC;AAC9D,SAAO,QAAQ,QAAQ,EAAE,IAAI,QAAQ,MAAM,IAAI,UAAU;AAC3D;AAGA,eAAsB,WAAW,SAAqB,OAAe,MAAc,IAA8B;AAC/G,SAAO,eAAe,MAAM,QAAQ,IAAI,OAAO,MAAM,EAAE,CAAC;AAC1D;AAGA,eAAsB,cAAc,SAAqB,OAAe,MAAoC;AAC1G,QAAM,MAAM,MAAM,QAAQ,KAAK,OAAO,IAAI;AAC1C,QAAM,MAAM,oBAAI,IAAY;AAC5B,aAAW,MAAM,IAAK,KAAI,MAAM,WAAW,SAAS,OAAO,MAAM,EAAE,EAAG,KAAI,IAAI,EAAE;AAChF,SAAO;AACT;","names":[]}

package/dist/{chunk-OFBFAVLI.js → chunk-H3MPSYCH.js}

@@ -1,19 +1,23 @@
 import {
   SyncScheduler
 } from "./chunk-VQNJ7UZL.js";
+import {
+  isDeleteMarker,
+  isTombstoneShape
+} from "./chunk-HGQ6UNHE.js";
 import {
   NOYDB_SYNC_VERSION
-} from "./chunk-LN22XH4B.js";
+} from "./chunk-HCK2DFEK.js";
 import {
   bufferToBase64,
   decrypt,
   derivePresenceKey,
   encrypt,
   generateIV
-} from "./chunk-TLJOJBZD.js";
+} from "./chunk-5HZULLHE.js";
 import {
   ConflictError
-} from "./chunk-U23JUUPX.js";
+} from "./chunk-OJ64XMPJ.js";
 
 // src/with-party/team/presence.ts
 var PresenceHandle = class {
@@ -241,6 +245,20 @@ var SyncEngine = class {
   scheduler;
   /** Per-collection conflict resolvers registered by Collection instances. */
   conflictResolvers = /* @__PURE__ */ new Map();
+  /**
+   * Expands a collection-name filter to include its satellite pair partner(s)
+   * (spec #591 convergence rule 5b) — wired from vault satellite declaration
+   * via `setPairExpander`. `undefined` when no satellite has ever been
+   * declared for this vault: identity behavior, zero change for non-satellite
+   * users.
+   */
+  pairExpander;
+  /** #598: refreshes Collection in-memory views after a sync-applied local write. Wired by the vault at open. */
+  cacheInvalidator;
+  /** Wire the Collection-cache invalidation hook (#598). Same injection pattern as `setPairExpander`. */
+  setCacheInvalidator(fn) {
+    this.cacheInvalidator = fn;
+  }
   constructor(opts) {
     this.local = opts.local;
     this.remote = opts.remote;
@@ -273,9 +291,39 @@ var SyncEngine = class {
   /**
    * Register a per-collection conflict resolver.
    * Called by Collection when `conflictPolicy` is set.
+   *
+   * Pair-coupled (#591 rule 5b): registering for one satellite-pair member
+   * registers the same resolver for both — the pair converges under one
+   * resolution policy. Expands with whatever the pair-expander knows *at this
+   * call*; resolvers registered before their pair existed are covered by
+   * `remirrorPairResolvers` at pair-registration time.
    */
   registerConflictResolver(collection, resolver) {
-    this.conflictResolvers.set(collection, resolver);
+    for (const n of this.pairExpander?.([collection]) ?? [collection]) this.conflictResolvers.set(n, resolver);
+  }
+  /**
+   * Wire a satellite pair-expansion function (vault registration, #591 Task 11).
+   * The closure re-reads the live `SatelliteRegistry` on every call, so pairs
+   * declared after this is set are still picked up by `push`/`pull` filters.
+   */
+  setPairExpander(expander) {
+    this.pairExpander = expander;
+  }
+  /**
+   * Retroactively mirror per-collection conflict resolvers across a newly
+   * registered satellite pair (#591 rule 5b) — covers the NORMAL declaration
+   * order, where the base's `conflictPolicy` resolver was registered before
+   * the satellite was declared (so the call-time expansion in
+   * `registerConflictResolver` saw no pair yet). Tie-break: when BOTH members
+   * already carry (different) resolvers, the FIRST name in `names` wins —
+   * callers pass `[base, satellite]`, so the base's resolver is canonical.
+   * Idempotent; a later explicit registration on either member still
+   * overwrites both (last-wins, via the call-time expansion above).
+   */
+  remirrorPairResolvers(names) {
+    const canonical = names.map((n) => this.conflictResolvers.get(n)).find((r) => r !== void 0);
+    if (!canonical) return;
+    for (const n of names) this.conflictResolvers.set(n, canonical);
   }
   /** Record a local change for later push. */
   async trackChange(collection, id, action, version) {
@@ -297,16 +345,24 @@ var SyncEngine = class {
     await this.persistMeta();
     this.scheduler?.notifyChange();
   }
+  /** Remove a dirty entry (satellite fan-out revert cleanup — spec #591). */
+  async removeDirty(collection, id) {
+    const before = this.dirty.length;
+    this.dirty = this.dirty.filter((d) => !(d.collection === collection && d.id === id));
+    if (this.dirty.length !== before) await this.persistMeta();
+  }
   /** Push dirty records to remote adapter. Accepts optional `PushOptions` for partial sync. */
   async push(options) {
     await this.ensureLoaded();
     let pushed = 0;
     const conflicts = [];
+    const erasures = [];
     const errors = [];
     const completed = [];
+    const filter = options?.collections ? new Set(this.pairExpander?.(options.collections) ?? options.collections) : null;
     for (let i = 0; i < this.dirty.length; i++) {
       const entry = this.dirty[i];
-      if (options?.collections && !options.collections.includes(entry.collection)) {
+      if (filter && !filter.has(entry.collection)) {
         continue;
       }
       try {
@@ -320,6 +376,12 @@ var SyncEngine = class {
             completed.push(i);
             continue;
           }
+          if (isTombstoneShape(envelope)) {
+            await this.remote.put(this.vault, entry.collection, entry.id, envelope);
+            completed.push(i);
+            pushed++;
+            continue;
+          }
           try {
             await this.remote.put(
               this.vault,
@@ -334,27 +396,42 @@ var SyncEngine = class {
             if (err instanceof ConflictError) {
               const remoteEnvelope = await this.remote.get(this.vault, entry.collection, entry.id);
               if (remoteEnvelope) {
-                const { handled, conflict } = await this.handleConflict(
-                  entry.collection,
-                  entry.id,
-                  envelope,
-                  remoteEnvelope,
-                  "push"
-                );
-                conflicts.push(conflict);
-                if (handled === "local") {
-                  await this.remote.put(this.vault, entry.collection, entry.id, conflict.local);
-                  completed.push(i);
-                  pushed++;
-                } else if (handled === "remote") {
-                  await this.local.put(this.vault, entry.collection, entry.id, conflict.remote);
+                if (isTombstoneShape(remoteEnvelope)) {
+                  await this.applyRemote(entry.collection, entry.id, remoteEnvelope);
+                  erasures.push(this.reportErasure(entry.collection, entry.id, remoteEnvelope, envelope, "push"));
                   completed.push(i);
-                } else if (handled === "merged" && conflict.local !== envelope) {
-                  const merged = conflict.local;
-                  await this.remote.put(this.vault, entry.collection, entry.id, merged);
-                  await this.local.put(this.vault, entry.collection, entry.id, merged);
-                  completed.push(i);
-                  pushed++;
+                } else if (remoteEnvelope._v === envelope._v && isDeleteMarker(remoteEnvelope) !== isDeleteMarker(envelope) && !this.conflictResolvers.get(entry.collection)) {
+                  if (isDeleteMarker(remoteEnvelope)) {
+                    await this.applyRemote(entry.collection, entry.id, remoteEnvelope);
+                    completed.push(i);
+                  } else {
+                    await this.remote.put(this.vault, entry.collection, entry.id, envelope);
+                    completed.push(i);
+                    pushed++;
+                  }
+                } else {
+                  const { handled, conflict } = await this.handleConflict(
+                    entry.collection,
+                    entry.id,
+                    envelope,
+                    remoteEnvelope,
+                    "push"
+                  );
+                  conflicts.push(conflict);
+                  if (handled === "local") {
+                    await this.remote.put(this.vault, entry.collection, entry.id, conflict.local);
+                    completed.push(i);
+                    pushed++;
+                  } else if (handled === "remote") {
+                    await this.applyRemote(entry.collection, entry.id, conflict.remote);
+                    completed.push(i);
+                  } else if (handled === "merged" && conflict.local !== envelope) {
+                    const merged = conflict.local;
+                    await this.remote.put(this.vault, entry.collection, entry.id, merged);
+                    await this.applyRemote(entry.collection, entry.id, merged);
+                    completed.push(i);
+                    pushed++;
+                  }
                 }
               }
             } else {
@@ -371,7 +448,7 @@ var SyncEngine = class {
     }
     this.lastPush = (/* @__PURE__ */ new Date()).toISOString();
     await this.persistMeta();
-    const result = { pushed, conflicts, errors };
+    const result = { pushed, conflicts, errors, erasures };
     this.emitter.emit("sync:push", result);
     return result;
   }
@@ -380,22 +457,54 @@ var SyncEngine = class {
     await this.ensureLoaded();
     let pulled = 0;
     const conflicts = [];
+    const erasures = [];
     const errors = [];
+    const filter = options?.collections ? new Set(this.pairExpander?.(options.collections) ?? options.collections) : null;
     try {
       const remoteSnapshot = await this.remote.loadAll(this.vault);
       for (const [collName, records] of Object.entries(remoteSnapshot)) {
-        if (options?.collections && !options.collections.includes(collName)) {
+        if (filter && !filter.has(collName)) {
           continue;
         }
         for (const [id, remoteEnvelope] of Object.entries(records)) {
-          if (options?.modifiedSince && remoteEnvelope._ts <= options.modifiedSince) {
+          if (options?.modifiedSince && remoteEnvelope._ts <= options.modifiedSince && !isTombstoneShape(remoteEnvelope) && !isDeleteMarker(remoteEnvelope)) {
             continue;
           }
           try {
             const localEnvelope = await this.local.get(this.vault, collName, id);
+            const remoteIsTombstone = isTombstoneShape(remoteEnvelope);
             if (!localEnvelope) {
-              await this.local.put(this.vault, collName, id, remoteEnvelope);
+              await this.applyRemote(collName, id, remoteEnvelope);
+              pulled++;
+            } else if (isTombstoneShape(localEnvelope)) {
+              if (remoteIsTombstone) {
+                if (remoteEnvelope._v > localEnvelope._v) await this.applyRemote(collName, id, remoteEnvelope);
+              } else {
+                erasures.push(await this.reassertTombstone(collName, id, localEnvelope, remoteEnvelope));
+              }
+            } else if (remoteIsTombstone) {
+              const wasDirty = this.dirty.some((d) => d.collection === collName && d.id === id);
+              await this.applyRemote(collName, id, remoteEnvelope);
+              this.dirty = this.dirty.filter((d) => !(d.collection === collName && d.id === id));
               pulled++;
+              if (wasDirty) erasures.push(this.reportErasure(collName, id, remoteEnvelope, localEnvelope, "pull"));
+            } else if (remoteEnvelope._v === localEnvelope._v && isDeleteMarker(remoteEnvelope) !== isDeleteMarker(localEnvelope)) {
+              const resolver = this.conflictResolvers.get(collName);
+              if (resolver) {
+                const winner = await resolver(id, localEnvelope, remoteEnvelope);
+                if (winner !== localEnvelope && winner !== null) {
+                  if (winner !== remoteEnvelope) {
+                    await this.remote.put(this.vault, collName, id, winner);
+                  }
+                  await this.applyRemote(collName, id, winner);
+                  this.dirty = this.dirty.filter((d) => !(d.collection === collName && d.id === id));
+                  pulled++;
+                }
+              } else if (isDeleteMarker(remoteEnvelope)) {
+                await this.applyRemote(collName, id, remoteEnvelope);
+                this.dirty = this.dirty.filter((d) => !(d.collection === collName && d.id === id));
+                pulled++;
+              }
             } else if (remoteEnvelope._v > localEnvelope._v) {
               const isDirty = this.dirty.some((d) => d.collection === collName && d.id === id);
               if (isDirty) {
@@ -408,17 +517,17 @@ var SyncEngine = class {
                 );
                 conflicts.push(conflict);
                 if (handled === "remote") {
-                  await this.local.put(this.vault, collName, id, conflict.remote);
+                  await this.applyRemote(collName, id, conflict.remote);
                   this.dirty = this.dirty.filter((d) => !(d.collection === collName && d.id === id));
                   pulled++;
                 } else if (handled === "merged" && conflict.local !== localEnvelope) {
                   const merged = conflict.local;
-                  await this.local.put(this.vault, collName, id, merged);
+                  await this.applyRemote(collName, id, merged);
                   this.dirty = this.dirty.filter((d) => !(d.collection === collName && d.id === id));
                   pulled++;
                 }
               } else {
-                await this.local.put(this.vault, collName, id, remoteEnvelope);
+                await this.applyRemote(collName, id, remoteEnvelope);
                 pulled++;
               }
             }
@@ -432,7 +541,7 @@ var SyncEngine = class {
     }
     this.lastPull = (/* @__PURE__ */ new Date()).toISOString();
     await this.persistMeta();
-    const result = { pulled, conflicts, errors };
+    const result = { pulled, conflicts, errors, erasures };
     this.emitter.emit("sync:pull", result);
     return result;
   }
@@ -451,6 +560,7 @@ var SyncEngine = class {
     await this.ensureLoaded();
     let pushed = 0;
     const conflicts = [];
+    const erasures = [];
     const errors = [];
     const completed = [];
     for (let i = 0; i < this.dirty.length; i++) {
@@ -467,6 +577,12 @@ var SyncEngine = class {
             completed.push(i);
             continue;
           }
+          if (isTombstoneShape(envelope)) {
+            await this.remote.put(this.vault, entry.collection, entry.id, envelope);
+            completed.push(i);
+            pushed++;
+            continue;
+          }
           try {
             await this.remote.put(
               this.vault,
@@ -481,27 +597,42 @@ var SyncEngine = class {
             if (err instanceof ConflictError) {
               const remoteEnvelope = await this.remote.get(this.vault, entry.collection, entry.id);
               if (remoteEnvelope) {
-                const { handled, conflict } = await this.handleConflict(
-                  entry.collection,
-                  entry.id,
-                  envelope,
-                  remoteEnvelope,
-                  "push"
-                );
-                conflicts.push(conflict);
-                if (handled === "local") {
-                  await this.remote.put(this.vault, entry.collection, entry.id, conflict.local);
-                  completed.push(i);
-                  pushed++;
-                } else if (handled === "remote") {
-                  await this.local.put(this.vault, entry.collection, entry.id, conflict.remote);
-                  completed.push(i);
-                } else if (handled === "merged" && conflict.local !== envelope) {
-                  const merged = conflict.local;
-                  await this.remote.put(this.vault, entry.collection, entry.id, merged);
-                  await this.local.put(this.vault, entry.collection, entry.id, merged);
+                if (isTombstoneShape(remoteEnvelope)) {
+                  await this.applyRemote(entry.collection, entry.id, remoteEnvelope);
+                  erasures.push(this.reportErasure(entry.collection, entry.id, remoteEnvelope, envelope, "push"));
                   completed.push(i);
-                  pushed++;
+                } else if (remoteEnvelope._v === envelope._v && isDeleteMarker(remoteEnvelope) !== isDeleteMarker(envelope) && !this.conflictResolvers.get(entry.collection)) {
+                  if (isDeleteMarker(remoteEnvelope)) {
+                    await this.applyRemote(entry.collection, entry.id, remoteEnvelope);
+                    completed.push(i);
+                  } else {
+                    await this.remote.put(this.vault, entry.collection, entry.id, envelope);
+                    completed.push(i);
+                    pushed++;
+                  }
+                } else {
+                  const { handled, conflict } = await this.handleConflict(
+                    entry.collection,
+                    entry.id,
+                    envelope,
+                    remoteEnvelope,
+                    "push"
+                  );
+                  conflicts.push(conflict);
+                  if (handled === "local") {
+                    await this.remote.put(this.vault, entry.collection, entry.id, conflict.local);
+                    completed.push(i);
+                    pushed++;
+                  } else if (handled === "remote") {
+                    await this.applyRemote(entry.collection, entry.id, conflict.remote);
+                    completed.push(i);
+                  } else if (handled === "merged" && conflict.local !== envelope) {
+                    const merged = conflict.local;
+                    await this.remote.put(this.vault, entry.collection, entry.id, merged);
+                    await this.applyRemote(entry.collection, entry.id, merged);
+                    completed.push(i);
+                    pushed++;
+                  }
                 }
               }
             } else {
@@ -518,7 +649,7 @@ var SyncEngine = class {
     }
     this.lastPush = (/* @__PURE__ */ new Date()).toISOString();
     await this.persistMeta();
-    const result = { pushed, conflicts, errors };
+    const result = { pushed, conflicts, errors, erasures };
     this.emitter.emit("sync:push", result);
     return result;
   }
@@ -567,6 +698,33 @@ var SyncEngine = class {
     this.isOnline = false;
     this.emitter.emit("sync:offline", void 0);
   };
+  /** Apply an envelope to the local store and refresh in-memory views (#598). */
+  async applyRemote(collection, id, envelope) {
+    await this.local.put(this.vault, collection, id, envelope);
+    await this.cacheInvalidator?.(collection, id);
+  }
+  /** Record + emit a tombstone enforcement (#590). */
+  reportErasure(collection, id, tombstone, suppressed, direction) {
+    const enforcement = { vault: this.vault, collection, id, tombstone, suppressed, direction };
+    this.emitter.emit("sync:erasure", enforcement);
+    return enforcement;
+  }
+  /**
+   * Re-assert a local tombstone over a live remote envelope (#590): the shred
+   * wins in both directions, regardless of `_v`. Bumps the tombstone to the
+   * suppressed envelope's `_v` when higher so per-key version counters stay
+   * monotonic on every store; `_by` (the shredding actor) is preserved.
+   */
+  async reassertTombstone(collection, id, tombstone, suppressedRemote) {
+    let winner = tombstone;
+    if (suppressedRemote._v > tombstone._v) {
+      winner = { ...tombstone, _v: suppressedRemote._v, _ts: (/* @__PURE__ */ new Date()).toISOString() };
+      await this.applyRemote(collection, id, winner);
+    }
+    await this.remote.put(this.vault, collection, id, winner);
+    this.dirty = this.dirty.filter((d) => !(d.collection === collection && d.id === id));
+    return this.reportErasure(collection, id, winner, suppressedRemote, "pull");
+  }
   /**
    * Resolve a conflict, checking per-collection resolvers first,
    * then falling back to the db-level `ConflictStrategy`.
@@ -709,7 +867,8 @@ var SyncTransaction = class {
     return {
       status: pushResult.conflicts.length > 0 ? "conflict" : "committed",
       pushed: pushResult.pushed,
-      conflicts: pushResult.conflicts
+      conflicts: pushResult.conflicts,
+      ...pushResult.erasures?.length ? { erasures: pushResult.erasures } : {}
     };
   }
 };
@@ -719,4 +878,4 @@ export {
   SyncEngine,
   SyncTransaction
 };
-//# sourceMappingURL=chunk-OFBFAVLI.js.map
+//# sourceMappingURL=chunk-H3MPSYCH.js.map