@powerhousedao/reactor 6.2.3-dev.50 → 6.2.3-dev.52

package/dist/{index-CNhT69De.d.ts → index-dDm0fUBT.d.ts}

@@ -2,75 +2,73 @@ import { Action, ActionSigner, AuthRequest, AuthSubject, DocumentModelModule, Ho
 import { DocumentDriveDocument, DriveInput, FolderNode, Node } from "@powerhousedao/shared/document-drive";
 import { ILogger } from "document-model";
 import "@powerhousedao/shared/document-model/errors";
-import { ColumnType, Generated, Insertable, Kysely, Selectable, Transaction } from "kysely";
-import { IProcessorManager } from "@powerhousedao/shared/processors";
+import { ColumnType, DatabaseIntrospector, Dialect, DialectAdapter, Driver, Generated, Insertable, Kysely, QueryCompiler, Selectable, Transaction } from "kysely";
+import { IProcessorManager, ProcessorStatus } from "@powerhousedao/shared/processors";
 import { Pool } from "pg";
-//#region src/catch-up/types.d.ts
-type WatermarkStatus = {
-  head: number;
-  settledThrough: number;
-  waitingOn: string[];
-  stalledSinceUtcMs?: number;
+//#region src/decision/stream-order.d.ts
+/** Where a stream's stored order contradicts its timestamps. */
+type OutOfOrderPair = {
+  previous: Operation;
+  current: Operation;
+  /**
+   * `descending` cannot be walked at all. `tied` walks fine — the intra-stream
+   * rule breaks the tie by index — but violates the monotonic auth rule, so a
+   * stream holding one can never be replicated to a peer that lacks it.
+   */
+  kind: "descending" | "tied";
 };
-interface ISettledWatermark {
-  /** Every ordinal at or below this is visible or will never exist. */
-  readonly settledThrough: number;
-  /** Probes, coalesced with one in flight; resolves with settledThrough. */
-  refresh(signal?: AbortSignal): Promise<number>;
-  onAdvance(listener: (settledThrough: number) => void): Unsubscribe;
-  status(): WatermarkStatus;
-}
-type SweepBlockedAt = {
-  ordinal: number;
-  documentId: string;
+/**
+ * The first pair of effective operations whose stored order contradicts their
+ * timestamps, or undefined when the stream is in position order.
+ *
+ * Such a stream cannot be walked, and the auth stream is never reshuffled once
+ * the monotonic rule is on, so run this before enabling enforcement on a fleet.
+ *
+ * `requireStrict` additionally rejects a tie, which is what the auth stream's
+ * monotonic rule requires and what the walk alone does not care about.
+ */
+declare function firstOutOfOrderPair(operations: Operation[], options?: {
+  requireStrict?: boolean;
+}): OutOfOrderPair | undefined;
+//#endregion
+//#region src/admin/types.d.ts
+type KeyframeValidationIssue = {
   scope: string;
   branch: string;
-  type: string;
-  error: string;
+  revision: number;
+  keyframeHash: string;
+  replayedHash: string;
 };
-type SweepResult = {
-  consumerId: string;
-  from: number;
-  to: number;
-  durationMs: number;
-  /** Late operations applied. */
-  replayed: number;
-  /** Later operations of their streams applied again. */
-  reapplied: number;
-  blockedAt?: SweepBlockedAt;
+type SnapshotValidationIssue = {
+  scope: string;
+  branch: string;
+  snapshotHash: string;
+  replayedHash: string;
 };
-interface ICatchUpConsumer {
-  readonly consumerId: string;
-  readonly appliedThrough: number;
-  /** Ordinals above the cursor this consumer holds in memory. */
-  readonly trackedAbove: number;
-  sweep(settledThrough: number, present: readonly number[], signal?: AbortSignal): Promise<SweepResult>;
-}
-type CatchUpThread = "host" | "projection";
-type CatchUpConsumerStatus = {
-  consumerId: string;
-  thread: CatchUpThread;
-  appliedThrough: number;
-  trackedAbove: number;
-  blockedAt?: SweepBlockedAt;
-  lastAdvanceUtcMs: number;
+/** Effective operations whose stored order contradicts their timestamps. */
+type StreamOrderIssue = {
+  scope: string;
+  branch: string;
+  previous: Operation;
+  current: Operation;
+  kind: OutOfOrderPair["kind"];
 };
-type CatchUpStatus = {
-  watermark: WatermarkStatus;
-  consumers: CatchUpConsumerStatus[];
+type ValidationResult = {
+  documentId: string;
+  isConsistent: boolean;
+  keyframeIssues: KeyframeValidationIssue[];
+  snapshotIssues: SnapshotValidationIssue[];
+  streamOrderIssues: StreamOrderIssue[];
 };
-type CatchUpConfig = {
-  intervalMs: number;
-  stuckWarnMs: number;
-  maxTrackedAboveCursor: number;
-  /** Present ordinals read per tick. */
-  sweepPageSize: number;
+type RebuildResult = {
+  documentId: string;
+  keyframesDeleted: number;
+  scopesInvalidated: number;
 };
-declare const defaultCatchUpConfig: CatchUpConfig;
-/** The catch-up surface a reactor module exposes. */
-interface ICatchUp {
-  status(): CatchUpStatus;
-  sweepNow(): Promise<SweepResult[]>;
+interface IDocumentIntegrityService {
+  validateDocument(documentId: string, branch?: string, signal?: AbortSignal): Promise<ValidationResult>;
+  rebuildKeyframes(documentId: string, branch?: string, signal?: AbortSignal): Promise<RebuildResult>;
+  rebuildSnapshots(documentId: string, branch?: string, signal?: AbortSignal): Promise<RebuildResult>;
 }
 //#endregion
 //#region src/shared/types.d.ts
@@ -454,6 +452,9 @@ type ReadModelRegistrationStage = "pre_ready" | "post_ready";
  */
 interface ILiveReadModelCoordinator extends IReadModelCoordinator {
   addReadModel(readModel: IReadModel, stage: ReadModelRegistrationStage): void;
+  /** Detaches this instance, not its name; false when it is not registered.
+   * A batch it reserved and has not applied is released. */
+  removeReadModel(readModel: IReadModel): boolean;
 }
 declare function supportsLiveReadModelRegistration(coordinator: IReadModelCoordinator): coordinator is ILiveReadModelCoordinator;
 //#endregion
@@ -478,6 +479,18 @@ declare enum PollBehavior {
   Auto = "auto",
   Manual = "manual"
 }
+/**
+ * Whether a remote outlives the process that added it.
+ *
+ * A `Session` remote's transport is a live object of this session, such as a
+ * brokered `MessagePort`. Its record is written like any other, so its cursors,
+ * holds and dead letters have a parent row, and the next `startup()` removes
+ * it instead of rehydrating it.
+ */
+declare enum RemotePersistence {
+  Durable = "durable",
+  Session = "session"
+}
 type RemoteOptions = {
   /**
    * Stringified UTC timestamp (ms). When set and not `"0"`, outbox operations older
@@ -485,6 +498,8 @@ type RemoteOptions = {
    * the filter, syncing from the beginning of history.
    */
   sinceTimestampUtcMs?: string;
+  /** Defaults to {@link RemotePersistence.Durable}. */
+  persistence?: RemotePersistence;
   /**
    * Polling cadence for this remote. Defaults to `PollBehavior.Auto` when omitted.
    */
@@ -1622,6 +1637,16 @@ declare class DriveCollectionId {
    * The single deserializer for the wire/storage form. `branch` may contain
    * dots, while `driveId` is a dot-free document id, so the drive id is the
    * final dot-delimited segment.
+   *
+   * That asymmetry is a real constraint, not a convention: a drive id
+   * containing a dot does NOT survive `key` -> `fromKey`, because the split
+   * takes the LAST dot and so hands the tail of the drive id back as the drive
+   * id and everything before it as the branch. The key format is the wire and
+   * storage representation of existing `document_collections` rows, so it
+   * cannot be changed; callers that accept a drive id or branch from outside
+   * (a UI field, an RPC payload) must reject dots in the drive id at their own
+   * boundary. The round-trip is verifiable without parsing rules:
+   * `DriveCollectionId.fromKey(id.key).key === id.key`.
    */
   static fromKey(key: string): DriveCollectionId;
   get key(): string;
@@ -1819,6 +1844,7 @@ interface SyncRemoteTable {
   pull_last_failure_utc_ms: string | null;
   pull_failure_count: number;
   bound_address: string | null;
+  persistence: Generated<string>;
   peer_manifest: string | null;
   peer_manifest_at_utc_ms: ColumnType<string | number | null, number | null, number | null>;
   created_at: Generated<Date>;
@@ -2660,6 +2686,12 @@ type JobExecutorConfig = {
   protocolSupport?: ProtocolSupport;
   /** Index rows a purge may remove without allowLarge. */
   maxPurgeOperations?: number;
+  /**
+   * How long a committed job waits for its flush before its write-ready is
+   * withheld; 0 or less waits unbounded. withGroupCommitPGlite refuses that and
+   * any non-finite value. Must stay under the job timeout.
+   */
+  durabilityWaitMs?: number;
 };
 /** Cloneable, so a pooled worker refuses exactly what the host refuses. */
 type ProtocolSupport = {
@@ -3330,6 +3362,281 @@ type CatchUpSweptEvent = SweepResult & {
   thread: CatchUpThread;
 };
 //#endregion
+//#region src/catch-up/types.d.ts
+type WatermarkStatus = {
+  head: number;
+  settledThrough: number;
+  waitingOn: string[];
+  stalledSinceUtcMs?: number;
+};
+interface ISettledWatermark {
+  /** Every ordinal at or below this is visible or will never exist. */
+  readonly settledThrough: number;
+  /** Probes, coalesced with one in flight; resolves with settledThrough. */
+  refresh(signal?: AbortSignal): Promise<number>;
+  onAdvance(listener: (settledThrough: number) => void): Unsubscribe;
+  status(): WatermarkStatus;
+}
+type SweepBlockedAt = {
+  ordinal: number;
+  documentId: string;
+  scope: string;
+  branch: string;
+  type: string;
+  error: string;
+};
+type SweepResult = {
+  consumerId: string;
+  from: number;
+  to: number;
+  durationMs: number;
+  /** Late operations applied. */
+  replayed: number;
+  /** Later operations of their streams applied again. */
+  reapplied: number;
+  blockedAt?: SweepBlockedAt;
+};
+interface ICatchUpConsumer {
+  readonly consumerId: string;
+  readonly appliedThrough: number;
+  /** Ordinals above the cursor this consumer holds in memory. */
+  readonly trackedAbove: number;
+  sweep(settledThrough: number, present: readonly number[], signal?: AbortSignal): Promise<SweepResult>;
+}
+type CatchUpThread = "host" | "projection";
+type CatchUpConsumerStatus = {
+  consumerId: string;
+  thread: CatchUpThread;
+  appliedThrough: number;
+  trackedAbove: number;
+  blockedAt?: SweepBlockedAt;
+  lastAdvanceUtcMs: number;
+};
+type CatchUpStatus = {
+  watermark: WatermarkStatus;
+  consumers: CatchUpConsumerStatus[];
+};
+type CatchUpConfig = {
+  intervalMs: number;
+  stuckWarnMs: number;
+  maxTrackedAboveCursor: number;
+  /** Present ordinals read per tick. */
+  sweepPageSize: number;
+};
+declare const defaultCatchUpConfig: CatchUpConfig;
+/** The catch-up surface a reactor module exposes. */
+interface ICatchUp {
+  status(): CatchUpStatus;
+  sweepNow(): Promise<SweepResult[]>;
+}
+//#endregion
+//#region src/inspector/types.d.ts
+/** Where the reactor's store keeps its bytes. */
+type StoragePersistence = "idb" | "memory" | "path" | "server" | "unknown";
+/** What the reactor knows about its own store. */
+type ReactorStorageFacts = {
+  readonly engine: "pglite" | "postgres" | "unknown";
+  readonly persistence: StoragePersistence;
+  /** False when the store is in memory or its persistence is unknown. */
+  readonly durable: boolean;
+  /** Whether a poisoned store session is recreated in place. */
+  readonly selfHeal: boolean;
+};
+/** The inspection tiers a transport serves beyond reads. */
+type InspectorAccess = {
+  readonly admin: boolean;
+  readonly sql: boolean;
+};
+/** The facts a reactor reports about itself. */
+type ReactorInfo = {
+  readonly storage: ReactorStorageFacts;
+  /** Whether a workflow runtime is composed onto this reactor right now. */
+  readonly workflows: boolean;
+  /** The channel types the built channel factory serves; empty without sync. */
+  readonly syncChannels: readonly string[];
+  readonly access: InspectorAccess;
+};
+/** Untracked health reports `healthy: false`, so an unwatched store never reads green. */
+type InspectorStorageHealth = {
+  tracked: boolean;
+  healthy: boolean;
+  everRecreated: boolean;
+  recreateCount: number;
+};
+/** The storage-health source a `ReactorInspector` reads, when one is wired. */
+interface IInspectorStorageHealthProvider {
+  getStorageHealth(): InspectorStorageHealth;
+}
+/** Point-in-time view of the job queue. */
+type QueueStateSnapshot = {
+  isPaused: boolean;
+  pendingJobs: Job[];
+  executingJobs: Job[];
+  totalPending: number;
+  totalExecuting: number;
+};
+/** One registered document model and every version its type supports. */
+type InspectorDocumentModelInfo = {
+  documentType: string;
+  name: string;
+  version: number;
+  supportedVersions: number[];
+};
+/** One drive and a summary of its node tree. */
+type InspectorDriveInfo = {
+  driveId: string;
+  name: string;
+  branch: string;
+  /** The `drive.<branch>.<driveId>` collection id a remote syncs it under. */
+  collectionId: string;
+  documentType: string;
+  /** Every entry in the raw node array, malformed ones included. */
+  nodeCount: number;
+  fileCount: number;
+  folderCount: number;
+  /** Readable nodes whose kind is neither file nor folder. */
+  otherNodeCount: number;
+  /** Entries with no string id or kind. */
+  unreadableNodeCount: number;
+  icon: string | undefined;
+};
+type InspectorDrivePage = {
+  results: InspectorDriveInfo[];
+  /** Absent once the last page has been served. */
+  nextCursor: string | undefined;
+};
+type InspectorDriveIntegrityRef = {
+  id: string;
+  documentType: string;
+};
+/** One pass over one drive snapshot, so `checkedNodeCount` equals `totalFileNodeCount`. */
+type InspectorDriveIntegrity = {
+  driveId: string;
+  checkedNodeCount: number;
+  totalFileNodeCount: number;
+  /** Missing or not served to the reader; the two look the same so nothing leaks. */
+  missingDocuments: InspectorDriveIntegrityRef[];
+  unsupportedTypes: InspectorDriveIntegrityRef[];
+};
+/** Replicator counters mean nothing when `hasReplicator` is false. */
+type InspectorAttachmentInfo = {
+  present: boolean;
+  /** The store class, e.g. "kysely", "idb", "memory"; "none" when absent. */
+  storeKind: string;
+  hasReplicator: boolean;
+  replicatorRunning: boolean;
+  backlogScanned: boolean;
+  refsSeen: number;
+  held: number;
+  bytesHeld: number;
+  queued: number;
+  fetching: number;
+  pendingFetches: number;
+  waiting: number;
+  notFound: number;
+  failed: number;
+  lastError: string | undefined;
+};
+/** The attachment-store source a `ReactorInspector` reads, when one is wired. */
+interface IInspectableAttachmentStore {
+  getAttachmentInfo(): Promise<InspectorAttachmentInfo>;
+}
+/** A tracked processor without its `retry()` closure, so it can be cloned. */
+type InspectorProcessorInfo = {
+  processorId: string;
+  factoryId: string;
+  driveId: string;
+  processorIndex: number;
+  lastOrdinal: number;
+  status: ProcessorStatus;
+  lastError: string | undefined;
+  lastErrorTimestamp: Date | undefined;
+};
+/** The in-memory queue's debugging surface; not part of `IQueue`. */
+interface IInspectableQueue {
+  readonly paused: boolean;
+  pause(): void;
+  resume(): Promise<void>;
+  getPendingJobs(): Job[];
+  getExecutingJobIds(): Map<string, Set<string>>;
+  getJob(jobId: string): Job | undefined;
+}
+/** Inspection reads: no state changes, plain-data results for any transport. */
+interface IInspector {
+  info(): Promise<ReactorInfo>;
+  listDocumentModels(): Promise<InspectorDocumentModelInfo[]>;
+  listDrives(cursor?: string, limit?: number): Promise<InspectorDrivePage>;
+  checkDriveIntegrity(driveId: string, branch: string): Promise<InspectorDriveIntegrity>;
+  getAttachmentInfo(): Promise<InspectorAttachmentInfo>;
+  getQueueState(): Promise<QueueStateSnapshot>;
+  getProcessors(): Promise<InspectorProcessorInfo[]>;
+  getCatchUpStatus(): Promise<CatchUpStatus>;
+  getStorageHealth(): Promise<InspectorStorageHealth>;
+  /** Replays the whole document; read-only but expensive. */
+  validateDocument(documentId: string, branch?: string): Promise<ValidationResult>;
+}
+/** The inspection levers. An action a host cannot perform is refused. */
+interface IInspectorAdmin {
+  pauseQueue(): Promise<void>;
+  resumeQueue(): Promise<void>;
+  retryProcessor(processorId: string): Promise<void>;
+  sweepCatchUp(): Promise<SweepResult[]>;
+  rebuildKeyframes(documentId: string, branch?: string): Promise<RebuildResult>;
+  rebuildSnapshots(documentId: string, branch?: string): Promise<RebuildResult>;
+}
+/** Raw SQL against the reactor's own store. */
+interface IReactorDbQuery {
+  queryDb(sql: string, params?: unknown[]): Promise<unknown[]>;
+}
+/** Host-side setters for the facts a reactor learns after it is built. */
+interface IReactorFactsSink {
+  setWorkflows(composed: boolean): void;
+}
+//#endregion
+//#region src/sync/sync-inspection.d.ts
+/** A remote's persisted cursor beside its channel's live watermark. */
+type RemoteCursorInfo = {
+  cursorType: "inbox" | "outbox";
+  cursorOrdinal: number;
+  lastSyncedAtUtcMs?: number;
+  liveAckOrdinal: number;
+  liveLatestOrdinal: number;
+};
+type MailboxDepths = {
+  inbox: number;
+  outbox: number;
+  deadLetter: number;
+};
+type RemoteConnectionHealth = {
+  snapshot: ConnectionStateSnapshot;
+  /** "connected" without one completed poll since boot. */
+  neverSucceeded: boolean;
+  /** Since the last successful poll; absent when there was none. */
+  stalenessMs?: number;
+};
+type RemoteSyncInspection = {
+  remoteName: string;
+  remoteId: string;
+  inboxCursor: RemoteCursorInfo;
+  outboxCursor: RemoteCursorInfo;
+  mailboxDepths: MailboxDepths;
+  connection: RemoteConnectionHealth;
+};
+/** One page of dead letters, without the `next()` closure a clone cannot carry. */
+type DeadLetterPage = {
+  remoteName: string;
+  results: DeadLetterRecord[];
+  nextCursor?: string;
+};
+/** Sync reads; the repair levers are `ISyncAdmin`. */
+interface ISyncInspector {
+  inspectRemote(remoteName: string): Promise<RemoteSyncInspection>;
+  inspectRemotes(): Promise<RemoteSyncInspection[]>;
+  /** Newest first; limit clamps to [1, max per remote]; cursor is a row offset. */
+  listDeadLetters(remoteName: string, cursor?: string, limit?: number): Promise<DeadLetterPage>;
+}
+declare function deriveConnectionHealth(snapshot: ConnectionStateSnapshot, nowMs?: number): RemoteConnectionHealth;
+//#endregion
 //#region src/events/interfaces.d.ts
 /**
  * Describes an object that manages event subscriptions and emissions.
@@ -3709,6 +4016,11 @@ declare function isDriveAuthError(error: unknown): boolean;
 declare class SyncRepairRefusedError extends Error {
   constructor(message: string);
 }
+/** A dead-letter page cursor that is not a row offset. */
+declare class InvalidDeadLetterCursorError extends Error {
+  readonly cursor: string;
+  constructor(cursor: string);
+}
 declare class PollingChannelError extends Error {
   constructor(message: string);
 }
@@ -3766,7 +4078,9 @@ interface IMailbox {
   /**
    * The latest ordinal that has been acknowledged. Because acknowledged items
    * are removed from the mailbox, this is the last ordinal that has been removed.
-   * With holdAckBelowMarkers, never at or past an unapplied marker entry.
+   * Never at or past an item that is neither applied nor failed, unless the
+   * mailbox opted out, and with holdAckBelowMarkers never at or past an
+   * unapplied marker entry either.
    */
   get ackOrdinal(): number;
   /**
@@ -3780,8 +4094,6 @@ interface IMailbox {
   get(id: string): SyncOperation | undefined;
   add(...items: SyncOperation[]): void;
   remove(...items: SyncOperation[]): void;
-  /** Keeps ackOrdinal below an unapplied item until it is applied or removed. */
-  hold?(item: SyncOperation): void;
   onAdded(callback: MailboxCallback): void;
   onRemoved(callback: MailboxCallback): void;
   pause(): void;
@@ -3792,13 +4104,24 @@ interface IMailbox {
 type MailboxOptions = {
   /** An unapplied item carrying a purge marker keeps ackOrdinal below it. */
   holdAckBelowMarkers?: boolean;
+  /**
+   * An item neither applied nor failed keeps ackOrdinal below it. Defaults to
+   * true: items for different documents apply out of order, so the maximum
+   * applied ordinal can pass one still loading. A failed item does not hold it;
+   * its dead letter stands for it. Opt out only where no cursor reads the ack.
+   */
+  holdAckBelowUnapplied?: boolean;
 };
 declare class Mailbox implements IMailbox {
   private readonly holdAckBelowMarkers;
+  private readonly holdAckBelowUnapplied;
   private itemsMap;
   /** Unapplied items carrying a marker, so the held ack reads only these. */
   private readonly heldMarkers;
-  private readonly held;
+  /** Lowest ordinal of each item neither applied nor failed, read once at add. */
+  private readonly unapplied;
+  /** Null when stale; a valid cache may be positive infinity. */
+  private unappliedFloorCache;
   private addedCallbacks;
   private removedCallbacks;
   private paused;
@@ -3812,7 +4135,6 @@ declare class Mailbox implements IMailbox {
   get items(): ReadonlyArray<SyncOperation>;
   get ackOrdinal(): number;
   get latestOrdinal(): number;
-  hold(item: SyncOperation): void;
   get(id: string): SyncOperation | undefined;
   add(...items: SyncOperation[]): void;
   remove(...items: SyncOperation[]): void;
@@ -3822,6 +4144,9 @@ declare class Mailbox implements IMailbox {
   resume(): void;
   flush(): void;
   isPaused(): boolean;
+  /** Recomputed only once the item that set it has resolved. */
+  private unappliedFloor;
+  private forgetUnapplied;
 }
 //#endregion
 //#region src/sync/sync-status-tracker.d.ts
@@ -3949,6 +4274,8 @@ type PeerManifestListener = (manifest: PeerManifest | null, undelivered?: readon
  * their own factories that implement this interface.
  */
 interface IChannelFactory {
+  /** The `ChannelConfig.type`s this factory builds; absent when it does not say. */
+  readonly channelTypes?: readonly string[];
   /**
    * Creates a new channel instance with the given configuration.
    *
@@ -4089,6 +4416,8 @@ interface ISyncManager {
    * @throws Error if the remote does not exist
    */
   remove(name: string): Promise<void>;
+  /** Settles once no reset of the remote is running or queued; never rejects. */
+  resetSettled?(name: string): Promise<void>;
   /**
    * Lists all configured remotes.
    *
@@ -5476,9 +5805,11 @@ interface IJobExecutor {
   /**
    * Execute a single job.
    * @param job - The job to execute
+   * @param onCommitting - Called in the same tick as the job's last abort
+   * check, just before its COMMIT is issued; the signal must not abort after it
    * @returns Promise that resolves to the job result
    */
-  executeJob(job: Job, signal?: AbortSignal): Promise<JobResult>;
+  executeJob(job: Job, signal?: AbortSignal, onCommitting?: () => void): Promise<JobResult>;
 }
 /**
  * Interface for managing multiple job executors.
@@ -5828,6 +6159,119 @@ type ForwardingPoolInstrumentation = PoolInstrumentation & {
   updateStats(stats: PoolStats): void;
 };
 //#endregion
+//#region src/storage/storage-health.d.ts
+type StorageHealth = {
+  /** False once the store's session was poisoned; a host restart clears it. */
+  healthy: boolean;
+};
+interface IStorageHealthProvider {
+  getStorageHealth(): StorageHealth;
+}
+//#endregion
+//#region src/storage/kysely/pglite-dialect.d.ts
+/** Structural so importing this module does not pull in the PGlite wasm bundle. */
+type PGliteSession = {
+  query: (sql: string, params?: unknown[]) => Promise<{
+    rows: unknown[];
+    affectedRows?: number;
+  }>;
+  /** Simple-query execution, used for the commit guard and session recovery. */
+  exec: (sql: string) => Promise<unknown>;
+  isInTransaction: () => boolean;
+  /** Runs one statement once the session admits it; the dialect's deadlines start inside. */
+  admit?: <T>(run: () => Promise<T>) => Promise<T>;
+};
+type HardenedPGliteDialectOptions = {
+  /** Opt-in bound on waiting for the single PGlite lease; 0 (the default) waits indefinitely. */
+  acquireTimeoutMs: number;
+  /** Bound on a call that never settles (a dead wasm call); a long synchronous statement still finishes. 0 disables it. */
+  statementTimeoutMs: number;
+  /** The bound for {@link isLongRunningStatement} statements, whose runtime scales with the data. */
+  longStatementTimeoutMs: number;
+  /** Bound on each session recovery statement, which runs against the session that just failed. */
+  recoveryTimeoutMs: number;
+  /** Where unrecoverable session faults and swallowed rollbacks are reported. */
+  onDiagnostic: (message: string, error?: unknown) => void;
+  /** Called once, the first time the session is refused as unrecoverable; the owner should restart. */
+  onPoisoned: (cause: Error) => void;
+};
+declare const DEFAULT_STATEMENT_TIMEOUT_MS = 120000;
+declare const DEFAULT_LONG_STATEMENT_TIMEOUT_MS = 900000;
+declare const DEFAULT_RECOVERY_TIMEOUT_MS = 15000;
+/** Maintenance and DDL, matched on the leading keyword of the compiled SQL. */
+declare function isLongRunningStatement(statement: string): boolean;
+type IntrospectedDatabase = Parameters<Dialect["createIntrospector"]>[0];
+declare class PGliteSessionError extends Error {
+  readonly cause?: unknown;
+  constructor(message: string, cause?: unknown);
+}
+declare class PGliteAcquireTimeoutError extends PGliteSessionError {
+  constructor(timeoutMs: number);
+}
+/** The call cannot be aborted, so it is abandoned and the session treated as poisoned. */
+declare class PGliteStatementTimeoutError extends PGliteSessionError {
+  constructor(timeoutMs: number, statement: string);
+}
+declare class PGliteAbortedTransactionError extends PGliteSessionError {
+  constructor(cause: unknown);
+}
+/** No statement can clear the session (e.g. a stuck active portal). */
+declare class PGliteSessionPoisonedError extends PGliteSessionError {
+  constructor(cause: unknown);
+}
+/** `kysely-pglite-dialect` hardened for one shared session that a fault must not brick. */
+declare class HardenedPGliteDialect implements Dialect {
+  private readonly client;
+  private readonly inner;
+  private readonly options;
+  constructor(client: PGliteSession, options?: Partial<HardenedPGliteDialectOptions>);
+  createAdapter(): DialectAdapter;
+  createDriver(): Driver;
+  createQueryCompiler(): QueryCompiler;
+  createIntrospector(db: IntrospectedDatabase): DatabaseIntrospector;
+}
+/** Raw SQL through the dialect's queue, instead of into whatever transaction holds the session. */
+declare function queryThroughDialect<DB>(db: Kysely<DB>, sql: string, params?: unknown[]): Promise<unknown[]>;
+//#endregion
+//#region src/storage/kysely/group-commit-pglite-client.d.ts
+/** A PGlite instance; PGlite awaits `syncToFs` after each statement. */
+type GroupCommitPGliteInstance = PGliteSession & {
+  close: () => Promise<void>;
+  syncToFs: () => Promise<void>;
+};
+type GroupCommitPGliteClientOptions = {
+  onDiagnostic: (message: string, error?: unknown) => void;
+  /** The sync hung or kept failing: the session is poisoned. */
+  onSyncStuck: (cause: Error) => void;
+  /** A sync that hangs past this poisons the session; 0 disables. */
+  flushSyncTimeoutMs: number;
+  /** Consecutive failed syncs before the session is poisoned. */
+  maxConsecutiveSyncFailures: number;
+  /** Bounds the closing flush and the instance close; 0 disables. */
+  closeTimeoutMs: number;
+};
+/** The filesystem sync never settled. */
+declare class PGliteFlushSyncTimeoutError extends Error {
+  constructor(timeoutMs: number);
+}
+//#endregion
+//#region src/storage/kysely/group-commit-storage.d.ts
+type GroupCommitPGliteOptions = {
+  /** Opened without `relaxedDurability`, or the flush is no barrier at all. */
+  pg: GroupCommitPGliteInstance;
+  /** Poisoned: unflushed writes and positions built on them are void; restart. */
+  onUnrecoverable: (cause: Error) => void;
+  onDiagnostic?: (message: string, error?: unknown) => void;
+  dialect?: Partial<Pick<HardenedPGliteDialectOptions, "acquireTimeoutMs" | "statementTimeoutMs" | "longStatementTimeoutMs" | "recoveryTimeoutMs">>;
+  client?: Partial<Pick<GroupCommitPGliteClientOptions, "flushSyncTimeoutMs" | "maxConsecutiveSyncFailures" | "closeTimeoutMs">>;
+};
+/** What a host keeps of the group-commit store once the reactor is built. */
+interface IGroupCommitStorage {
+  readonly health: IStorageHealthProvider;
+  /** Flushes, then closes the instance; bounded. */
+  close(): Promise<void>;
+}
+//#endregion
 //#region src/core/types.d.ts
 /**
  * A single mutation job within a batch request.
@@ -6140,6 +6584,8 @@ interface SyncModule {
   syncManager: ISyncManager;
   /** Absent where the host cannot reach the sync manager's repair levers. */
   syncAdmin?: ISyncAdmin;
+  /** Absent where the host cannot read the sync manager's channel state. */
+  syncInspector?: ISyncInspector;
 }
 /**
  * Sync module composed in-process, with the full set of sync dependencies.
@@ -6230,6 +6676,10 @@ interface InProcessReactorModule extends ReactorModule {
   settledWatermark: ISettledWatermark;
   /** Enqueues purge jobs; the erasure scheduler is its only caller. */
   documentPurgeService: DocumentPurgeService;
+  /** What the builder knows about the store; see `withStorageFacts`. */
+  storageFacts: ReactorStorageFacts;
+  /** Set by `withGroupCommitPGlite`; the host closes the store through it. */
+  groupCommitStorage?: IGroupCommitStorage;
 }
 /**
  * Base reactor client contract — the client plus its reactor module. Satisfied
@@ -6378,6 +6828,6 @@ declare class DocumentModelRegistry implements IDocumentModelRegistry {
   getUpgradeReducer(documentType: string, fromVersion: number, toVersion: number): UpgradeReducer<any, any>;
 }
 //#endregion
-export { ReadGateOptions as $, supportsLiveReadModelRegistration as $i, SanitizedArg as $n, DuplicateOperationError as $r, ISubscriptionErrorHandler as $t, instrumentPgPool as A, ISettledWatermark as Aa, PurgeLookup as Ai, SignatureVerdict as An, DocumentIndexerDatabase as Ar, ISyncAdmin as At, InsertableDocumentSnapshot as B, SyncFailedEvent as Bi, HeartbeatMessage as Bn, DocumentStreamKey as Br, Mailbox as Bt, ReactorClientModule as C, ViewFilter$1 as Ca, ConnectionState as Ci, Subscriber as Cn, IWriteCache as Cr, StreamQuery as Ct, ForwardingPoolInstrumentation as D, CatchUpThread as Da, JwtHandler as Di, SignatureRefusalCode as Dn, FileModelSource as Dr, ConnectionStateChangeCallback as Dt, SyncModule as E, CatchUpStatus as Ea, DeadLetterAddedEvent as Ei, SIGNATURE_REFUSAL_CODES as En, DocumentModelSource as Er, createPeerAgreement as Et, PurgeFence as F, RemoteRecord as Fi, DbConfig as Fn, ICollectionMembershipCache as Fr, ISyncStatusTracker as Ft, IJobExecutor as G, SyncPendingEvent as Gi, MetricsMessage as Gn, AppendConditionFailedError as Gr, DriveRequestError as Gt, IConsistencyTracker as H, SyncHold as Hi, JobWriteReadyPayload as Hn, WriteCacheConfig as Hr, SyncOperationAggregateError as Ht, ReadModelIndexingConfig as I, RemoteStatus as Ii, DocumentModelSpec as In, DriveCollectionId as Ir, SyncStatus as It, ReactorClient as J, SyncSucceededEvent as Ji, ModelManifestEntry as Jn, DocumentAlreadyExistsError as Jr, SyncRepairRefusedError as Jt, IJobExecutorManager as K, SyncPurgeRefusedEvent as Ki, ModelLoadFailedMessage as Kn, AppendConditionStream as Kr, PollingChannelError as Kt, defaultReadModelIndexingConfig as L, SyncEnvelope as Li, ErrorInfo as Ln, IOperationIndex as Lr, SyncStatusChangeCallback as Lt, BaseReadModelConfig as M, SweepResult as Ma, RemoteFilter as Mi, SignatureVerificationMode as Mn, OperationTable as Mr, PeerManifestListener as Mt, DEFAULT_COMMIT_CHUNK_SIZE as N, WatermarkStatus as Na, RemoteOptions as Ni, SignerConfig as Nn, PurgeRemovedRows as Nr, Remote as Nt, PoolInstrumentation as O, ICatchUp as Oa, LocalPeer as Oi, SignatureScheme as On, PackageModelSource as Or, IChannel as Ot, DEFAULT_READ_MODEL_YIELD_DEADLINE_MS as P, defaultCatchUpConfig as Pa, RemotePeer as Pi, AbortMessage as Pn, IDocumentMetaCache as Pr, RemoteMeta as Pt, ModelReadGate as Q, ReadModelRegistrationStage as Qi, ResultMessage as Qn, DocumentRevisions as Qr, IReactorSubscriptionManager as Qt, unchunkedReadModelIndexingConfig as R, SyncEnvelopeType as Ri, ExecuteMessage as Rn, OperationIndexEntry as Rr, SyncStatusTracker as Rt, LoadJobPlan as S, SubmittedActionResult as Sa, ChannelScheme as Si, SignatureRefusedEvent as Sn, KyselyWriteCache as Sr, Projection as St, ReactorModule as T, CatchUpConsumerStatus as Ta, ConnectionStateSnapshot as Ti, AdmissionPath as Tn, IDocumentModelRegistry as Tr, PeerAgreementBasis as Tt, makeConsistencyKey as U, SyncOperationErrorType as Ui, LoadModelMessage as Un, APPEND_CONDITION_FAILED_PREFIX as Ur, ChannelError as Ut, ConsistencyTracker as V, SyncHeldEvent as Vi, InitMessage as Vn, KeyframeSnapshot as Vr, SyncOperation as Vt, IExecutorWorker as W, SyncOperationStatus as Wi, LogMessage as Wn, AppendCondition as Wr, DRIVE_AUTH_ERROR_MESSAGES as Wt, BareReadGate as X, IReadModel as Xi, ParentMessage as Xn, DocumentGraphEdge as Xr, isRecoverableGraphQLError as Xt, ALWAYS_READABLE_SCOPES as Y, ILiveReadModelCoordinator as Yi, ModuleRef as Yn, DocumentExistence as Yr, isDriveAuthError as Yt, IReadGate as Z, IReadModelCoordinator as Zi, ReadyMessage as Zn, DocumentRelationship as Zr, DocumentDeletedInfo as Zt, ExecutionJobPlan as _, PagingOptions as _a, ViewFilter as _i, ReactorEventTypes as _n, KyselyDocumentPurger as _r, DecisionContext as _t, ModelNotWorkerImportableError as a, PurgeJobOptions as aa, ISyncCursorStorage as ai, IQueue as an, ExecutorStartedEvent as ar, decideAtHead as at, InProcessReactorModule as b, SearchFilter as ba, ChannelHealth as bi, ReadModelIndexingStage as bn, KyselyKeyframeStore as br, Evaluation as bt, DocumentModelResolver as c, ConsistencyCoordinate as ca, ISyncPurgeRefusalStorage as ci, CatchUpSweptEvent as cn, JobExecutorConfig as cr, documentDecisionModel as ct, BatchExecutionRequest as d, ErrorInfo$1 as da, OperationFilter as di, JobPendingEvent as dn, JobResult as dr, DocumentChangeEvent as dt, IJobExecutionHandle as ea, IDocumentGraph as ei, SubscriptionErrorContext as en, ShutdownMessage as er, SeededStateReader as et, BatchExecutionResult as f, JobInfo as fa, OptimisticLockError as fi, JobReadReadyEvent as fn, JobStartedEvent as fr, DocumentChangeType as ft, DegradedComponent as g, PagedResults as ga, SyncHoldRecord as gi, PurgeMarkerContext as gn, DEFAULT_PURGE_DELETE_BATCH as gr, BuiltDecisionModel as gt, Database as h, JobStatus as ha, RevisionMismatchError as hi, ModelLoadedEvent as hn, CollectionMember as hr, ProtocolSelection as ht, InvalidModuleError as i, JobRoutingMeta as ia, IOperationStore as ii, EnqueuePurgeOptions as in, ExecutorManagerStatus as ir, RegisteredDecisionModel as it, BaseReadModel as j, SweepBlockedAt as ja, RemoteCursor as ji, SignatureVerificationHandler as jn, DocumentPurgeRow as jr, ISyncManager as jt, PoolStats as k, ICatchUpConsumer as ka, PollBehavior as ki, SignatureTrustPolicy as kn, Database$1 as kr, IChannelFactory as kt, IDocumentModelResolver as l, ConsistencyKey as la, ISyncReceivedMarkerStorage as li, EventBusAggregateError as ln, JobExecutorEventTypes as lr, ActionCandidate as lt, BatchLoadResult as m, JobResultSummary as ma, ReceivedMarkerRecord as mi, JobWriteReadyEvent as mn, IExecutionScope as mr, IReactorClient as mt, DuplicateManifestError as n, JobAvailableEvent as na, IDocumentView as ni, JobAwaiter as nn, WorkerPoolConfig as nr, readDecisionModel as nt, ModuleNotFoundError as o, QueueEventTypes as oa, ISyncDeadLetterStorage as oi, IJobTracker as on, ExecutorStoppedEvent as or, selectDecisionModel as ot, BatchLoadRequest as p, JobMeta as pa, PurgeRefusalRecord as pi, JobRunningEvent as pn, ReactorFeatureFlags as pr, IDriveClient as pt, ActionEvaluationConfig as q, SyncReleasedEvent as qi, ModelLoadedMessage as qn, AtomicTxn as qr, RECOVERABLE_GRAPHQL_ERROR_CODES as qt, DuplicateModuleError as r, JobKind as ra, IKeyframeStore as ri, DocumentPurgeService as rn, DEFAULT_MAX_PURGE_OPERATIONS as rr, AdmissionDecision as rt, loadDocumentModelSpec as s, RetryAccounting as sa, ISyncHoldStorage as si, IEventBus as sn, JobCompletedEvent as sr, DocumentDecisionModel as st, DocumentModelRegistry as t, Job as ta, IDocumentIndexer as ti, IJobAwaiter as tn, WorkerMessage as tr, SubjectScopePredicate as tt, NullDocumentModelResolver as u, ConsistencyToken as ua, ISyncRemoteStorage as ui, JobFailedEvent as un, JobFailedEvent$1 as ur, ActionEvaluations as ut, IReactor as v, PropagationMode as va, ChannelConfig as vi, ReadModelBatchCompletedEvent as vn, PurgeStream as vr, DecisionModel as vt, ReactorFeatures as w, CatchUpConfig as wa, ConnectionStateChangedEvent as wi, Unsubscribe as wn, IDocumentModelLoader as wr, IPeerAgreement as wt, InProcessSyncModule as x, ShutdownStatus as xa, ChannelMeta as xi, ReadModelStage as xn, KyselyOperationStore as xr, IStreamStateReader as xt, InProcessReactorClientModule as y, RelationshipChangeType as ya, ChannelErrorSource as yi, ReadModelIndexedEvent as yn, appliedDelete as yr, DecisionTarget as yt, DocumentViewDatabase as z, SyncEventTypes as zi, FactorySpec as zn, CachedSnapshot as zr, IMailbox as zt };
+export { DEFAULT_READ_MODEL_YIELD_DEADLINE_MS as $, SyncPendingEvent as $a, AtomicTxn as $i, QueueStateSnapshot as $n, ModelLoadedMessage as $r, PeerManifestListener as $t, PGliteFlushSyncTimeoutError as A, ConnectionState as Aa, IDocumentModelLoader as Ai, DeadLetterPage as An, SubmittedActionResult as Ao, Unsubscribe as Ar, CreateDocumentOptions as At, PGliteSessionPoisonedError as B, RemoteOptions as Ba, IDocumentMetaCache as Bi, IInspectorAdmin as Bn, AbortMessage as Br, DecisionTarget as Bt, ReactorClientModule as C, SyncHoldRecord as Ca, KyselyDocumentPurger as Ci, IJobAwaiter as Cn, JobStatus as Co, ReactorEventTypes as Cr, RegisteredDecisionModel as Ct, GroupCommitPGliteOptions as D, ChannelHealth as Da, KyselyOperationStore as Di, IQueue as Dn, RelationshipChangeType as Do, ReadModelStage as Dr, documentDecisionModel as Dt, SyncModule as E, ChannelErrorSource as Ea, KyselyKeyframeStore as Ei, EnqueuePurgeOptions as En, PropagationMode as Eo, ReadModelIndexingStage as Er, DocumentDecisionModel as Et, HardenedPGliteDialectOptions as F, LocalPeer as Fa, Database$1 as Fi, RemoteSyncInspection as Fn, SnapshotValidationIssue as Fo, SignatureTrustPolicy as Fr, ProtocolSelection as Ft, StorageHealth as G, SyncEnvelope as Ga, CachedSnapshot as Gi, InspectorAttachmentInfo as Gn, FactorySpec as Gr, IPeerAgreement as Gt, isLongRunningStatement as H, RemotePersistence as Ha, DriveCollectionId as Hi, IReactorDbQuery as Hn, DocumentModelSpec as Hr, IStreamStateReader as Ht, PGliteAbortedTransactionError as I, PollBehavior as Ia, DocumentIndexerDatabase as Ii, deriveConnectionHealth as In, StreamOrderIssue as Io, SignatureVerdict as Ir, UpgradeDocumentOptions as It, PoolStats as J, SyncFailedEvent as Ja, WriteCacheConfig as Ji, InspectorDriveIntegrity as Jn, JobWriteReadyPayload as Jr, ConnectionStateChangeCallback as Jt, ForwardingPoolInstrumentation as K, SyncEnvelopeType as Ka, DocumentStreamKey as Ki, InspectorDocumentModelInfo as Kn, HeartbeatMessage as Kr, PeerAgreementBasis as Kt, PGliteAcquireTimeoutError as L, PurgeLookup as La, DocumentPurgeRow as Li, IInspectableAttachmentStore as Ln, ValidationResult as Lo, SignatureVerificationHandler as Lr, BuiltDecisionModel as Lt, DEFAULT_RECOVERY_TIMEOUT_MS as M, ConnectionStateSnapshot as Ma, DocumentModelSource as Mi, MailboxDepths as Mn, IDocumentIntegrityService as Mo, SIGNATURE_REFUSAL_CODES as Mr, DocumentChangeType as Mt, DEFAULT_STATEMENT_TIMEOUT_MS as N, DeadLetterAddedEvent as Na, FileModelSource as Ni, RemoteConnectionHealth as Nn, KeyframeValidationIssue as No, SignatureRefusalCode as Nr, IDriveClient as Nt, IGroupCommitStorage as O, ChannelMeta as Oa, KyselyWriteCache as Oi, IJobTracker as On, SearchFilter as Oo, SignatureRefusedEvent as Or, ActionCandidate as Ot, HardenedPGliteDialect as P, JwtHandler as Pa, PackageModelSource as Pi, RemoteCursorInfo as Pn, RebuildResult as Po, SignatureScheme as Pr, IReactorClient as Pt, DEFAULT_COMMIT_CHUNK_SIZE as Q, SyncOperationStatus as Qa, AppendConditionStream as Qi, InspectorStorageHealth as Qn, ModelLoadFailedMessage as Qr, ISyncManager as Qt, PGliteSession as R, RemoteCursor as Ra, OperationTable as Ri, IInspectableQueue as Rn, OutOfOrderPair as Ro, SignatureVerificationMode as Rr, DecisionContext as Rt, LoadJobPlan as S, RevisionMismatchError as Sa, DEFAULT_PURGE_DELETE_BATCH as Si, SubscriptionErrorContext as Sn, JobResultSummary as So, PurgeMarkerContext as Sr, AdmissionDecision as St, ReactorModule as T, ChannelConfig as Ta, appliedDelete as Ti, DocumentPurgeService as Tn, PagingOptions as To, ReadModelIndexedEvent as Tr, selectDecisionModel as Tt, queryThroughDialect as U, RemoteRecord as Ua, IOperationIndex as Ui, IReactorFactsSink as Un, ErrorInfo as Ur, Projection as Ut, PGliteStatementTimeoutError as V, RemotePeer as Va, ICollectionMembershipCache as Vi, IInspectorStorageHealthProvider as Vn, DbConfig as Vr, Evaluation as Vt, IStorageHealthProvider as W, RemoteStatus as Wa, OperationIndexEntry as Wi, InspectorAccess as Wn, ExecuteMessage as Wr, StreamQuery as Wt, BaseReadModel as X, SyncHold as Xa, AppendCondition as Xi, InspectorDrivePage as Xn, LogMessage as Xr, IChannelFactory as Xt, instrumentPgPool as Y, SyncHeldEvent as Ya, APPEND_CONDITION_FAILED_PREFIX as Yi, InspectorDriveIntegrityRef as Yn, LoadModelMessage as Yr, IChannel as Yt, BaseReadModelConfig as Z, SyncOperationErrorType as Za, AppendConditionFailedError as Zi, InspectorProcessorInfo as Zn, MetricsMessage as Zr, ISyncAdmin as Zt, ExecutionJobPlan as _, ISyncRemoteStorage as _a, JobResult as _i, isDriveAuthError as _n, ConsistencyKey as _o, JobPendingEvent as _r, ModelReadGate as _t, ModelNotWorkerImportableError as a, DocumentRevisions as aa, SanitizedArg as ai, SyncStatusTracker as an, IReadModelCoordinator as ao, CatchUpStatus as ar, InsertableDocumentSnapshot as at, InProcessReactorModule as b, PurgeRefusalRecord as ba, IExecutionScope as bi, IReactorSubscriptionManager as bn, JobInfo as bo, JobWriteReadyEvent as br, SubjectScopePredicate as bt, DocumentModelResolver as c, IDocumentIndexer as ca, WorkerPoolConfig as ci, SyncOperation as cn, IJobExecutionHandle as co, ICatchUpConsumer as cr, makeConsistencyKey as ct, BatchExecutionRequest as d, IOperationStore as da, ExecutorStartedEvent as di, DRIVE_AUTH_ERROR_MESSAGES as dn, JobKind as do, SweepResult as dr, IJobExecutorManager as dt, DeadLetterRecord as ea, ModelManifestEntry as ei, Remote as en, SyncPurgeRefusedEvent as eo, ReactorInfo as er, PurgeFence as et, BatchExecutionResult as f, ISyncCursorStorage as fa, ExecutorStoppedEvent as fi, DriveRequestError as fn, JobRoutingMeta as fo, WatermarkStatus as fr, ActionEvaluationConfig as ft, DegradedComponent as g, ISyncReceivedMarkerStorage as ga, JobFailedEvent$1 as gi, SyncRepairRefusedError as gn, ConsistencyCoordinate as go, JobFailedEvent as gr, IReadGate as gt, Database as h, ISyncPurgeRefusalStorage as ha, JobExecutorEventTypes as hi, RECOVERABLE_GRAPHQL_ERROR_CODES as hn, RetryAccounting as ho, EventBusAggregateError as hr, BareReadGate as ht, InvalidModuleError as i, DocumentRelationship as ia, ResultMessage as ii, SyncStatusChangeCallback as in, IReadModel as io, CatchUpConsumerStatus as ir, DocumentViewDatabase as it, DEFAULT_LONG_STATEMENT_TIMEOUT_MS as j, ConnectionStateChangedEvent as ja, IDocumentModelRegistry as ji, ISyncInspector as jn, ViewFilter$1 as jo, AdmissionPath as jr, DocumentChangeEvent as jt, GroupCommitPGliteInstance as k, ChannelScheme as ka, IWriteCache as ki, IEventBus as kn, ShutdownStatus as ko, Subscriber as kr, ActionEvaluations as kt, IDocumentModelResolver as l, IDocumentView as la, DEFAULT_MAX_PURGE_OPERATIONS as li, SyncOperationAggregateError as ln, Job as lo, ISettledWatermark as lr, IExecutorWorker as lt, BatchLoadResult as m, ISyncHoldStorage as ma, JobExecutorConfig as mi, PollingChannelError as mn, QueueEventTypes as mo, CatchUpSweptEvent as mr, ALWAYS_READABLE_SCOPES as mt, DuplicateManifestError as n, DocumentExistence as na, ParentMessage as ni, ISyncStatusTracker as nn, SyncSucceededEvent as no, StoragePersistence as nr, defaultReadModelIndexingConfig as nt, ModuleNotFoundError as o, DuplicateOperationError as oa, ShutdownMessage as oi, IMailbox as on, ReadModelRegistrationStage as oo, CatchUpThread as or, ConsistencyTracker as ot, BatchLoadRequest as p, ISyncDeadLetterStorage as pa, JobCompletedEvent as pi, InvalidDeadLetterCursorError as pn, PurgeJobOptions as po, defaultCatchUpConfig as pr, ReactorClient as pt, PoolInstrumentation as q, SyncEventTypes as qa, KeyframeSnapshot as qi, InspectorDriveInfo as qn, InitMessage as qr, createPeerAgreement as qt, DuplicateModuleError as r, DocumentGraphEdge as ra, ReadyMessage as ri, SyncStatus as rn, ILiveReadModelCoordinator as ro, CatchUpConfig as rr, unchunkedReadModelIndexingConfig as rt, loadDocumentModelSpec as s, IDocumentGraph as sa, WorkerMessage as si, Mailbox as sn, supportsLiveReadModelRegistration as so, ICatchUp as sr, IConsistencyTracker as st, DocumentModelRegistry as t, DocumentAlreadyExistsError as ta, ModuleRef as ti, RemoteMeta as tn, SyncReleasedEvent as to, ReactorStorageFacts as tr, ReadModelIndexingConfig as tt, NullDocumentModelResolver as u, IKeyframeStore as ua, ExecutorManagerStatus as ui, ChannelError as un, JobAvailableEvent as uo, SweepBlockedAt as ur, IJobExecutor as ut, IReactor as v, OperationFilter as va, JobStartedEvent as vi, isRecoverableGraphQLError as vn, ConsistencyToken as vo, JobReadReadyEvent as vr, ReadGateOptions as vt, ReactorFeatures as w, ViewFilter as wa, PurgeStream as wi, JobAwaiter as wn, PagedResults as wo, ReadModelBatchCompletedEvent as wr, decideAtHead as wt, InProcessSyncModule as x, ReceivedMarkerRecord as xa, CollectionMember as xi, ISubscriptionErrorHandler as xn, JobMeta as xo, ModelLoadedEvent as xr, readDecisionModel as xt, InProcessReactorClientModule as y, OptimisticLockError as ya, ReactorFeatureFlags as yi, DocumentDeletedInfo as yn, ErrorInfo$1 as yo, JobRunningEvent as yr, SeededStateReader as yt, PGliteSessionError as z, RemoteFilter as za, PurgeRemovedRows as zi, IInspector as zn, firstOutOfOrderPair as zo, SignerConfig as zr, DecisionModel as zt };
 export {};
-//# sourceMappingURL=index-CNhT69De.d.ts.map
+//# sourceMappingURL=index-dDm0fUBT.d.ts.map