@noy-db/hub 0.3.0-pre.10 → 0.3.0-pre.12

package/dist/extract-partition-RNENZZ4T.js

@@ -1,36 +0,0 @@
-import {
-  extractPartition,
-  extractPartitionCore,
-  reKeyBlobs,
-  reKeyClosure,
-  reKeyLedger,
-  reKeySchemas,
-  sealDeks
-} from "./chunk-YMVQD5Q5.js";
-import "./chunk-T7WSLRAU.js";
-import "./chunk-XH7XP3OL.js";
-import "./chunk-QSFOZUYL.js";
-import "./chunk-OXCSVM3B.js";
-import "./chunk-ZJADGNYF.js";
-import "./chunk-I7FD46FF.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 "./chunk-S7VFUQM2.js";
-import "./chunk-PZ5AY32C.js";
-export {
-  extractPartition,
-  extractPartitionCore,
-  reKeyBlobs,
-  reKeyClosure,
-  reKeyLedger,
-  reKeySchemas,
-  sealDeks
-};
-//# sourceMappingURL=extract-partition-RNENZZ4T.js.map

package/dist/fanout-sidecar-OFWN3NM7.js

@@ -1,74 +0,0 @@
-import {
-  openEnvelopeJson
-} from "./chunk-MCHVVJIA.js";
-import "./chunk-QA2KUPCP.js";
-import "./chunk-2OV5NVE7.js";
-import "./chunk-VEPTFUJY.js";
-import "./chunk-HYR4WZZ3.js";
-import "./chunk-LP7BEXCT.js";
-import {
-  encrypt
-} from "./chunk-3OPY6MK2.js";
-import {
-  NOYDB_FORMAT_VERSION
-} from "./chunk-YN5IAHN6.js";
-import "./chunk-S7VFUQM2.js";
-import "./chunk-PZ5AY32C.js";
-
-// src/with-formula/derivations/fanout-sidecar.ts
-var FANOUT_DEK_COLLECTION = "_meta";
-function recordId(source, sourceId, outputKey) {
-  return `derivations-fanout/${source}/${sourceId}/${outputKey}`;
-}
-async function loadFanoutSidecar(store, vault, source, sourceId, outputKey, getDEK, encrypted) {
-  const envelope = await store.get(vault, "_meta", recordId(source, sourceId, outputKey));
-  if (!envelope) return void 0;
-  const json = !encrypted || envelope._iv === "" ? envelope._data : await openEnvelopeJson(envelope, await getDEK(FANOUT_DEK_COLLECTION));
-  const parsed = JSON.parse(json);
-  if (parsed._noydb_fanout !== 1) return void 0;
-  if (!Array.isArray(parsed.keys)) return void 0;
-  return parsed;
-}
-async function saveFanoutSidecar(store, vault, payload, getDEK, encrypted) {
-  const doc = {
-    _noydb_fanout: 1,
-    source: payload.source,
-    sourceId: payload.sourceId,
-    outputKey: payload.outputKey,
-    outputCollection: payload.outputCollection,
-    keys: payload.keys,
-    emittedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const id = recordId(payload.source, payload.sourceId, payload.outputKey);
-  const prior = await store.get(vault, "_meta", id);
-  const json = JSON.stringify(doc);
-  let envelope;
-  if (!encrypted) {
-    envelope = {
-      _noydb: NOYDB_FORMAT_VERSION,
-      _v: (prior?._v ?? 0) + 1,
-      _ts: (/* @__PURE__ */ new Date()).toISOString(),
-      _iv: "",
-      _data: json
-    };
-  } else {
-    const { iv, data } = await encrypt(json, await getDEK(FANOUT_DEK_COLLECTION));
-    envelope = {
-      _noydb: NOYDB_FORMAT_VERSION,
-      _v: (prior?._v ?? 0) + 1,
-      _ts: (/* @__PURE__ */ new Date()).toISOString(),
-      _iv: iv,
-      _data: data
-    };
-  }
-  await store.put(vault, "_meta", id, envelope);
-}
-async function deleteFanoutSidecar(store, vault, source, sourceId, outputKey) {
-  await store.delete(vault, "_meta", recordId(source, sourceId, outputKey));
-}
-export {
-  deleteFanoutSidecar,
-  loadFanoutSidecar,
-  saveFanoutSidecar
-};
-//# sourceMappingURL=fanout-sidecar-OFWN3NM7.js.map

package/dist/find-BNGBJNKP.js

@@ -1,11 +0,0 @@
-import {
-  computeBidxTarget
-} from "./chunk-HYR4WZZ3.js";
-import "./chunk-LP7BEXCT.js";
-import "./chunk-3OPY6MK2.js";
-import "./chunk-S7VFUQM2.js";
-import "./chunk-PZ5AY32C.js";
-export {
-  computeBidxTarget
-};
-//# sourceMappingURL=find-BNGBJNKP.js.map

package/dist/forget/index.d.ts

@@ -1,36 +0,0 @@
-import { S as SubjectDeclaration, F as ForgetStrategy } from '../subject-index-CyOgGMJL.js';
-export { a as ForgetResult, N as NO_FORGET, b as SUBJECT_INDEX_COLLECTION, c as SubjectRef } from '../subject-index-CyOgGMJL.js';
-
-/**
- * `withForgetCascade` — the active factory for GDPR right-to-erasure via
- * per-record CEK crypto-shred. Mirrors the canonical
- * `strategy.ts` (type + `NO_FORGET` sentinel) / `active.ts` (factory) split
- * used by the other services.
- *
- * @module
- */
-
-/**
- * Declare GDPR crypto-shred for one or more collections.
- *
- * Each declared collection is forced to `perRecordKeys: true` (a shred can
- * only guarantee erasure of a record whose body is keyed off a per-record
- * CEK). On write, Noydb extracts `record[subjectField]` and maintains an
- * encrypted `_subject_index` mapping `subject → [{collection, id}]`, so
- * `vault.forget(subjectId)` can find every record for a subject and rewrite
- * each to a tombstone (body + history permanently undecryptable) while the
- * collection DEK and every other record stay intact.
- *
- * @example
- * ```ts
- * createNoydb({
- *   secret, user,
- *   forgetStrategy: withForgetCascade({ subjects: { invoices: 'buyerId' } }),
- * })
- * const result = await vault.forget('buyer-123')
- * // → { subject, recordsShredded, historyVersionsShredded, collections, … }
- * ```
- */
-declare function withForgetCascade(opts: SubjectDeclaration): ForgetStrategy;
-
-export { ForgetStrategy, SubjectDeclaration, withForgetCascade };

package/dist/guards/index.d.ts

@@ -1,34 +0,0 @@
-export { I as ImmutableGuardConfig, T as TransitionGuardConfig, i as immutableGuard, t as transitionGuard, w as withGuard } from '../transition-guard-DI-krBsZ.js';
-import { bc as GuardStrategy, bd as GuardChange, be as GuardContext } from '../index-DjWbxsjb.js';
-export { bf as AmendmentForbiddenError, bg as FieldFrozenError, bh as GuardRegistry, bi as GuardStrategyHandle, bj as IllegalTransitionError, bk as InvariantError, bl as ReadOnlyVaultFacade, bm as RecordLockedError } from '../index-DjWbxsjb.js';
-import '../subject-index-CyOgGMJL.js';
-import '../index-B9QdHytu.js';
-import '@noy-db/attestation';
-
-/**
- * Pure functions that execute the work declared by a `GuardStrategy`.
- * Stateless — `GuardRegistry` decides when to call these.
- *
- * @internal
- */
-declare const GuardExecutor: {
-    /**
-     * Compare existing vs incoming for each `frozenFields.fields` entry
-     * when `frozenFields.when(existing)` is true. Throws
-     * `FieldFrozenError` listing every changed frozen field.
-     *
-     * @param skipFields — field names that are schema-owned computed fields.
-     *   These are excluded from the comparison because `incoming` carries the
-     *   raw user input (computed fields not yet evaluated), so comparing
-     *   `existing[field]` vs `incoming[field]` would always look like a
-     *   change even when the computed result is unchanged.
-     */
-    checkFrozenFields<T extends Record<string, unknown>>(guard: GuardStrategy<T>, id: string, existing: T | null, incoming: T, skipFields?: ReadonlySet<string>): Promise<void>;
-    /**
-     * Run a single guard's invariant over its slice of the change-set.
-     * Any throw is converted to `InvariantError` unless it already is one.
-     */
-    runInvariant<T extends Record<string, unknown>>(guard: GuardStrategy<T>, changes: ReadonlyArray<GuardChange<T>>, ctx: GuardContext<T>): Promise<void>;
-};
-
-export { GuardChange, GuardContext, GuardExecutor, GuardStrategy };

package/dist/hash-DAJjMsCE.d.ts

@@ -1,72 +0,0 @@
-import { d0 as EncryptedEnvelope } from './index-DjWbxsjb.js';
-
-/**
- * Ledger storage constants — pinned in their own leaf module so
- * always-on core code (vault.ts, dictionary.ts) can import them
- * without dragging the `LedgerStore` class into the bundle.
- *
- * `splitting: true` in tsup is not enough on its own: when a
- * source file exports both pure constants and a heavyweight class,
- * the bundler keeps the entire chunk reachable from any importer.
- * Extracting the constants lets the floor scenario import them
- * without paying for the class.
- *
- * @internal
- */
-/** The internal collection name used for ledger entry storage. */
-declare const LEDGER_COLLECTION = "_ledger";
-/**
- * The internal collection name used for delta payload storage.
- *
- * Deltas live in a sibling collection (not inside `_ledger`) for two
- * reasons:
- *
- *   1. **Listing efficiency.** `ledger.loadAllEntries()` calls
- *      `adapter.list(_ledger)` which would otherwise return every
- *      delta key alongside every entry key. Splitting them keeps the
- *      list small (one key per ledger entry) and the delta reads
- *      keyed by the entry's index.
- *
- *   2. **Prune-friendliness.** A future `pruneHistory()` will delete
- *      old deltas while keeping the ledger chain intact (folding old
- *      deltas into a base snapshot). Separating the storage makes
- *      that deletion a targeted operation on one collection instead
- *      of a filter across a mixed list.
- *
- * Both collections share the same ledger DEK — one DEK, two
- * internal collections, same zero-knowledge guarantees.
- */
-declare const LEDGER_DELTAS_COLLECTION = "_ledger_deltas";
-
-/**
- * Envelope payload hash — pinned in its own leaf module so consumers
- * (DictionaryHandle, the active history strategy) can import it
- * without dragging in the `LedgerStore` class.
- *
- * see `constants.ts` for the broader rationale.
- *
- * @internal
- */
-
-/**
- * Compute the `payloadHash` value for an encrypted envelope. Used by
- * `LedgerStore.append` for both put (hash the new envelope) and
- * delete (hash the previous envelope) paths, and by
- * `DictionaryHandle` so its ledger entries match the same contract.
- *
- * Hashes the open `_data` ciphertext, plus the sealed-field ciphertext
- * map (`_sealed`) when a record carries one — so the ledger attests to
- * both the open body AND every sealed value … and the verify-digest
- * ciphertext map (`_vdig`), each bound only when present — the `_vdig`
- * binding is the temporal-rollback detector for the C1 splice class.
- * `rotateRecordCek` rewrites `_vdig` with no ledger entry, the same
- * pre-existing rotation property `_sealed`/`_cek` already have
- * (`verifyBackupIntegrity` flags rotated records until re-anchored).
- *
- * Returns the empty string when there is no envelope (delete of a
- * never-existed record). The empty string tolerated by the ledger
- * entry's `payloadHash` field as the canonical "nothing here" value.
- */
-declare function envelopePayloadHash(envelope: EncryptedEnvelope | null): Promise<string>;
-
-export { LEDGER_COLLECTION as L, LEDGER_DELTAS_COLLECTION as a, envelopePayloadHash as e };

package/dist/history/index.d.ts

@@ -1,60 +0,0 @@
-import { cZ as HistoryStrategy, c_ as NoydbStore, c$ as HistoryOptions, d0 as EncryptedEnvelope, d1 as PruneOptions } from '../index-DjWbxsjb.js';
-export { d2 as AppendInput, d3 as ChangeType, d4 as CollectionInstant, c7 as DiffEntry, d5 as JsonPatch, d6 as JsonPatchOp, d7 as LedgerStore, d8 as VaultEngine, d9 as VaultInstant, da as VerifyResult, db as applyPatch, dc as computePatch, dd as diff, de as formatDiff } from '../index-DjWbxsjb.js';
-export { L as LedgerEntry, d as canonicalJson, h as hashEntry, p as paddedIndex, e as parseIndex, s as sha256Hex } from '../subject-index-CyOgGMJL.js';
-export { L as LEDGER_COLLECTION, a as LEDGER_DELTAS_COLLECTION, e as envelopePayloadHash } from '../hash-DAJjMsCE.js';
-import '../index-B9QdHytu.js';
-import '@noy-db/attestation';
-
-/**
- * Active history strategy — `withHistory()` returns the real
- * implementation that wires per-record snapshots, the hash-chained
- * audit ledger, JSON-patch deltas, and time-machine reads into the
- * core write/read paths.
- *
- * Consumers opt in by:
- *
- * ```ts
- * import { createNoydb } from '@noy-db/hub'
- * import { withHistory } from '@noy-db/hub/history'
- *
- * const db = await createNoydb({
- *   store: ...,
- *   user: ...,
- *   historyStrategy: withHistory(),
- * })
- * ```
- *
- * The factory is a thin wrapper that delegates to the existing
- * `history.ts`, `diff.ts`, `ledger/store.ts`, `ledger/patch.ts`, and
- * `time-machine.ts` modules. Splitting the import chain through this
- * file is what lets `tsup` tree-shake the heavy modules out of the
- * default `@noy-db/hub` bundle when no `withHistory()` import is
- * present in the consumer.
- *
- * @public
- */
-
-/**
- * Build the active history strategy. Today the factory takes no
- * options; per-collection retention tuning still flows through
- * `HistoryConfig` on `Vault.collection()` / `vault.openVault()`.
- *
- * Future option slots (kept off the LTS surface for now):
- *   - global maxVersions cap
- *   - global beforeDate prune cadence
- *   - ledger encryption toggle (today inferred from vault.encrypted)
- */
-declare function withHistory(): HistoryStrategy;
-
-/** Save a history entry (a complete encrypted envelope snapshot). */
-declare function saveHistory(adapter: NoydbStore, vault: string, collection: string, recordId: string, envelope: EncryptedEnvelope): Promise<void>;
-/** Get history entries for a record, sorted newest-first. */
-declare function getHistory(adapter: NoydbStore, vault: string, collection: string, recordId: string, options?: HistoryOptions): Promise<EncryptedEnvelope[]>;
-/** Get a specific version's envelope from history. */
-declare function getVersionEnvelope(adapter: NoydbStore, vault: string, collection: string, recordId: string, version: number): Promise<EncryptedEnvelope | null>;
-/** Prune history entries. Returns the number of entries deleted. */
-declare function pruneHistory(adapter: NoydbStore, vault: string, collection: string, recordId: string | undefined, options: PruneOptions): Promise<number>;
-/** Clear all history for a vault, optionally scoped to a collection or record. */
-declare function clearHistory(adapter: NoydbStore, vault: string, collection?: string, recordId?: string): Promise<number>;
-
-export { HistoryStrategy, clearHistory, getHistory, getVersionEnvelope, pruneHistory, saveHistory, withHistory };

package/dist/i18n/index.d.ts

@@ -1,56 +0,0 @@
-import { ck as I18nStrategy } from '../index-DjWbxsjb.js';
-export { cl as DICT_COLLECTION_PREFIX, cm as DictEntry, cn as DictKeyDescriptor, co as DictKeyInUseError, cp as DictKeyMissingError, cq as DictionaryHandle, cr as DictionaryOptions, cs as I18nMap, ct as I18nTextDescriptor, cu as I18nTextOptions, cv as Layer, cw as LocaleNotSpecifiedError, cx as MissingTranslationError, cy as OnMissing, cz as OnMissingPolicy, cA as ReservedCollectionNameError, cB as ResolveI18nOptions, cC as ScriptViolationError, cD as ScriptWarning, cE as StaticDictDescriptor, cF as StaticDictReadonlyError, cG as TranslatorNotConfiguredError, cH as UnknownDictCodeError, cI as applyI18nLocale, cJ as dictCollectionName, cK as dictKey, cL as enforceScript, cM as i18nText, cN as inferScripts, cO as isDictCollectionName, cP as isDictKeyDescriptor, cQ as isI18nTextDescriptor, cR as isStaticDictDescriptor, cS as presentI18nForJoin, cT as resolveI18nText, cU as resolvePolicy, cV as staticDict, cW as stripI18nFilled, cX as validateI18nTextValue } from '../index-DjWbxsjb.js';
-import '../subject-index-CyOgGMJL.js';
-import '../index-B9QdHytu.js';
-import '@noy-db/attestation';
-
-/**
- * Generic dotted-path / `[]`-wildcard record helpers. Kernel-owned:
- * these carry zero i18n logic — they were extracted out of
- * `via/i18n/core.ts` (Task 7, #623) so kernel call-sites (put-time
- * validation, densify) can import them without a spine→service edge.
- *
- * @internal
- */
-/**
- * Return all leaf values at `path`, expanding `[].` array wildcards.
- *
- * - `'name'`              → `[obj.name]`
- * - `'address.lineOne'`   → `[obj.address.lineOne]`
- * - `'contacts[].title'`  → `[obj.contacts[0].title, obj.contacts[1].title, …]`
- *
- * Returns an empty array when the path does not resolve (missing key,
- * wrong type, etc.). Used by `enforceI18nOnPut` to validate nested fields.
- */
-declare function getAtPath(obj: Record<string, unknown>, path: string): unknown[];
-
-/**
- * Active i18n strategy — `withI18n()` returns the real implementation
- * that wires multi-locale resolution, i18nText validation, and the
- * `DictionaryHandle` for `dictKey` fields into the core read/write
- * paths.
- *
- * Consumers opt in by:
- *
- * ```ts
- * import { createNoydb } from '@noy-db/hub'
- * import { withI18n } from '@noy-db/hub/i18n'
- *
- * const db = await createNoydb({
- *   store: ...,
- *   user: ...,
- *   i18nStrategy: withI18n(),
- * })
- * ```
- *
- * The factory delegates to the existing `core.ts` and `dictionary.ts`
- * modules. Splitting the import chain through this file is what lets
- * tsup tree-shake the `~854 LOC` of dictionary + locale resolution
- * out of the default bundle when no `withI18n()` import is present.
- *
- * @public
- */
-
-declare function withI18n(): I18nStrategy;
-
-export { I18nStrategy, getAtPath, withI18n };

package/dist/in/index.d.ts

@@ -1,4 +0,0 @@
-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/index-B9QdHytu.d.ts

@@ -1,123 +0,0 @@
-/**
- * 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 };