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

package/dist/i18n/index.js

@@ -1,27 +1,41 @@
 import {
-  enforceScript,
-  inferScripts
-} from "../chunk-6STK5TQP.js";
+  withLookup
+} from "../chunk-JJZ2LW6T.js";
+import {
+  dictKey,
+  staticDict
+} from "../chunk-ET67AY6B.js";
 import {
   DICT_COLLECTION_PREFIX,
-  DictionaryHandle,
+  LookupHandle,
+  dictCollectionName
+} from "../chunk-NUEQU36L.js";
+import "../chunk-UF362QVH.js";
+import "../chunk-MCHVVJIA.js";
+import "../chunk-QA2KUPCP.js";
+import "../chunk-2OV5NVE7.js";
+import "../chunk-VEPTFUJY.js";
+import "../chunk-HYR4WZZ3.js";
+import "../chunk-LP7BEXCT.js";
+import "../chunk-3OPY6MK2.js";
+import "../chunk-YN5IAHN6.js";
+import {
   applyI18nLocale,
-  dictCollectionName,
-  dictKey,
+  enforceScript,
   getAtPath,
   i18nText,
+  inferScripts,
   isDictCollectionName,
   isDictKeyDescriptor,
   isI18nTextDescriptor,
+  isStaticDictDescriptor,
+  presentI18nForJoin,
   resolveI18nText,
   resolvePolicy,
-  setAtPathInPlace,
+  stripI18nFilled,
   validateI18nTextValue
-} from "../chunk-22DWZL57.js";
-import "../chunk-DONMZAD2.js";
-import "../chunk-Z6FNBOTC.js";
-import "../chunk-WIRRPTFH.js";
-import "../chunk-PP6W64Y3.js";
+} from "../chunk-EOXAAJTY.js";
+import "../chunk-VEAVKDDB.js";
 import {
   DictKeyInUseError,
   DictKeyMissingError,
@@ -29,28 +43,117 @@ import {
   MissingTranslationError,
   ReservedCollectionNameError,
   ScriptViolationError,
-  TranslatorNotConfiguredError
-} from "../chunk-B6PB7JLN.js";
+  StaticDictReadonlyError,
+  TranslatorNotConfiguredError,
+  UnknownDictCodeError
+} from "../chunk-S7VFUQM2.js";
+import "../chunk-PZ5AY32C.js";
+
+// src/via/i18n/densify.ts
+var MARKER = "_i18nFilled";
+function priorFilled(prior, field) {
+  if (!prior) return /* @__PURE__ */ new Set();
+  const marker = prior[MARKER];
+  return new Set(marker?.[field] ?? []);
+}
+function singleLeaf(record, field) {
+  const leaves = getAtPath(record, field);
+  if (leaves.length !== 1) return void 0;
+  const leaf = leaves[0];
+  if (!leaf || typeof leaf !== "object" || Array.isArray(leaf)) return void 0;
+  return leaf;
+}
+function computeExemptFills(prior, incoming, fields) {
+  const out = /* @__PURE__ */ new Map();
+  if (!prior) return out;
+  for (const field of Object.keys(fields)) {
+    const filled = priorFilled(prior, field);
+    if (filled.size === 0) continue;
+    const priorLeaf = singleLeaf(prior, field);
+    const incLeaf = singleLeaf(incoming, field);
+    if (!priorLeaf || !incLeaf) continue;
+    const exempt = /* @__PURE__ */ new Set();
+    for (const loc of filled) {
+      if (incLeaf[loc] !== void 0 && incLeaf[loc] !== "" && incLeaf[loc] === priorLeaf[loc]) {
+        exempt.add(loc);
+      }
+    }
+    if (exempt.size > 0) out.set(field, exempt);
+  }
+  return out;
+}
+function densify(record, prior, fields) {
+  let marker = record[MARKER];
+  for (const [field, descriptor] of Object.entries(fields)) {
+    const leaf = singleLeaf(record, field);
+    if (!leaf) continue;
+    const { languages, substitute, smartSubstitute } = descriptor.options;
+    const filledSet = priorFilled(prior, field);
+    const priorLeaf = singleLeaf(prior ?? {}, field);
+    const isUnchangedFill = (loc) => filledSet.has(loc) && priorLeaf?.[loc] !== void 0 && leaf[loc] === priorLeaf[loc];
+    const authored = {};
+    for (const [loc, val] of Object.entries(leaf)) {
+      if (typeof val === "string" && val !== "" && !isUnchangedFill(loc)) authored[loc] = val;
+    }
+    const filled = [];
+    for (const loc of languages) {
+      if (authored[loc] !== void 0) continue;
+      const sub = resolveI18nText(authored, loc, void 0, field, {
+        policy: "substitute",
+        substitute: substitute ?? ["any"],
+        ...smartSubstitute ? { smartSubstitute } : {}
+      });
+      if (typeof sub === "string" && sub !== "") {
+        leaf[loc] = sub;
+        filled.push(loc);
+      } else if (isUnchangedFill(loc)) {
+        delete leaf[loc];
+      }
+    }
+    if (filled.length > 0) {
+      marker ??= {};
+      marker[field] = filled;
+    } else if (marker) {
+      delete marker[field];
+    }
+  }
+  if (marker && Object.keys(marker).length > 0) {
+    record[MARKER] = marker;
+  } else {
+    delete record[MARKER];
+  }
+}
 
