@noy-db/hub 0.3.0-pre.1 → 0.3.0-pre.11

package/dist/chunk-W5D62AQD.js

@@ -0,0 +1,944 @@
+import {
+  SyncScheduler
+} from "./chunk-VQNJ7UZL.js";
+import {
+  isDeleteMarker,
+  isTombstoneShape
+} from "./chunk-FQQF23MC.js";
+import {
+  bufferToBase64,
+  decrypt,
+  derivePresenceKey,
+  encrypt,
+  generateIV
+} from "./chunk-HUS3J5WM.js";
+import {
+  NOYDB_SYNC_VERSION
+} from "./chunk-CKZW6P5V.js";
+import {
+  ConflictError
+} from "./chunk-FH542DDY.js";
+
+// src/with-party/team/presence.ts
+var PresenceHandle = class {
+  adapter;
+  syncAdapter;
+  vault;
+  collectionName;
+  userId;
+  encrypted;
+  getDEK;
+  staleMs;
+  pollIntervalMs;
+  channel;
+  storageCollection;
+  presenceKey = null;
+  subscribers = [];
+  unsubscribePubSub = null;
+  pollTimer = null;
+  stopped = false;
+  constructor(opts) {
+    this.adapter = opts.adapter;
+    this.syncAdapter = opts.syncAdapter;
+    this.vault = opts.vault;
+    this.collectionName = opts.collectionName;
+    this.userId = opts.userId;
+    this.encrypted = opts.encrypted;
+    this.getDEK = opts.getDEK;
+    this.staleMs = opts.staleMs ?? 3e4;
+    this.pollIntervalMs = opts.pollIntervalMs ?? 5e3;
+    this.channel = `${opts.vault}:${opts.collectionName}:presence`;
+    this.storageCollection = `_presence_${opts.collectionName}`;
+  }
+  /**
+   * Announce yourself (or update your cursor/status).
+   * Encrypts `payload` with the presence key and publishes it.
+   */
+  async update(payload) {
+    if (this.stopped) return;
+    const key = await this.getPresenceKey();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const plaintext = JSON.stringify({ userId: this.userId, lastSeen: now, payload });
+    let encryptedPayload;
+    if (this.encrypted && key) {
+      const iv = generateIV();
+      const ivB64 = bufferToBase64(iv);
+      const { data } = await encrypt(plaintext, key);
+      encryptedPayload = JSON.stringify({ iv: ivB64, data });
+    } else {
+      encryptedPayload = plaintext;
+    }
+    const pubAdapter = this.getPubSubAdapter();
+    if (pubAdapter?.presencePublish) {
+      await pubAdapter.presencePublish(this.channel, encryptedPayload);
+    }
+    await this.writeStorageRecord(payload, now);
+  }
+  /**
+   * Subscribe to presence updates. The callback receives a filtered, decrypted
+   * list of all currently-active peers (excluding yourself, excluding stale).
+   *
+   * Returns an unsubscribe function. Also call `stop()` to release all resources.
+   */
+  subscribe(cb) {
+    if (this.stopped) return () => {
+    };
+    this.subscribers.push(cb);
+    if (this.subscribers.length === 1) {
+      this.startListening();
+    }
+    return () => {
+      this.subscribers = this.subscribers.filter((s) => s !== cb);
+      if (this.subscribers.length === 0) this.stopListening();
+    };
+  }
+  /** Stop all listening and clear resources. */
+  stop() {
+    this.stopped = true;
+    this.stopListening();
+    this.subscribers = [];
+  }
+  // ─── Private ────────────────────────────────────────────────────────
+  async getPresenceKey() {
+    if (!this.encrypted) return null;
+    if (!this.presenceKey) {
+      try {
+        const dek = await this.getDEK(this.collectionName);
+        this.presenceKey = await derivePresenceKey(dek, this.collectionName);
+      } catch {
+      }
+    }
+    return this.presenceKey;
+  }
+  getPubSubAdapter() {
+    if (this.syncAdapter?.presencePublish) return this.syncAdapter;
+    if (this.adapter.presencePublish) return this.adapter;
+    return void 0;
+  }
+  startListening() {
+    const pubAdapter = this.getPubSubAdapter();
+    if (pubAdapter?.presenceSubscribe) {
+      this.unsubscribePubSub = pubAdapter.presenceSubscribe(
+        this.channel,
+        (encryptedPayload) => {
+          void this.handlePubSubMessage(encryptedPayload);
+        }
+      );
+    } else {
+      this.pollTimer = setInterval(
+        () => {
+          void this.pollStoragePresence();
+        },
+        this.pollIntervalMs
+      );
+      void this.pollStoragePresence();
+    }
+  }
+  stopListening() {
+    if (this.unsubscribePubSub) {
+      this.unsubscribePubSub();
+      this.unsubscribePubSub = null;
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  async handlePubSubMessage(encryptedPayload) {
+    try {
+      const peer = await this.decryptPresencePayload(encryptedPayload);
+      if (!peer || peer.userId === this.userId) return;
+      const cutoff = new Date(Date.now() - this.staleMs).toISOString();
+      if (peer.lastSeen < cutoff) return;
+      await this.pollStoragePresence();
+    } catch {
+    }
+  }
+  async decryptPresencePayload(encryptedPayload) {
+    const key = await this.getPresenceKey();
+    if (!this.encrypted || !key) {
+      return JSON.parse(encryptedPayload);
+    }
+    const { iv: ivB64, data } = JSON.parse(encryptedPayload);
+    const plaintext = await decrypt(ivB64, data, key);
+    return JSON.parse(plaintext);
+  }
+  async writeStorageRecord(payload, now) {
+    const key = await this.getPresenceKey();
+    const plaintext = JSON.stringify(payload);
+    let iv = "";
+    let data;
+    if (this.encrypted && key) {
+      const ivBytes = generateIV();
+      iv = bufferToBase64(ivBytes);
+      const result = await encrypt(plaintext, key);
+      data = result.data;
+    } else {
+      data = plaintext;
+    }
+    const record = { userId: this.userId, lastSeen: now, iv, data };
+    const json = JSON.stringify(record);
+    const storeAdapter = this.syncAdapter ?? this.adapter;
+    const envelope = {
+      _noydb: 1,
+      _v: 1,
+      _ts: now,
+      _iv: "",
+      _data: json
+    };
+    try {
+      await storeAdapter.put(
+        this.vault,
+        this.storageCollection,
+        this.userId,
+        envelope
+      );
+    } catch {
+    }
+  }
+  async pollStoragePresence() {
+    if (this.stopped || this.subscribers.length === 0) return;
+    try {
+      const storeAdapter = this.syncAdapter ?? this.adapter;
+      const ids = await storeAdapter.list(this.vault, this.storageCollection);
+      const cutoff = new Date(Date.now() - this.staleMs).toISOString();
+      const peers = [];
+      for (const id of ids) {
+        if (id === this.userId) continue;
+        const envelope = await storeAdapter.get(this.vault, this.storageCollection, id);
+        if (!envelope) continue;
+        const record = JSON.parse(envelope._data);
+        if (record.lastSeen < cutoff) continue;
+        let peerPayload;
+        if (this.encrypted && this.presenceKey && record.iv) {
+          const plaintext = await decrypt(record.iv, record.data, this.presenceKey);
+          peerPayload = JSON.parse(plaintext);
+        } else {
+          peerPayload = JSON.parse(record.data);
+        }
+        peers.push({ userId: record.userId, payload: peerPayload, lastSeen: record.lastSeen });
+      }
+      for (const cb of this.subscribers) {
+        cb(peers);
+      }
+    } catch {
+    }
+  }
+};
+
+// src/with-party/team/sync.ts
+var SyncEngine = class {
+  local;
+  remote;
+  strategy;
+  emitter;
+  vault;
+  role;
+  label;
+  dirty = [];
+  lastPush = null;
+  lastPull = null;
+  loaded = false;
+  autoSyncInterval = null;
+  isOnline = true;
+  /** Sync scheduler. Manages push/pull timing. */
+  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;
+    this.vault = opts.vault;
+    this.strategy = opts.strategy;
+    this.emitter = opts.emitter;
+    this.role = opts.role ?? "sync-peer";
+    this.label = opts.label;
+    const policy = opts.syncPolicy;
+    if (policy && policy.push.mode !== "manual") {
+      this.scheduler = new SyncScheduler(policy, {
+        push: () => this.push().then(() => {
+        }),
+        pull: () => this.pull().then(() => {
+        }),
+        getDirtyCount: () => this.dirty.length
+      });
+    } else {
+      this.scheduler = null;
+    }
+  }
+  /** Start the sync scheduler. Called after vault is fully opened. */
+  startScheduler() {
+    this.scheduler?.start();
+  }
+  /** Stop the sync scheduler. Called on close. */
+  stopScheduler() {
+    this.scheduler?.stop();
+  }
+  /**
+   * 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) {
+    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) {
+    await this.ensureLoaded();
+    const idx = this.dirty.findIndex((d) => d.collection === collection && d.id === id);
+    const entry = {
+      vault: this.vault,
+      collection,
+      id,
+      action,
+      version,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (idx >= 0) {
+      this.dirty[idx] = entry;
+    } else {
+      this.dirty.push(entry);
+    }
+    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 (filter && !filter.has(entry.collection)) {
+        continue;
+      }
+      try {
+        if (entry.action === "delete") {
+          await this.remote.delete(this.vault, entry.collection, entry.id);
+          completed.push(i);
+          pushed++;
+        } else {
+          const envelope = await this.local.get(this.vault, entry.collection, entry.id);
+          if (!envelope) {
+            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,
+              entry.collection,
+              entry.id,
+              envelope,
+              entry.version - 1
+            );
+            completed.push(i);
+            pushed++;
+          } catch (err) {
+            if (err instanceof ConflictError) {
+              const remoteEnvelope = await this.remote.get(this.vault, entry.collection, entry.id);
+              if (remoteEnvelope) {
+                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 (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 {
+              throw err;
+            }
+          }
+        }
+      } catch (err) {
+        errors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    for (const i of completed.sort((a, b) => b - a)) {
+      this.dirty.splice(i, 1);
+    }
+    this.lastPush = (/* @__PURE__ */ new Date()).toISOString();
+    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 (filter && !filter.has(collName)) {
+          continue;
+        }
+        for (const [id, remoteEnvelope] of Object.entries(records)) {
+          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.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) {
+                const { handled, conflict } = await this.handleConflict(
+                  collName,
+                  id,
+                  localEnvelope,
+                  remoteEnvelope,
+                  "pull"
+                );
+                conflicts.push(conflict);
+                if (handled === "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.applyRemote(collName, id, merged);
+                  this.dirty = this.dirty.filter((d) => !(d.collection === collName && d.id === id));
+                  pulled++;
+                }
+              } else {
+                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)));
+          }
+        }
+      }
+    } catch (err) {
+      errors.push(err instanceof Error ? err : new Error(String(err)));
+    }
+    this.lastPull = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      await this.persistMeta();
+    } finally {
+      await this.graphBatchController?.flush();
+    }
+    const result = { pulled, conflicts, errors, erasures };
+    this.emitter.emit("sync:pull", result);
+    return result;
+  }
+  /** Bidirectional sync: pull then push. */
+  async sync(options) {
+    const pullResult = await this.pull(options?.pull);
+    const pushResult = await this.push(options?.push);
+    return { pull: pullResult, push: pushResult };
+  }
+  /**
+   * Push a specific subset of dirty entries (for sync transactions, ).
+   * Entries are matched by collection+id from the dirty log; matched entries
+   * are removed from the dirty log on success.
+   */
+  async pushFiltered(predicate) {
+    await this.ensureLoaded();
+    let pushed = 0;
+    const conflicts = [];
+    const erasures = [];
+    const errors = [];
+    const completed = [];
+    for (let i = 0; i < this.dirty.length; i++) {
+      const entry = this.dirty[i];
+      if (!predicate(entry)) continue;
+      try {
+        if (entry.action === "delete") {
+          await this.remote.delete(this.vault, entry.collection, entry.id);
+          completed.push(i);
+          pushed++;
+        } else {
+          const envelope = await this.local.get(this.vault, entry.collection, entry.id);
+          if (!envelope) {
+            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,
+              entry.collection,
+              entry.id,
+              envelope,
+              entry.version - 1
+            );
+            completed.push(i);
+            pushed++;
+          } catch (err) {
+            if (err instanceof ConflictError) {
+              const remoteEnvelope = await this.remote.get(this.vault, entry.collection, entry.id);
+              if (remoteEnvelope) {
+                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 (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 {
+              throw err;
+            }
+          }
+        }
+      } catch (err) {
+        errors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    for (const i of completed.sort((a, b) => b - a)) {
+      this.dirty.splice(i, 1);
+    }
+    this.lastPush = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persistMeta();
+    const result = { pushed, conflicts, errors, erasures };
+    this.emitter.emit("sync:push", result);
+    return result;
+  }
+  /** Get current sync status. */
+  status() {
+    return {
+      dirty: this.dirty.length,
+      lastPush: this.lastPush,
+      lastPull: this.lastPull,
+      online: this.isOnline
+    };
+  }
+  // ─── Auto-Sync ───────────────────────────────────────────────────
+  /** Start auto-sync: listen for online/offline events, optional periodic sync. */
+  startAutoSync(intervalMs) {
+    if (typeof globalThis.addEventListener === "function") {
+      globalThis.addEventListener("online", this.handleOnline);
+      globalThis.addEventListener("offline", this.handleOffline);
+    }
+    if (intervalMs && intervalMs > 0) {
+      this.autoSyncInterval = setInterval(() => {
+        if (this.isOnline) {
+          void this.sync();
+        }
+      }, intervalMs);
+    }
+  }
+  /** Stop auto-sync and scheduler. */
+  stopAutoSync() {
+    this.stopScheduler();
+    if (typeof globalThis.removeEventListener === "function") {
+      globalThis.removeEventListener("online", this.handleOnline);
+      globalThis.removeEventListener("offline", this.handleOffline);
+    }
+    if (this.autoSyncInterval) {
+      clearInterval(this.autoSyncInterval);
+      this.autoSyncInterval = null;
+    }
+  }
+  handleOnline = () => {
+    this.isOnline = true;
+    this.emitter.emit("sync:online", void 0);
+    void this.sync();
+  };
+  handleOffline = () => {
+    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`.
+   *
+   * Returns the resolved `Conflict` object (possibly with `resolve` set for
+   * manual mode) and a `handled` discriminant:
+   * - `'local'` — keep the local envelope; push it to remote.
+   * - `'remote'` — keep the remote envelope; update local.
+   * - `'merged'` — a custom merge fn produced a new envelope stored as `conflict.local`.
+   * - `'deferred'` — manual mode, resolve was not called synchronously.
+   */
+  async handleConflict(collection, id, local, remote, _phase) {
+    const resolver = this.conflictResolvers.get(collection);
+    if (resolver) {
+      const winner = await resolver(id, local, remote);
+      const base = {
+        vault: this.vault,
+        collection,
+        id,
+        local,
+        remote,
+        localVersion: local._v,
+        remoteVersion: remote._v
+      };
+      if (winner === null) return { handled: "deferred", conflict: base };
+      if (winner === local) return { handled: "local", conflict: base };
+      if (winner === remote) return { handled: "remote", conflict: base };
+      return {
+        handled: "merged",
+        conflict: { ...base, local: winner, localVersion: winner._v }
+      };
+    }
+    const baseConflict = {
+      vault: this.vault,
+      collection,
+      id,
+      local,
+      remote,
+      localVersion: local._v,
+      remoteVersion: remote._v
+    };
+    this.emitter.emit("sync:conflict", baseConflict);
+    const side = this.legacyResolve(baseConflict);
+    return { handled: side, conflict: baseConflict };
+  }
+  /** DB-level ConflictStrategy resolution (legacy, kept for backward compat). */
+  legacyResolve(conflict) {
+    if (typeof this.strategy === "function") {
+      return this.strategy(conflict);
+    }
+    switch (this.strategy) {
+      case "local-wins":
+        return "local";
+      case "remote-wins":
+        return "remote";
+      case "version":
+      default:
+        return conflict.localVersion >= conflict.remoteVersion ? "local" : "remote";
+    }
+  }
+  // ─── Persistence ─────────────────────────────────────────────────
+  async ensureLoaded() {
+    if (this.loaded) return;
+    const envelope = await this.local.get(this.vault, "_sync", "meta");
+    if (envelope) {
+      const meta = JSON.parse(envelope._data);
+      this.dirty = [...meta.dirty];
+      this.lastPush = meta.last_push;
+      this.lastPull = meta.last_pull;
+    }
+    this.loaded = true;
+  }
+  async persistMeta() {
+    const meta = {
+      _noydb_sync: NOYDB_SYNC_VERSION,
+      last_push: this.lastPush,
+      last_pull: this.lastPull,
+      dirty: this.dirty
+    };
+    const envelope = {
+      _noydb: 1,
+      _v: 1,
+      _ts: (/* @__PURE__ */ new Date()).toISOString(),
+      _iv: "",
+      _data: JSON.stringify(meta)
+    };
+    await this.local.put(this.vault, "_sync", "meta", envelope);
+  }
+};
+
+// src/with-party/team/sync-transaction.ts
+var SyncTransaction = class {
+  comp;
+  engine;
+  ops = [];
+  /** @internal — constructed by `Noydb.transaction()` */
+  constructor(comp, engine) {
+    this.comp = comp;
+    this.engine = engine;
+  }
+  /** Stage a record write. Does not write to any adapter until `commit()`. */
+  put(collection, id, record) {
+    this.ops.push({ type: "put", collection, id, record });
+    return this;
+  }
+  /** Stage a record delete. Does not write to any adapter until `commit()`. */
+  delete(collection, id) {
+    this.ops.push({ type: "delete", collection, id });
+    return this;
+  }
+  /**
+   * Commit the transaction.
+   *
+   * Phase 1 — writes all staged operations to the local adapter via the
+   * collection layer (encryption + dirty-log tracking).
+   *
+   * Phase 2 — pushes only the records that were written in this
+   * transaction to the remote adapter. Existing dirty entries from
+   * outside this transaction are not affected.
+   *
+   * If any record conflicts during the push, `status` is `'conflict'`
+   * and `conflicts` lists the affected records. No automatic rollback is
+   * performed.
+   */
+  async commit() {
+    for (const op of this.ops) {
+      if (op.type === "put") {
+        await this.comp.collection(op.collection).put(op.id, op.record);
+      } else {
+        await this.comp.collection(op.collection).delete(op.id);
+      }
+    }
+    const opSet = /* @__PURE__ */ new Set();
+    for (const op of this.ops) {
+      opSet.add(`${op.collection}::${op.id}`);
+    }
+    const pushResult = await this.engine.pushFiltered(
+      (entry) => opSet.has(`${entry.collection}::${entry.id}`)
+    );
+    return {
+      status: pushResult.conflicts.length > 0 ? "conflict" : "committed",
+      pushed: pushResult.pushed,
+      conflicts: pushResult.conflicts,
+      ...pushResult.erasures?.length ? { erasures: pushResult.erasures } : {}
+    };
+  }
+};
+
+export {
+  PresenceHandle,
+  SyncEngine,
+  SyncTransaction
+};
+//# sourceMappingURL=chunk-W5D62AQD.js.map