@noy-db/hub 0.2.0-pre.26 → 0.2.0-pre.27

package/dist/i18n/index.d.cts

@@ -1,6 +1,6 @@
 export { I as I18nMap, a as I18nTextDescriptor, b as I18nTextOptions, L as Layer, O as OnMissing, c as OnMissingPolicy, R as ResolveI18nOptions, d as applyI18nLocale, g as getAtPath, i as i18nText, e as isI18nTextDescriptor, r as resolveI18nText, f as resolvePolicy, s as setAtPathInPlace, v as validateI18nTextValue } from '../strategy-D1zjEV3n.cjs';
-import { I as I18nStrategy } from '../types-BCYvhKzr.cjs';
-export { D as DICT_COLLECTION_PREFIX, a as DictEntry, b as DictKeyDescriptor, c as DictionaryHandle, d as DictionaryOptions, S as ScriptWarning, e as StaticDictDescriptor, f as dictCollectionName, g as dictKey, h as enforceScript, i as inferScripts, j as isDictCollectionName, k as isDictKeyDescriptor, l as isStaticDictDescriptor, s as staticDict } from '../types-BCYvhKzr.cjs';
+import { I as I18nStrategy } from '../types-CwrTuYFI.cjs';
+export { D as DICT_COLLECTION_PREFIX, a as DictEntry, b as DictKeyDescriptor, c as DictionaryHandle, d as DictionaryOptions, S as ScriptWarning, e as StaticDictDescriptor, f as dictCollectionName, g as dictKey, h as enforceScript, i as inferScripts, j as isDictCollectionName, k as isDictKeyDescriptor, l as isStaticDictDescriptor, s as staticDict } from '../types-CwrTuYFI.cjs';
 export { D as DictKeyInUseError, a as DictKeyMissingError, L as LocaleNotSpecifiedError, M as MissingTranslationError, R as ReservedCollectionNameError, S as ScriptViolationError, b as StaticDictReadonlyError, T as TranslatorNotConfiguredError, U as UnknownDictCodeError } from '../errors-Dwk2k1xY.cjs';
 import '../lazy-builder-eYZzLEL1.cjs';
 import '../predicate-BmhBSPCH.cjs';

package/dist/i18n/index.d.ts

@@ -1,6 +1,6 @@
 export { I as I18nMap, a as I18nTextDescriptor, b as I18nTextOptions, L as Layer, O as OnMissing, c as OnMissingPolicy, R as ResolveI18nOptions, d as applyI18nLocale, g as getAtPath, i as i18nText, e as isI18nTextDescriptor, r as resolveI18nText, f as resolvePolicy, s as setAtPathInPlace, v as validateI18nTextValue } from '../strategy-YQ1qJWyq.js';
-import { I as I18nStrategy } from '../types-CCq0WHh9.js';
-export { D as DICT_COLLECTION_PREFIX, a as DictEntry, b as DictKeyDescriptor, c as DictionaryHandle, d as DictionaryOptions, S as ScriptWarning, e as StaticDictDescriptor, f as dictCollectionName, g as dictKey, h as enforceScript, i as inferScripts, j as isDictCollectionName, k as isDictKeyDescriptor, l as isStaticDictDescriptor, s as staticDict } from '../types-CCq0WHh9.js';
+import { I as I18nStrategy } from '../types-CkSWJt0H.js';
+export { D as DICT_COLLECTION_PREFIX, a as DictEntry, b as DictKeyDescriptor, c as DictionaryHandle, d as DictionaryOptions, S as ScriptWarning, e as StaticDictDescriptor, f as dictCollectionName, g as dictKey, h as enforceScript, i as inferScripts, j as isDictCollectionName, k as isDictKeyDescriptor, l as isStaticDictDescriptor, s as staticDict } from '../types-CkSWJt0H.js';
 export { D as DictKeyInUseError, a as DictKeyMissingError, L as LocaleNotSpecifiedError, M as MissingTranslationError, R as ReservedCollectionNameError, S as ScriptViolationError, b as StaticDictReadonlyError, T as TranslatorNotConfiguredError, U as UnknownDictCodeError } from '../errors-Dwk2k1xY.js';
 import '../lazy-builder-ChSqcF5t.js';
 import '../predicate-BmhBSPCH.js';