-// src/i18n/active.ts
+// src/via/i18n/active.ts
 function withI18n() {
+  const lookup = withLookup();
   return {
     applyI18nLocale,
     validateI18nTextValue,
     enforceScript,
+    computeExemptFills,
+    densify,
     buildDictionaryHandle(opts) {
-      return new DictionaryHandle(
-        opts.adapter,
-        opts.compartmentName,
-        opts.dictionaryName,
-        opts.keyring,
-        opts.getDEK,
-        opts.encrypted,
-        opts.ledger,
-        opts.options,
-        opts.findAndUpdateReferences,
-        opts.emitter
-      );
+      return lookup.buildLookupHandle({
+        adapter: opts.adapter,
+        compartmentName: opts.compartmentName,
+        dimensionName: opts.dictionaryName,
+        keyring: opts.keyring,
+        reservedEnvelopes: opts.reservedEnvelopes,
+        encrypted: opts.encrypted,
+        ledger: opts.ledger,
+        options: opts.options,
+        findAndUpdateReferences: opts.findAndUpdateReferences,
+        emitter: opts.emitter,
+        buildDeleteMarker: opts.buildDeleteMarker,
+        // #647 fix wave 1
+        onDirty: opts.onDirty,
+        // #650 Task 4
+        onRecordMutated: opts.onRecordMutated,
+        // #650 Task 4
+        checkReferencesOnDelete: opts.checkReferencesOnDelete
+        // #650 Task 5
+      });
     }
   };
 }
