@noy-db/hub 0.2.0-pre.9 → 0.3.0-pre.10

package/dist/{chunk-WPLVTJ5D.js → chunk-TAKWLZZX.js}

@@ -1,21 +1,25 @@
 import {
   SyncScheduler
-} from "./chunk-2QR2PQTT.js";
+} from "./chunk-VQNJ7UZL.js";
 import {
-  NOYDB_SYNC_VERSION
-} from "./chunk-WIRRPTFH.js";
+  isDeleteMarker,
+  isTombstoneShape
+} from "./chunk-QA2KUPCP.js";
 import {
   bufferToBase64,
   decrypt,
   derivePresenceKey,
   encrypt,
   generateIV
-} from "./chunk-PP6W64Y3.js";
+} from "./chunk-3OPY6MK2.js";
+import {
+  NOYDB_SYNC_VERSION
+} from "./chunk-YN5IAHN6.js";
 import {
   ConflictError
-} from "./chunk-B6PB7JLN.js";
+} from "./chunk-S7VFUQM2.js";
 
-// src/team/presence.ts
+// src/with-party/team/presence.ts
 var PresenceHandle = class {
   adapter;
   syncAdapter;
@@ -222,7 +226,7 @@ var PresenceHandle = class {
   }
 };
 
-// src/team/sync.ts
+// src/with-party/team/sync.ts
 var SyncEngine = class {
   local;
   remote;
@@ -241,6 +245,38 @@ 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. `action` (#640): `'delete'` for a pulled tombstone/delete-marker, `'put'`
+   *  otherwise — classified at `applyRemote`, the one choke point that holds the envelope. */
+  cacheInvalidator;
+  /** Wire the Collection-cache invalidation hook (#598). Same injection pattern as `setPairExpander`. */
+  setCacheInvalidator(fn) {
+    this.cacheInvalidator = fn;
+  }
+  /** #638 Task 4: opens/flushes the vault's graph-dispatch touch batch around a whole `pull()`/
+   *  `push()` call, so N `applyRemote`d records feeding the same derivation/rollup/MV target
+   *  recompute once. Wired by the vault at open, mirroring `cacheInvalidator`. */
+  graphBatchController;
+  /** Wire the graph-dispatch batch controller (#638 Task 4). Same injection pattern as `setCacheInvalidator`. */
+  setGraphBatchController(controller) {
+    this.graphBatchController = controller;
+  }
+  /** #650 Task 4 (#647): declared reserved-lookup collections `pull()` enumerates explicitly (the
+   *  store's `list()` does not skip `_`-prefixed names, unlike `loadAll()`). Wired by the vault at
+   *  open, same injection pattern as `setCacheInvalidator`/`setGraphBatchController`. */
+  reservedLookup;
+  /** Wire the reserved-lookup source (#650 Task 4). */
+  setReservedLookupSource(source) {
+    this.reservedLookup = source;
+  }
   constructor(opts) {
     this.local = opts.local;
     this.remote = opts.remote;
@@ -273,9 +309,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 +363,25 @@ 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();
+    this.graphBatchController?.begin();
     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 +395,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 +415,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 {
@@ -370,32 +466,69 @@ var SyncEngine = class {
       this.dirty.splice(i, 1);
     }
     this.lastPush = (/* @__PURE__ */ new Date()).toISOString();
-    await this.persistMeta();
-    const result = { pushed, conflicts, errors };
+    try {
+      await this.persistMeta();
+    } finally {
+      await this.graphBatchController?.flush();
+    }
+    const result = { pushed, conflicts, errors, erasures };
     this.emitter.emit("sync:push", result);
     return result;
   }
   /** Pull remote records to local adapter. Accepts optional `PullOptions` for partial sync. */
   async pull(options) {
     await this.ensureLoaded();
+    this.graphBatchController?.begin();
     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,19 +541,48 @@ 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++;
+              }
+            }
+          } catch (err) {
+            errors.push(err instanceof Error ? err : new Error(String(err)));
+          }
+        }
+      }
+      for (const collName of this.reservedLookup?.collections() ?? []) {
+        if (filter && !filter.has(collName)) continue;
+        for (const id of await this.remote.list(this.vault, collName)) {
+          try {
+            const remoteEnvelope = await this.remote.get(this.vault, collName, id);
+            if (!remoteEnvelope) continue;
+            if (options?.modifiedSince && remoteEnvelope._ts <= options.modifiedSince && !isDeleteMarker(remoteEnvelope)) {
+              continue;
+            }
+            const localEnvelope = await this.local.get(this.vault, collName, id);
+            if (!localEnvelope) {
+              await this.applyRemote(collName, id, remoteEnvelope);
+              pulled++;
+            } else if (remoteEnvelope._v === localEnvelope._v && isDeleteMarker(remoteEnvelope) !== isDeleteMarker(localEnvelope)) {
+              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) {
+              await this.applyRemote(collName, id, remoteEnvelope);
+              this.dirty = this.dirty.filter((d) => !(d.collection === collName && d.id === id));
+              pulled++;
             }
           } catch (err) {
             errors.push(err instanceof Error ? err : new Error(String(err)));
@@ -431,8 +593,12 @@ var SyncEngine = class {
       errors.push(err instanceof Error ? err : new Error(String(err)));
     }
     this.lastPull = (/* @__PURE__ */ new Date()).toISOString();
-    await this.persistMeta();
-    const result = { pulled, conflicts, errors };
+    try {
+      await this.persistMeta();
+    } finally {
+      await this.graphBatchController?.flush();
+    }
+    const result = { pulled, conflicts, errors, erasures };
     this.emitter.emit("sync:pull", result);
     return result;
   }
@@ -451,6 +617,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 +634,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 +654,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);
+                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 (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);
-                  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 +706,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 +755,39 @@ 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). `action` (#640):
+   *  classified HERE — the one choke point that still holds the envelope — so the
+   *  cacheInvalidator seam (and, downstream, the dispatch wave) can tell a pulled delete from an
+   *  ordinary put. `isTombstoneShape` covers a forgotten-elsewhere record arriving as a shred;
+   *  `isDeleteMarker` covers an ordinary (#589) delete — both route to the SAME 'delete' action
+   *  (sync delete ≠ forget: freshness only, no shred/residue channel on the receiving side). */
+  async applyRemote(collection, id, envelope) {
+    await this.local.put(this.vault, collection, id, envelope);
+    const action = isTombstoneShape(envelope) || isDeleteMarker(envelope) ? "delete" : "put";
+    await this.cacheInvalidator?.(collection, id, action);
+  }
+  /** 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`.
@@ -657,7 +878,7 @@ var SyncEngine = class {
   }
 };
 
-// src/team/sync-transaction.ts
+// src/with-party/team/sync-transaction.ts
 var SyncTransaction = class {
   comp;
   engine;
@@ -709,7 +930,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 +941,4 @@ export {
   SyncEngine,
   SyncTransaction
 };
-//# sourceMappingURL=chunk-WPLVTJ5D.js.map
+//# sourceMappingURL=chunk-TAKWLZZX.js.map