package/dist/i18n/index.js

@@ -7,7 +7,7 @@ import {
   isDictKeyDescriptor,
   isStaticDictDescriptor,
   staticDict
-} from "../chunk-JJKXJAH2.js";
+} from "../chunk-PFKAT4NT.js";
 import {
   applyI18nLocale,
   enforceScript,
@@ -20,9 +20,9 @@ import {
   setAtPathInPlace,
   validateI18nTextValue
 } from "../chunk-KD253AI5.js";
-import "../chunk-UNBX2HMA.js";
+import "../chunk-LXA2E3VI.js";
 import "../chunk-PDVP3C2I.js";
-import "../chunk-LR7CODVN.js";
+import "../chunk-AD6RNBAW.js";
 import "../chunk-7JSP3E67.js";
 import {
   DictKeyInUseError,

package/dist/{index-CBUhOmrM.d.cts → index-CqzZml-D.d.cts}

@@ -1,8 +1,8 @@
 import './predicate-BmhBSPCH.cjs';
 import './strategy-D1zjEV3n.cjs';
 import './ulid-DRH25k3y.cjs';
+import './types-CwrTuYFI.cjs';
 import './errors-Dwk2k1xY.cjs';
-import './types-BCYvhKzr.cjs';
 import './index-DoxKSsMj.cjs';
 
 interface EncryptResult {

package/dist/{index-DFhKV-6A.d.ts → index-wRwJVVJQ.d.ts}

@@ -1,8 +1,8 @@
 import './predicate-BmhBSPCH.js';
 import './strategy-YQ1qJWyq.js';
 import './ulid-DRH25k3y.js';
+import './types-CkSWJt0H.js';
 import './errors-Dwk2k1xY.js';
-import './types-CCq0WHh9.js';
 import './index-LaexBi3v.js';
 
 interface EncryptResult {

package/dist/index.cjs

@@ -7255,6 +7255,249 @@ var init_peer_recover = __esm({
   }
 });
 
+// src/coordination/types.ts
+function isQuorum(writers, generation, excludeWriterId) {
+  return writers.filter((w) => w.writerId !== excludeWriterId).every((w) => w.quiescedAtVersion === generation);
+}
+async function runDrainBarrier(provider, o, run) {
+  await provider.setFence(o.vault, { currentSchemaVersion: o.generation, fenceState: "draining" });
+  await o.onFlush();
+  const deadline = o.now() + o.quiesceTimeoutMs;
+  const seeded = await provider.reachableWriters(o.vault, { staleMs: o.staleMs, now: o.now() });
+  if (!isQuorum(seeded, o.generation, o.writerId)) {
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (fn) => {
+        if (!settled) {
+          settled = true;
+          unsub();
+          fn();
+        }
+      };
+      const unsub = provider.observePresence(o.vault, (writers) => {
+        if (isQuorum(writers, o.generation, o.writerId)) finish(resolve);
+      });
+      const tick = async () => {
+        if (settled) return;
+        if (o.now() >= deadline) {
+          finish(
+            () => reject(
+              new QuiesceTimeoutError(
+                `Cutover of vault "${o.vault}" to generation ${o.generation} timed out after ${o.quiesceTimeoutMs}ms waiting for active writers to quiesce.`
+              )
+            )
+          );
+          return;
+        }
+        if (o.onPoll) await o.onPoll();
+        const w = await provider.reachableWriters(o.vault, { staleMs: o.staleMs, now: o.now() });
+        if (isQuorum(w, o.generation, o.writerId)) finish(resolve);
+        else setTimeout(() => void tick(), 25);
+      };
+      void tick();
+    });
+  }
+  await run();
+}
+var init_types4 = __esm({
+  "src/coordination/types.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
+// src/schema-update/fence.ts
+async function loadFence(store, vault) {
+  const envelope = await store.get(vault, META_COLLECTION3, FENCE_RECORD_ID);
+  if (!envelope) return DEFAULT_FENCE;
+  try {
+    const parsed = JSON.parse(envelope._data);
+    if (!isFenceDoc(parsed)) return DEFAULT_FENCE;
+    return parsed;
+  } catch {
+    return DEFAULT_FENCE;
+  }
+}
+async function saveFence(store, vault, fence) {
+  const envelope = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: JSON.stringify(fence)
+  };
+  await store.put(vault, META_COLLECTION3, FENCE_RECORD_ID, envelope);
+}
+function isFenceDoc(x) {
+  if (x === null || typeof x !== "object") return false;
+  const o = x;
+  return typeof o["currentSchemaVersion"] === "number" && (o["fenceState"] === "normal" || o["fenceState"] === "draining" || o["fenceState"] === "migrating" || o["fenceState"] === "complete");
+}
+var FENCE_RECORD_ID, META_COLLECTION3, DEFAULT_FENCE;
+var init_fence = __esm({
+  "src/schema-update/fence.ts"() {
+    "use strict";
+    init_types();
+    FENCE_RECORD_ID = "schema-fence";
+    META_COLLECTION3 = "_meta";
+    DEFAULT_FENCE = { currentSchemaVersion: 0, fenceState: "normal" };
+  }
+});
+
+// src/schema-update/client-registry.ts
+async function writeClientDoc(store, vault, clientId, doc) {
+  const envelope = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: JSON.stringify({ clientId, ...doc })
+  };
+  await store.put(vault, META_COLLECTION4, `${CLIENT_PREFIX}${clientId}`, envelope);
+}
+async function listClientDocs(store, vault) {
+  const ids = await store.list(vault, META_COLLECTION4);
+  const out = [];
+  for (const id of ids) {
+    if (!id.startsWith(CLIENT_PREFIX)) continue;
+    const env = await store.get(vault, META_COLLECTION4, id);
+    if (!env) continue;
+    try {
+      const parsed = JSON.parse(env._data);
+      if (isClientDoc(parsed)) out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+function isClientDoc(x) {
+  if (x === null || typeof x !== "object") return false;
+  const o = x;
+  return typeof o["clientId"] === "string" && typeof o["lastSeen"] === "number" && (o["quiescedAtVersion"] === null || typeof o["quiescedAtVersion"] === "number") && (o["sessionId"] === void 0 || typeof o["sessionId"] === "string");
+}
+var META_COLLECTION4, CLIENT_PREFIX;
+var init_client_registry = __esm({
+  "src/schema-update/client-registry.ts"() {
+    "use strict";
+    init_types();
+    META_COLLECTION4 = "_meta";
+    CLIENT_PREFIX = "schema-fence:client:";
+  }
+});
+
+// src/coordination/store-provider.ts
+function toPresence(doc) {
+  return {
+    writerId: doc.clientId,
+    // Pre-#469 docs (and explicit empty) have no session — fall back to the
+    // writerId so every presence is session-addressable.
+    sessionId: doc.sessionId && doc.sessionId.length > 0 ? doc.sessionId : doc.clientId,
+    lastSeen: doc.lastSeen,
+    quiescedAtVersion: doc.quiescedAtVersion
+  };
+}
+function fenceEqual(a, b) {
+  return a.currentSchemaVersion === b.currentSchemaVersion && a.fenceState === b.fenceState;
+}
+function presenceListEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const key = (w) => `${w.writerId}\0${w.sessionId}\0${w.lastSeen}\0${String(w.quiescedAtVersion)}`;
+  const bk = new Set(b.map(key));
+  return a.every((w) => bk.has(key(w)));
+}
+function unref(timer) {
+  const t = timer;
+  if (typeof t.unref === "function") t.unref();
+}
+var DEFAULT_POLL_INTERVAL_MS, StoreCoordinationProvider;
+var init_store_provider = __esm({
+  "src/coordination/store-provider.ts"() {
+    "use strict";
+    init_fence();
+    init_client_registry();
+    DEFAULT_POLL_INTERVAL_MS = 50;
+    StoreCoordinationProvider = class {
+      #store;
+      #pollIntervalMs;
+      constructor(store, opts) {
+        this.#store = store;
+        this.#pollIntervalMs = opts?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+      }
+      async setFence(vault, fence) {
+        await saveFence(this.#store, vault, fence);
+      }
+      async readFence(vault) {
+        return loadFence(this.#store, vault);
+      }
+      observeFence(vault, onChange) {
+        let last = null;
+        let busy = false;
+        const poll = async () => {
+          if (busy) return;
+          busy = true;
+          try {
+            const fence = await loadFence(this.#store, vault);
+            if (last === null || !fenceEqual(last, fence)) {
+              last = fence;
+              onChange(fence);
+            }
+          } catch {
+          } finally {
+            busy = false;
+          }
+        };
+        void poll();
+        const timer = setInterval(() => void poll(), this.#pollIntervalMs);
+        unref(timer);
+        return () => clearInterval(timer);
+      }
+      async reportPresence(vault, p) {
+        await writeClientDoc(this.#store, vault, p.writerId, {
+          lastSeen: p.lastSeen,
+          quiescedAtVersion: p.quiescedAtVersion,
+          sessionId: p.sessionId
+        });
+      }
+      observePresence(vault, onChange) {
+        let last = null;
+        let busy = false;
+        const poll = async () => {
+          if (busy) return;
+          busy = true;
+          try {
+            const docs = await listClientDocs(this.#store, vault);
+            const writers = docs.map(toPresence);
+            if (last === null || !presenceListEqual(last, writers)) {
+              last = writers;
+              onChange(writers);
+            }
+          } catch {
+          } finally {
+            busy = false;
+          }
+        };
+        void poll();
+        const timer = setInterval(() => void poll(), this.#pollIntervalMs);
+        unref(timer);
+        return () => clearInterval(timer);
+      }
+      async reachableWriters(vault, o) {
+        const docs = await listClientDocs(this.#store, vault);
+        return docs.map(toPresence).filter((w) => o.now - w.lastSeen <= o.staleMs);
+      }
+    };
+  }
+});
+
+// src/coordination/index.ts
+var init_coordination = __esm({
+  "src/coordination/index.ts"() {
+    "use strict";
+    init_types4();
+    init_store_provider();
+  }
+});
+
 // src/crdt/strategy.ts
 var NOT_ENABLED, NO_CRDT;
 var init_strategy = __esm({
@@ -17764,108 +18007,18 @@ var init_magic_link_grant = __esm({
   }
 });
 
-// src/schema-update/fence.ts
-async function loadFence(store, vault) {
-  const envelope = await store.get(vault, META_COLLECTION3, FENCE_RECORD_ID);
-  if (!envelope) return DEFAULT_FENCE;
-  try {
-    const parsed = JSON.parse(envelope._data);
-    if (!isFenceDoc(parsed)) return DEFAULT_FENCE;
-    return parsed;
-  } catch {
-    return DEFAULT_FENCE;
-  }
-}
-async function saveFence(store, vault, fence) {
-  const envelope = {
-    _noydb: NOYDB_FORMAT_VERSION,
-    _v: 1,
-    _ts: (/* @__PURE__ */ new Date()).toISOString(),
-    _iv: "",
-    _data: JSON.stringify(fence)
-  };
-  await store.put(vault, META_COLLECTION3, FENCE_RECORD_ID, envelope);
-}
-function isFenceDoc(x) {
-  if (x === null || typeof x !== "object") return false;
-  const o = x;
-  return typeof o["currentSchemaVersion"] === "number" && (o["fenceState"] === "normal" || o["fenceState"] === "draining" || o["fenceState"] === "migrating" || o["fenceState"] === "complete");
-}
-var FENCE_RECORD_ID, META_COLLECTION3, DEFAULT_FENCE;
-var init_fence = __esm({
-  "src/schema-update/fence.ts"() {
-    "use strict";
-    init_types();
-    FENCE_RECORD_ID = "schema-fence";
-    META_COLLECTION3 = "_meta";
-    DEFAULT_FENCE = { currentSchemaVersion: 0, fenceState: "normal" };
-  }
-});
-
-// src/schema-update/client-registry.ts
-async function writeClientDoc(store, vault, clientId, doc) {
-  const envelope = {
-    _noydb: NOYDB_FORMAT_VERSION,
-    _v: 1,
-    _ts: (/* @__PURE__ */ new Date()).toISOString(),
-    _iv: "",
-    _data: JSON.stringify({ clientId, ...doc })
-  };
-  await store.put(vault, META_COLLECTION4, `${CLIENT_PREFIX}${clientId}`, envelope);
-}
-async function listClientDocs(store, vault) {
-  const ids = await store.list(vault, META_COLLECTION4);
-  const out = [];
-  for (const id of ids) {
-    if (!id.startsWith(CLIENT_PREFIX)) continue;
-    const env = await store.get(vault, META_COLLECTION4, id);
-    if (!env) continue;
-    try {
-      const parsed = JSON.parse(env._data);
-      if (isClientDoc(parsed)) out.push(parsed);
-    } catch {
-    }
-  }
-  return out;
-}
-async function activeQuiesced(store, vault, opts) {
-  const docs = await listClientDocs(store, vault);
-  const active = docs.filter(
-    (d) => d.lastSeen >= opts.now - opts.staleMs && d.clientId !== opts.excludeClientId
-  );
-  return active.every((d) => d.quiescedAtVersion === opts.generation);
-}
-function isClientDoc(x) {
-  if (x === null || typeof x !== "object") return false;
-  const o = x;
-  return typeof o["clientId"] === "string" && typeof o["lastSeen"] === "number" && (o["quiescedAtVersion"] === null || typeof o["quiescedAtVersion"] === "number");
-}
-var META_COLLECTION4, CLIENT_PREFIX;
-var init_client_registry = __esm({
-  "src/schema-update/client-registry.ts"() {
-    "use strict";
-    init_types();
-    META_COLLECTION4 = "_meta";
-    CLIENT_PREFIX = "schema-fence:client:";
-  }
-});
-
 // src/schema-update/fence-controller.ts
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 var SchemaFenceController;
 var init_fence_controller = __esm({
   "src/schema-update/fence-controller.ts"() {
     "use strict";
-    init_fence();
     init_errors();
-    init_client_registry();
+    init_coordination();
     SchemaFenceController = class {
-      #store;
+      #coordination;
       #vault;
       #onFlush;
-      #clientId;
+      #writerId;
       #now;
       #staleMs;
       #quiesceTimeoutMs;
@@ -17873,10 +18026,10 @@ var init_fence_controller = __esm({
       #snapshot = 0;
       #pending = /* @__PURE__ */ new Map();
       constructor(opts) {
-        this.#store = opts.store;
+        this.#coordination = opts.coordination;
         this.#vault = opts.vault;
         this.#onFlush = opts.onFlush;
-        this.#clientId = opts.clientId ?? "migrator";
+        this.#writerId = opts.clientId ?? "migrator";
         this.#now = opts.now ?? (() => Date.now());
         this.#staleMs = opts.staleMs ?? 3e4;
         this.#quiesceTimeoutMs = opts.quiesceTimeoutMs ?? 6e4;
@@ -17885,7 +18038,7 @@ var init_fence_controller = __esm({
       }
       /** Capture the generation snapshot at vault-open. */
       async init() {
-        this.#snapshot = (await loadFence(this.#store, this.#vault)).currentSchemaVersion;
+        this.#snapshot = (await this.#coordination.readFence(this.#vault)).currentSchemaVersion;
       }
       /** Record a per-collection pending cutover (from a registration `cutover` decision). */
       registerPendingCutover(collection, transform) {
@@ -17893,7 +18046,7 @@ var init_fence_controller = __esm({
       }
       /** Write-path gate. Throws when behind, fenced, or this collection is cutover-pending. */
       async assertWritable(collection) {
-        const fence = await loadFence(this.#store, this.#vault);
+        const fence = await this.#coordination.readFence(this.#vault);
         if (fence.currentSchemaVersion > this.#snapshot) {
           throw new MigrationRequiredError(
             `Vault "${this.#vault}" advanced to schema generation ${fence.currentSchemaVersion} (this client opened at ${this.#snapshot}). Reload to continue.`
@@ -17912,49 +18065,49 @@ var init_fence_controller = __esm({
        * Admin trigger. Drain → wait for the active set to quiesce (or time out)
        * → migrate each pending transform → bump → complete → normal. The
        * migrator excludes itself from the barrier (it drained synchronously
-       * here). `onPoll` (tests) advances other clients between barrier checks;
-       * production falls back to a short real delay.
+       * inside {@link runDrainBarrier}). `onPoll` (tests) advances other clients
+       * between barrier checks; production falls back to a short real delay.
        */
       async runCutover(run, opts) {
         if (this.#pending.size === 0) return { migrated: 0 };
-        const base = await loadFence(this.#store, this.#vault);
+        const base = await this.#coordination.readFence(this.#vault);
         const generation = base.currentSchemaVersion;
-        await this.#setState(generation, "draining");
-        await this.#onFlush();
-        const deadline = this.#now() + this.#quiesceTimeoutMs;
-        while (!await activeQuiesced(this.#store, this.#vault, {
-          generation,
-          now: this.#now(),
-          staleMs: this.#staleMs,
-          excludeClientId: this.#clientId
-        })) {
-          if (this.#now() >= deadline) {
-            throw new QuiesceTimeoutError(
-              `Cutover on "${this.#vault}" timed out waiting for clients to quiesce at generation ${generation}.`
-            );
-          }
-          await (opts?.onPoll ? opts.onPoll() : delay(50));
-        }
-        await this.#setState(generation, "migrating");
+        this.#emit({ currentSchemaVersion: generation, fenceState: "draining" });
         let migrated = 0;
-        for (const [collection, transform] of this.#pending) {
-          await run(collection, transform);
-          migrated++;
-        }
-        const nextVersion = generation + 1;
-        await this.#setState(nextVersion, "complete");
-        this.#pending.clear();
-        await this.#setState(nextVersion, "normal");
-        this.#snapshot = nextVersion;
+        await runDrainBarrier(
+          this.#coordination,
+          {
+            vault: this.#vault,
+            generation,
+            writerId: this.#writerId,
+            onFlush: this.#onFlush,
+            staleMs: this.#staleMs,
+            quiesceTimeoutMs: this.#quiesceTimeoutMs,
+            now: this.#now,
+            ...opts?.onPoll ? { onPoll: opts.onPoll } : {}
+          },
+          async () => {
+            await this.#setState(generation, "migrating");
+            for (const [collection, transform] of this.#pending) {
+              await run(collection, transform);
+              migrated++;
+            }
+            const nextVersion = generation + 1;
+            await this.#setState(nextVersion, "complete");
+            this.#pending.clear();
+            await this.#setState(nextVersion, "normal");
+            this.#snapshot = nextVersion;
+          }
+        );
         return { migrated };
       }
       /** Recover a stuck drain: reset fenceState to normal at the current version (no bump). */
       async abort() {
-        const fence = await loadFence(this.#store, this.#vault);
+        const fence = await this.#coordination.readFence(this.#vault);
         await this.#setState(fence.currentSchemaVersion, "normal");
       }
       async #setState(currentSchemaVersion, fenceState) {
-        await saveFence(this.#store, this.#vault, { currentSchemaVersion, fenceState });
+        await this.#coordination.setFence(this.#vault, { currentSchemaVersion, fenceState });
         this.#emit({ currentSchemaVersion, fenceState });
       }
     };
@@ -17966,12 +18119,11 @@ var FenceWatcher;
 var init_fence_watcher = __esm({
   "src/schema-update/fence-watcher.ts"() {
     "use strict";
-    init_fence();
-    init_client_registry();
     FenceWatcher = class {
-      #store;
+      #coordination;
       #vault;
-      #clientId;
+      #writerId;
+      #sessionId;
       #onFlush;
       #now;
       #emit;
@@ -17979,9 +18131,10 @@ var init_fence_watcher = __esm({
       #quiescedAtVersion = null;
       #timer;
       constructor(opts) {
-        this.#store = opts.store;
+        this.#coordination = opts.coordination;
         this.#vault = opts.vault;
-        this.#clientId = opts.clientId;
+        this.#writerId = opts.clientId;
+        this.#sessionId = opts.sessionId ?? opts.clientId;
         this.#onFlush = opts.onFlush;
         this.#now = opts.now ?? (() => Date.now());
         this.#emit = opts.emit ?? (() => {
@@ -17989,14 +18142,16 @@ var init_fence_watcher = __esm({
       }
       /** Publish liveness (and the current ack) without changing quiesce state. */
       async beat() {
-        await writeClientDoc(this.#store, this.#vault, this.#clientId, {
+        await this.#coordination.reportPresence(this.#vault, {
+          writerId: this.#writerId,
+          sessionId: this.#sessionId,
           lastSeen: this.#now(),
           quiescedAtVersion: this.#quiescedAtVersion
         });
       }
       /** Poll the fence; quiesce on draining; emit on transitions. */
       async check() {
-        const fence = await loadFence(this.#store, this.#vault);
+        const fence = await this.#coordination.readFence(this.#vault);
         if (fence.fenceState !== this.#lastState) {
           this.#lastState = fence.fenceState;
           this.#emit({ currentSchemaVersion: fence.currentSchemaVersion, fenceState: fence.fenceState });
@@ -19308,10 +19463,11 @@ var init_vault = __esm({
         this.keyring = opts.keyring;
         this.encrypted = opts.encrypted;
         this.schemaFence = new SchemaFenceController({
-          store: this.adapter,
+          coordination: this.noydb.coordination,
           vault: this.name,
           onFlush: () => this.noydb._writeQueueTracker.onFlush(),
           clientId: this.noydb._clientId,
+          sessionId: this.noydb._sessionId,
           emit: (e) => this.emitter.emit("schema:fence-changed", { vault: this.name, ...e })
         });
         this.emitter = opts.emitter;
@@ -19707,9 +19863,10 @@ var init_vault = __esm({
         if (this.#fenceCoordinationStarted) return;
         this.#fenceCoordinationStarted = true;
         this.#fenceWatcher = new FenceWatcher({
-          store: this.adapter,
+          coordination: this.noydb.coordination,
           vault: this.name,
           clientId: this.noydb._clientId,
+          sessionId: this.noydb._sessionId,
           onFlush: () => this.noydb._writeQueueTracker.onFlush(),
           emit: (e) => this.emitter.emit("schema:fence-changed", { vault: this.name, ...e })
         });
@@ -23450,6 +23607,7 @@ var init_noydb = __esm({
     init_recovery();
     init_managed_passphrase();
     init_ulid();
+    init_coordination();
     init_errors2();
     init_auth_introspection();
     init_public_envelope();
@@ -23493,6 +23651,10 @@ var init_noydb = __esm({
       writeHooks = new WriteHookRegistry();
       subsystemBus = new SubsystemBus();
       clientId = generateULID();
+      /** Session that owns this instance's writers (one user's writers across vaults). */
+      sessionId;
+      /** Drain-barrier coordination transport for the schema fence (#469). */
+      coordinationProvider;
       vaultCache = /* @__PURE__ */ new Map();
       keyringCache = /* @__PURE__ */ new Map();
       syncEngines = /* @__PURE__ */ new Map();
@@ -23567,6 +23729,8 @@ var init_noydb = __esm({
             "[noydb] debugPlaintext is ON \u2014 records are stored UNENCRYPTED and laid out for native store inspection. NEVER use this for production or client data."
           );
         }
+        this.sessionId = options.sessionId ?? generateULID();
+        this.coordinationProvider = options.coordinationStrategy ?? new StoreCoordinationProvider(options.store);
         this.txStrategy = options.txStrategy ?? NO_TX;
         this.forgetStrategy = options.forgetStrategy ?? NO_FORGET;
         this.sessionStrategy = options.sessionStrategy ?? NO_SESSION;
@@ -24620,6 +24784,18 @@ var init_noydb = __esm({
       get _clientId() {
         return this.clientId;
       }
+      /** @internal Session that owns this instance's writers (#469). */
+      get _sessionId() {
+        return this.sessionId;
+      }
+      /**
+       * @internal Drain-barrier coordination transport for the schema fence (#469).
+       * The default store-backed provider reproduces today's fence behavior; a
+       * `by-*` real-time transport is injected via `coordinationStrategy`.
+       */
+      get coordination() {
+        return this.coordinationProvider;
+      }
       /**
        * Soft-lock a single vault: clear its in-memory keyring, DEKs, vault
        * instance, sync engine, policy enforcer, and active-tier entry —
@@ -28036,8 +28212,8 @@ function withRetry(opts = {}) {
       } catch (err) {
         lastError = err;
         if (attempt >= maxRetries || !shouldRetry(err)) throw err;
-        const delay2 = backoffMs * Math.pow(2, attempt) * (1 + Math.random() * jitter);
-        await new Promise((r) => setTimeout(r, delay2));
+        const delay = backoffMs * Math.pow(2, attempt) * (1 + Math.random() * jitter);
+        await new Promise((r) => setTimeout(r, delay));
       }
     }
     throw lastError;