@@ -58,12 +161,14 @@ export {
   DICT_COLLECTION_PREFIX,
   DictKeyInUseError,
   DictKeyMissingError,
-  DictionaryHandle,
+  LookupHandle as DictionaryHandle,
   LocaleNotSpecifiedError,
   MissingTranslationError,
   ReservedCollectionNameError,
   ScriptViolationError,
+  StaticDictReadonlyError,
   TranslatorNotConfiguredError,
+  UnknownDictCodeError,
   applyI18nLocale,
   dictCollectionName,
   dictKey,
@@ -74,9 +179,12 @@ export {
   isDictCollectionName,
   isDictKeyDescriptor,
   isI18nTextDescriptor,
+  isStaticDictDescriptor,
+  presentI18nForJoin,
   resolveI18nText,
   resolvePolicy,
-  setAtPathInPlace,
+  staticDict,
+  stripI18nFilled,
   validateI18nTextValue,
   withI18n
 };

package/dist/i18n/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/i18n/active.ts"],"sourcesContent":["/**\n * Active i18n strategy — `withI18n()` returns the real implementation\n * that wires multi-locale resolution, i18nText validation, and the\n * `DictionaryHandle` for `dictKey` fields into the core read/write\n * paths.\n *\n * Consumers opt in by:\n *\n * ```ts\n * import { createNoydb } from '@noy-db/hub'\n * import { withI18n } from '@noy-db/hub/i18n'\n *\n * const db = await createNoydb({\n *   store: ...,\n *   user: ...,\n *   i18nStrategy: withI18n(),\n * })\n * ```\n *\n * The factory delegates to the existing `core.ts` and `dictionary.ts`\n * modules. Splitting the import chain through this file is what lets\n * tsup tree-shake the `~854 LOC` of dictionary + locale resolution\n * out of the default bundle when no `withI18n()` import is present.\n *\n * @public\n */\n\nimport type { I18nStrategy, BuildDictionaryHandleOptions } from './strategy.js'\nimport { applyI18nLocale, validateI18nTextValue } from './core.js'\nimport { enforceScript } from './script.js'\nimport { DictionaryHandle } from './dictionary.js'\n\nexport function withI18n(): I18nStrategy {\n  return {\n    applyI18nLocale,\n    validateI18nTextValue,\n    enforceScript,\n    buildDictionaryHandle<Keys extends string = string>(\n      opts: BuildDictionaryHandleOptions<Keys>,\n    ): DictionaryHandle<Keys> {\n      return new DictionaryHandle<Keys>(\n        opts.adapter,\n        opts.compartmentName,\n        opts.dictionaryName,\n        opts.keyring,\n        opts.getDEK,\n        opts.encrypted,\n        opts.ledger,\n        opts.options,\n        opts.findAndUpdateReferences,\n        opts.emitter,\n      )\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCO,SAAS,WAAyB;AACvC,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,sBACE,MACwB;AACxB,aAAO,IAAI;AAAA,QACT,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,MACP;AAAA,IACF;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/via/i18n/densify.ts","../../src/via/i18n/active.ts"],"sourcesContent":["/**\n * `densifyOnWrite` — eager-fill empty i18n slots from each field's\n * substitute chain at write time, recording provenance in the internal\n * `_i18nFilled` marker (decision A: dense map + prior-read).\n *\n * Pure functions over plain records; all DB wiring lives in collection.ts.\n * Only single-leaf i18n fields are supported (array-wildcard paths are\n * skipped, mirroring auto-translate).\n */\nimport { getAtPath, resolveI18nText } from './core.js'\nimport type { I18nTextDescriptor } from './core.js'\n\nconst MARKER = '_i18nFilled'\n\ntype Leaf = Record<string, string>\n\n/** Locales recorded as densify-filled on the prior record for `field`. */\nfunction priorFilled(prior: Record<string, unknown> | undefined, field: string): Set<string> {\n  if (!prior) return new Set()\n  const marker = prior[MARKER] as Record<string, string[]> | undefined\n  return new Set(marker?.[field] ?? [])\n}\n\n/** The single leaf map for `field`, or undefined for absent / array-wildcard / non-object. */\nfunction singleLeaf(record: Record<string, unknown>, field: string): Leaf | undefined {\n  const leaves = getAtPath(record, field)\n  if (leaves.length !== 1) return undefined\n  const leaf = leaves[0]\n  if (!leaf || typeof leaf !== 'object' || Array.isArray(leaf)) return undefined\n  return leaf as Leaf\n}\n\n/**\n * Per field, the locales that are UNCHANGED round-tripped densify fills — i.e.\n * marked filled on the prior record AND identical in the incoming record.\n * These are exempt from write-time script enforcement (they are derived copies,\n * not authored text). Slots the user changed are NOT exempt (validated as authored).\n */\nexport function computeExemptFills(\n  prior: Record<string, unknown> | undefined,\n  incoming: Record<string, unknown>,\n  fields: Record<string, I18nTextDescriptor>,\n): Map<string, Set<string>> {\n  const out = new Map<string, Set<string>>()\n  if (!prior) return out\n  for (const field of Object.keys(fields)) {\n    const filled = priorFilled(prior, field)\n    if (filled.size === 0) continue\n    const priorLeaf = singleLeaf(prior, field)\n    const incLeaf = singleLeaf(incoming, field)\n    if (!priorLeaf || !incLeaf) continue\n    const exempt = new Set<string>()\n    for (const loc of filled) {\n      if (incLeaf[loc] !== undefined && incLeaf[loc] !== '' && incLeaf[loc] === priorLeaf[loc]) {\n        exempt.add(loc)\n      }\n    }\n    if (exempt.size > 0) out.set(field, exempt)\n  }\n  return out\n}\n\n/**\n * Mutate `record` in place: fill empty declared-language slots for each\n * densify-enabled field from the field's substitute chain, recompute unchanged\n * prior fills, clear marks for slots that became authored, and write the\n * resulting `_i18nFilled` marker (removed when empty).\n *\n * `prior` is read-only — it is never mutated.\n *\n * Provenance uses value-equality (decision A): a slot counts as an unchanged\n * fill when it was prior-marked AND its value still equals the prior value. A\n * consequence is that re-authoring a value byte-identical to the existing fill\n * keeps it classified as a fill (the visible value is unchanged either way; the\n * slot stays script-exempt and will auto-refresh if its source later changes).\n * This is inherent to value-equality provenance, not a bug.\n */\nexport function densify(\n  record: Record<string, unknown>,\n  prior: Record<string, unknown> | undefined,\n  fields: Record<string, I18nTextDescriptor>,\n): void {\n  let marker = record[MARKER] as Record<string, string[]> | undefined\n\n  for (const [field, descriptor] of Object.entries(fields)) {\n    const leaf = singleLeaf(record, field)\n    if (!leaf) continue\n    const { languages, substitute, smartSubstitute } = descriptor.options\n    const filledSet = priorFilled(prior, field)\n    const priorLeaf = singleLeaf(prior ?? {}, field)\n    const isUnchangedFill = (loc: string): boolean =>\n      filledSet.has(loc) && priorLeaf?.[loc] !== undefined && leaf[loc] === priorLeaf[loc]\n\n    // Authored source = present, non-empty, NOT an unchanged prior fill.\n    const authored: Leaf = {}\n    for (const [loc, val] of Object.entries(leaf)) {\n      if (typeof val === 'string' && val !== '' && !isUnchangedFill(loc)) authored[loc] = val\n    }\n\n    const filled: string[] = []\n    for (const loc of languages) {\n      if (authored[loc] !== undefined) continue // real value present → not a fill\n      const sub = resolveI18nText(authored, loc, undefined, field, {\n        policy: 'substitute',\n        substitute: substitute ?? ['any'],\n        ...(smartSubstitute ? { smartSubstitute } : {}),\n      })\n      if (typeof sub === 'string' && sub !== '') {\n        leaf[loc] = sub\n        filled.push(loc)\n      } else if (isUnchangedFill(loc)) {\n        delete leaf[loc] // stale fill with no source left → drop it\n      }\n    }\n\n    if (filled.length > 0) {\n      marker ??= {}\n      marker[field] = filled\n    } else if (marker) {\n      delete marker[field]\n    }\n  }\n\n  if (marker && Object.keys(marker).length > 0) {\n    record[MARKER] = marker\n  } else {\n    delete record[MARKER]\n  }\n}\n","/**\n * Active i18n strategy — `withI18n()` returns the real implementation\n * that wires multi-locale resolution, i18nText validation, and the\n * `DictionaryHandle` for `dictKey` fields into the core read/write\n * paths.\n *\n * Consumers opt in by:\n *\n * ```ts\n * import { createNoydb } from '@noy-db/hub'\n * import { withI18n } from '@noy-db/hub/i18n'\n *\n * const db = await createNoydb({\n *   store: ...,\n *   user: ...,\n *   i18nStrategy: withI18n(),\n * })\n * ```\n *\n * The factory delegates to the existing `core.ts` and `dictionary.ts`\n * modules. Splitting the import chain through this file is what lets\n * tsup tree-shake the `~854 LOC` of dictionary + locale resolution\n * out of the default bundle when no `withI18n()` import is present.\n *\n * @public\n */\n\nimport type { I18nStrategy, BuildDictionaryHandleOptions } from './strategy.js'\nimport { applyI18nLocale, validateI18nTextValue } from './core.js'\nimport { enforceScript } from './script.js'\nimport { computeExemptFills, densify } from './densify.js'\nimport type { DictionaryHandle } from './dictionary.js'\nimport { withLookup } from '../lookup/active.js'\n\nexport function withI18n(): I18nStrategy {\n  // #650 Task 1: the handle-construction logic moved to\n  // via/lookup/active.ts (LookupHandle, renamed from\n  // DictionaryHandle, new home). buildDictionaryHandle below is now a\n  // thin field-name translator over buildLookupHandle — same handle.\n  const lookup = withLookup()\n  return {\n    applyI18nLocale,\n    validateI18nTextValue,\n    enforceScript,\n    computeExemptFills,\n    densify,\n    buildDictionaryHandle<Keys extends string = string>(\n      opts: BuildDictionaryHandleOptions<Keys>,\n    ): DictionaryHandle<Keys> {\n      return lookup.buildLookupHandle<Keys>({\n        adapter: opts.adapter,\n        compartmentName: opts.compartmentName,\n        dimensionName: opts.dictionaryName,\n        keyring: opts.keyring,\n        reservedEnvelopes: opts.reservedEnvelopes,\n        encrypted: opts.encrypted,\n        ledger: opts.ledger,\n        options: opts.options,\n        findAndUpdateReferences: opts.findAndUpdateReferences,\n        emitter: opts.emitter,\n        buildDeleteMarker: opts.buildDeleteMarker, // #647 fix wave 1\n        onDirty: opts.onDirty, // #650 Task 4\n        onRecordMutated: opts.onRecordMutated, // #650 Task 4\n        checkReferencesOnDelete: opts.checkReferencesOnDelete, // #650 Task 5\n      })\n    },\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/in/index.d.ts

@@ -0,0 +1,4 @@
+export { e_ as ChangeEvent, bN as Collection, gR as LiveQuery, hs as Noydb, ef as Query, V as Vault } from '../index-DjWbxsjb.js';
+import '../subject-index-CyOgGMJL.js';
+import '../index-B9QdHytu.js';
+import '@noy-db/attestation';

package/dist/in/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=index.js.map

package/dist/in/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index-B9QdHytu.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Hub-level write lifecycle hooks. `onBeforeWrite` may abort (throw);
+ * `onAfterWrite` is awaited and its errors are warned, not thrown. A
+ * re-entrancy flag suppresses nested firing so a handler that writes can't
+ * loop. Held on the Noydb instance, threaded into every Collection.
+ */
+interface WriteEvent {
+    readonly op: 'create' | 'update' | 'delete';
+    readonly vault: string;
+    readonly collection: string;
+    readonly docId: string;
+    readonly before: unknown;
+    readonly after: unknown;
+    readonly baseVersion: number;
+    readonly version: number;
+    readonly userId: string;
+    readonly timestamp: number;
+    readonly txId: string;
+}
+type WriteHook = (event: WriteEvent) => void | Promise<void>;
+type Unsubscribe = () => void;
+declare class WriteHookRegistry {
+    #private;
+    /** True while handlers are running — used by the write path to skip nested firing. */
+    get suppressed(): boolean;
+    /** True when any hook is registered (cheap gate for the write path). */
+    get hasHandlers(): boolean;
+    onBeforeWrite(handler: WriteHook): Unsubscribe;
+    onAfterWrite(handler: WriteHook): Unsubscribe;
+    /** Run before-hooks (awaited, in order). A throw propagates and aborts the write. */
+    runBefore(event: WriteEvent): Promise<void>;
+    /** Run after-hooks (awaited, in order). Per-handler errors are warned, not thrown. */
+    runAfter(event: WriteEvent): Promise<void>;
+}
+
+/**
+ * Kernel coordination port — the injected `CoordinationProvider` seam for the
+ * schema-fence drain-barrier.
+ *
+ * The kernel defines this port; `@noy-db/by-tabs` / `@noy-db/by-peer` implement
+ * it for real-time quorum, and an external orchestrator (`@klum-db/lobby`)
+ * drives it through the `Noydb` handle without ever naming a `by-*` package.
+ * The dependency arrow is `by-* → kernel ← klum`, the app at the apex.
+ *
+ * This module carries only the port TYPES plus two pure-ish helpers:
+ * {@link isQuorum} (a pure quorum predicate extracted from the legacy
+ * `activeQuiesced`) and {@link runDrainBarrier} (the reusable barrier protocol
+ * the migration cutover and klum both call).
+ *
+ * @module
+ */
+
+/** Vault fence state (the existing FenceDoc shape). */
+interface FenceState {
+    readonly currentSchemaVersion: number;
+    readonly fenceState: 'normal' | 'draining' | 'migrating' | 'complete';
+}
+/** A writer's presence + ack, tagged with the session that owns it. */
+interface WriterPresence {
+    /** = today's clientId (one per tab/peer). */
+    readonly writerId: string;
+    /** Groups one user's writers across vaults (consolidation is klum's job). */
+    readonly sessionId: string;
+    readonly lastSeen: number;
+    readonly quiescedAtVersion: number | null;
+}
+/** Session-addressable drain-barrier coordination transport. Per-vault ops. */
+interface CoordinationProvider {
+    /** orchestrator → all writers */
+    setFence(vault: string, fence: FenceState): Promise<void>;
+    /**
+     * Fresh one-shot fence read for the write-path gate (`assertWritable`).
+     * A direct read (not a cached `observeFence` snapshot) avoids a staleness
+     * window and keeps the timing-sensitive cutover gate exact. The store
+     * default reads `_meta/schema-fence`; `by-*` return their last-pushed fence.
+     */
+    readFence(vault: string): Promise<FenceState>;
+    /** writer observes fence changes (default: poll-emit; by-*: push) */
+    observeFence(vault: string, onChange: (f: FenceState) => void): Unsubscribe;
+    /** writer → orchestrator: presence + ack (heartbeat + quiescedAtVersion) */
+    reportPresence(vault: string, p: WriterPresence): Promise<void>;
+    /** orchestrator observes presence changes (default: poll-emit; by-*: push) */
+    observePresence(vault: string, onChange: (writers: readonly WriterPresence[]) => void): Unsubscribe;
+    /** orchestrator one-shot snapshot of reachable writers (quorum input) */
+    reachableWriters(vault: string, o: {
+        staleMs: number;
+        now: number;
+    }): Promise<readonly WriterPresence[]>;
+}
+/**
+ * Pure quorum predicate: true when every writer (other than `excludeWriterId`)
+ * has acked at exactly `generation`. An empty set is trivially a quorum.
+ *
+ * Extracted from the legacy `activeQuiesced` store-polling check so the
+ * migration cutover, the store default provider, and `by-*` real-time
+ * providers all share one definition of "everyone has drained".
+ */
+declare function isQuorum(writers: readonly WriterPresence[], generation: number, excludeWriterId?: string): boolean;
+/** Inputs for {@link runDrainBarrier}. */
+interface DrainBarrierOptions {
+    readonly vault: string;
+    readonly generation: number;
+    readonly writerId: string;
+    readonly onFlush: () => Promise<void>;
+    readonly staleMs: number;
+    readonly quiesceTimeoutMs: number;
+    readonly now: () => number;
+    /** Optional seam (mainly for deterministic tests) run before each poll tick. */
+    readonly onPoll?: () => Promise<void>;
+}
+/**
+ * The reusable drain-barrier protocol shared by the migration cutover and klum:
+ *
+ *   drain self → setFence(draining) → await quorum (presence push + isQuorum,
+ *   polling as a fallback, or timeout) → run() → release-by-caller.
+ *
+ * Resolves once every reachable writer (excluding `writerId`) has quiesced at
+ * `generation`, at which point `run` is invoked exactly once. Rejects with
+ * {@link QuiesceTimeoutError} if `quiesceTimeoutMs` elapses first.
+ */
+declare function runDrainBarrier(provider: CoordinationProvider, o: DrainBarrierOptions, run: () => Promise<void>): Promise<void>;
+
+export { type CoordinationProvider as C, type DrainBarrierOptions as D, type FenceState as F, type Unsubscribe as U, type WriteEvent as W, type WriteHook as a, WriteHookRegistry as b, type WriterPresence as c, isQuorum as i, runDrainBarrier as r };