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

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { $ as ReadGateOptions, $i as supportsLiveReadModelRegistration, $n as SanitizedArg, $r as DuplicateOperationError, $t as ISubscriptionErrorHandler, A as instrumentPgPool, Aa as ISettledWatermark, Ai as PurgeLookup, An as SignatureVerdict, Ar as DocumentIndexerDatabase, At as ISyncAdmin, B as InsertableDocumentSnapshot, Bi as SyncFailedEvent, Bn as HeartbeatMessage, Br as DocumentStreamKey, Bt as Mailbox, C as ReactorClientModule, Ca as ViewFilter, Ci as ConnectionState, Cn as Subscriber, Cr as IWriteCache, Ct as StreamQuery, D as ForwardingPoolInstrumentation, Da as CatchUpThread, Di as JwtHandler, Dn as SignatureRefusalCode, Dr as FileModelSource, Dt as ConnectionStateChangeCallback, E as SyncModule, Ea as CatchUpStatus, Ei as DeadLetterAddedEvent, En as SIGNATURE_REFUSAL_CODES, Er as DocumentModelSource, Et as createPeerAgreement, F as PurgeFence, Fi as RemoteRecord, Fn as DbConfig, Fr as ICollectionMembershipCache, Ft as ISyncStatusTracker, G as IJobExecutor, Gi as SyncPendingEvent, Gn as MetricsMessage, Gr as AppendConditionFailedError, Gt as DriveRequestError, H as IConsistencyTracker, Hi as SyncHold, Hn as JobWriteReadyPayload, Hr as WriteCacheConfig, Ht as SyncOperationAggregateError, I as ReadModelIndexingConfig, Ii as RemoteStatus, In as DocumentModelSpec, Ir as DriveCollectionId, It as SyncStatus, J as ReactorClient, Ji as SyncSucceededEvent, Jn as ModelManifestEntry, Jr as DocumentAlreadyExistsError, Jt as SyncRepairRefusedError, K as IJobExecutorManager, Ki as SyncPurgeRefusedEvent, Kn as ModelLoadFailedMessage, Kr as AppendConditionStream, Kt as PollingChannelError, L as defaultReadModelIndexingConfig, Li as SyncEnvelope, Ln as ErrorInfo, Lr as IOperationIndex, Lt as SyncStatusChangeCallback, M as BaseReadModelConfig, Ma as SweepResult, Mi as RemoteFilter, Mn as SignatureVerificationMode, Mr as OperationTable, Mt as PeerManifestListener, N as DEFAULT_COMMIT_CHUNK_SIZE, Na as WatermarkStatus, Ni as RemoteOptions, Nn as SignerConfig, Nr as PurgeRemovedRows, Nt as Remote, O as PoolInstrumentation, Oa as ICatchUp, Oi as LocalPeer, On as SignatureScheme, Or as PackageModelSource, Ot as IChannel, P as DEFAULT_READ_MODEL_YIELD_DEADLINE_MS, Pa as defaultCatchUpConfig, Pi as RemotePeer, Pn as AbortMessage, Pr as IDocumentMetaCache, Pt as RemoteMeta, Q as ModelReadGate, Qi as ReadModelRegistrationStage, Qn as ResultMessage, Qr as DocumentRevisions, Qt as IReactorSubscriptionManager, R as unchunkedReadModelIndexingConfig, Ri as SyncEnvelopeType, Rn as ExecuteMessage, Rr as OperationIndexEntry, Rt as SyncStatusTracker, S as LoadJobPlan, Sa as SubmittedActionResult, Si as ChannelScheme, Sn as SignatureRefusedEvent, Sr as KyselyWriteCache, St as Projection, T as ReactorModule, Ta as CatchUpConsumerStatus, Ti as ConnectionStateSnapshot, Tn as AdmissionPath, Tr as IDocumentModelRegistry, Tt as PeerAgreementBasis, U as makeConsistencyKey, Ui as SyncOperationErrorType, Un as LoadModelMessage, Ur as APPEND_CONDITION_FAILED_PREFIX, Ut as ChannelError, V as ConsistencyTracker, Vi as SyncHeldEvent, Vn as InitMessage, Vr as KeyframeSnapshot, Vt as SyncOperation, W as IExecutorWorker, Wi as SyncOperationStatus, Wn as LogMessage, Wr as AppendCondition, Wt as DRIVE_AUTH_ERROR_MESSAGES, X as BareReadGate, Xi as IReadModel, Xn as ParentMessage, Xr as DocumentGraphEdge, Xt as isRecoverableGraphQLError, Y as ALWAYS_READABLE_SCOPES, Yi as ILiveReadModelCoordinator, Yn as ModuleRef, Yr as DocumentExistence, Yt as isDriveAuthError, Z as IReadGate, Zi as IReadModelCoordinator, Zn as ReadyMessage, Zr as DocumentRelationship, Zt as DocumentDeletedInfo, _ as ExecutionJobPlan, _a as PagingOptions, _i as ViewFilter$1, _n as ReactorEventTypes, _r as KyselyDocumentPurger, _t as DecisionContext, a as ModelNotWorkerImportableError, aa as PurgeJobOptions, ai as ISyncCursorStorage, an as IQueue, ar as ExecutorStartedEvent, at as decideAtHead, b as InProcessReactorModule, ba as SearchFilter, bi as ChannelHealth, bn as ReadModelIndexingStage, br as KyselyKeyframeStore, bt as Evaluation, c as DocumentModelResolver, ca as ConsistencyCoordinate, ci as ISyncPurgeRefusalStorage, cn as CatchUpSweptEvent, cr as JobExecutorConfig, ct as documentDecisionModel, d as BatchExecutionRequest, da as ErrorInfo$1, di as OperationFilter, dn as JobPendingEvent, dr as JobResult, dt as DocumentChangeEvent, ea as IJobExecutionHandle, ei as IDocumentGraph, en as SubscriptionErrorContext, er as ShutdownMessage, et as SeededStateReader, f as BatchExecutionResult, fa as JobInfo, fi as OptimisticLockError, fn as JobReadReadyEvent, fr as JobStartedEvent, ft as DocumentChangeType, g as DegradedComponent, ga as PagedResults, gi as SyncHoldRecord, gn as PurgeMarkerContext, gr as DEFAULT_PURGE_DELETE_BATCH, gt as BuiltDecisionModel, h as Database, ha as JobStatus, hi as RevisionMismatchError, hn as ModelLoadedEvent, hr as CollectionMember, ht as ProtocolSelection, i as InvalidModuleError, ia as JobRoutingMeta, ii as IOperationStore, in as EnqueuePurgeOptions, ir as ExecutorManagerStatus, it as RegisteredDecisionModel, j as BaseReadModel, ja as SweepBlockedAt, ji as RemoteCursor, jn as SignatureVerificationHandler, jr as DocumentPurgeRow, jt as ISyncManager, k as PoolStats, ka as ICatchUpConsumer, ki as PollBehavior, kn as SignatureTrustPolicy, kr as Database$1, kt as IChannelFactory, l as IDocumentModelResolver, la as ConsistencyKey, li as ISyncReceivedMarkerStorage, ln as EventBusAggregateError, lr as JobExecutorEventTypes, lt as ActionCandidate, m as BatchLoadResult, ma as JobResultSummary, mi as ReceivedMarkerRecord, mn as JobWriteReadyEvent, mr as IExecutionScope, mt as IReactorClient, n as DuplicateManifestError, na as JobAvailableEvent, ni as IDocumentView, nn as JobAwaiter, nr as WorkerPoolConfig, nt as readDecisionModel, o as ModuleNotFoundError, oa as QueueEventTypes, oi as ISyncDeadLetterStorage, on as IJobTracker, or as ExecutorStoppedEvent, ot as selectDecisionModel, p as BatchLoadRequest, pa as JobMeta, pi as PurgeRefusalRecord, pn as JobRunningEvent, pr as ReactorFeatureFlags, pt as IDriveClient, q as ActionEvaluationConfig, qi as SyncReleasedEvent, qn as ModelLoadedMessage, qr as AtomicTxn, qt as RECOVERABLE_GRAPHQL_ERROR_CODES, r as DuplicateModuleError, ra as JobKind, ri as IKeyframeStore, rn as DocumentPurgeService, rr as DEFAULT_MAX_PURGE_OPERATIONS, rt as AdmissionDecision, s as loadDocumentModelSpec, sa as RetryAccounting, si as ISyncHoldStorage, sn as IEventBus, sr as JobCompletedEvent, st as DocumentDecisionModel, t as DocumentModelRegistry, ta as Job, ti as IDocumentIndexer, tn as IJobAwaiter, tr as WorkerMessage, tt as SubjectScopePredicate, u as NullDocumentModelResolver, ua as ConsistencyToken, ui as ISyncRemoteStorage, un as JobFailedEvent$1, ur as JobFailedEvent, ut as ActionEvaluations, v as IReactor, va as PropagationMode, vi as ChannelConfig, vn as ReadModelBatchCompletedEvent, vr as PurgeStream, vt as DecisionModel, w as ReactorFeatures, wa as CatchUpConfig, wi as ConnectionStateChangedEvent, wn as Unsubscribe, wr as IDocumentModelLoader, wt as IPeerAgreement, x as InProcessSyncModule, xa as ShutdownStatus, xi as ChannelMeta, xn as ReadModelStage, xr as KyselyOperationStore, xt as IStreamStateReader, y as InProcessReactorClientModule, ya as RelationshipChangeType, yi as ChannelErrorSource, yn as ReadModelIndexedEvent, yr as appliedDelete, yt as DecisionTarget, z as DocumentViewDatabase, zi as SyncEventTypes, zn as FactorySpec, zr as CachedSnapshot, zt as IMailbox } from "./index-CNhT69De.js";
-import { Action, AuthSubject, CreateDocumentActionInput, DocumentModelModule, ISigner, Operation, OperationContext, OperationWithContext, OperationWithContext as OperationWithContext$1, PHAuthState, PHDocument, PHDocumentState, PURGE_DOCUMENT, PeerCapability, PeerManifest, PurgeDocumentAction, PurgeDocumentActionInput, PurgeMarkerOperation, SignaturePolicy, UpgradeDocumentActionInput, UpgradeManifest, actions as documentActions, isPurgeMarker } from "@powerhousedao/shared/document-model";
+import { $ as DEFAULT_READ_MODEL_YIELD_DEADLINE_MS, $a as SyncPendingEvent, $i as AtomicTxn, $n as QueueStateSnapshot, $r as ModelLoadedMessage, $t as PeerManifestListener, A as PGliteFlushSyncTimeoutError, Aa as ConnectionState, Ai as IDocumentModelLoader, An as DeadLetterPage, Ao as SubmittedActionResult, Ar as Unsubscribe, At as CreateDocumentOptions, B as PGliteSessionPoisonedError, Ba as RemoteOptions, Bi as IDocumentMetaCache, Bn as IInspectorAdmin, Br as AbortMessage, Bt as DecisionTarget, C as ReactorClientModule, Ca as SyncHoldRecord, Ci as KyselyDocumentPurger, Cn as IJobAwaiter, Co as JobStatus, Cr as ReactorEventTypes, Ct as RegisteredDecisionModel, D as GroupCommitPGliteOptions, Da as ChannelHealth, Di as KyselyOperationStore, Dn as IQueue, Do as RelationshipChangeType, Dr as ReadModelStage, Dt as documentDecisionModel, E as SyncModule, Ea as ChannelErrorSource, Ei as KyselyKeyframeStore, En as EnqueuePurgeOptions, Eo as PropagationMode, Er as ReadModelIndexingStage, Et as DocumentDecisionModel, F as HardenedPGliteDialectOptions, Fa as LocalPeer, Fi as Database$1, Fn as RemoteSyncInspection, Fo as SnapshotValidationIssue, Fr as SignatureTrustPolicy, Ft as ProtocolSelection, G as StorageHealth, Ga as SyncEnvelope, Gi as CachedSnapshot, Gn as InspectorAttachmentInfo, Gr as FactorySpec, Gt as IPeerAgreement, H as isLongRunningStatement, Ha as RemotePersistence, Hi as DriveCollectionId, Hn as IReactorDbQuery, Hr as DocumentModelSpec, Ht as IStreamStateReader, I as PGliteAbortedTransactionError, Ia as PollBehavior, Ii as DocumentIndexerDatabase, In as deriveConnectionHealth, Io as StreamOrderIssue, Ir as SignatureVerdict, It as UpgradeDocumentOptions, J as PoolStats, Ja as SyncFailedEvent, Ji as WriteCacheConfig, Jn as InspectorDriveIntegrity, Jr as JobWriteReadyPayload, Jt as ConnectionStateChangeCallback, K as ForwardingPoolInstrumentation, Ka as SyncEnvelopeType, Ki as DocumentStreamKey, Kn as InspectorDocumentModelInfo, Kr as HeartbeatMessage, Kt as PeerAgreementBasis, L as PGliteAcquireTimeoutError, La as PurgeLookup, Li as DocumentPurgeRow, Ln as IInspectableAttachmentStore, Lo as ValidationResult, Lr as SignatureVerificationHandler, Lt as BuiltDecisionModel, M as DEFAULT_RECOVERY_TIMEOUT_MS, Ma as ConnectionStateSnapshot, Mi as DocumentModelSource, Mn as MailboxDepths, Mo as IDocumentIntegrityService, Mr as SIGNATURE_REFUSAL_CODES, Mt as DocumentChangeType, N as DEFAULT_STATEMENT_TIMEOUT_MS, Na as DeadLetterAddedEvent, Ni as FileModelSource, Nn as RemoteConnectionHealth, No as KeyframeValidationIssue, Nr as SignatureRefusalCode, Nt as IDriveClient, O as IGroupCommitStorage, Oa as ChannelMeta, Oi as KyselyWriteCache, On as IJobTracker, Oo as SearchFilter, Or as SignatureRefusedEvent, Ot as ActionCandidate, P as HardenedPGliteDialect, Pa as JwtHandler, Pi as PackageModelSource, Pn as RemoteCursorInfo, Po as RebuildResult, Pr as SignatureScheme, Pt as IReactorClient, Q as DEFAULT_COMMIT_CHUNK_SIZE, Qa as SyncOperationStatus, Qi as AppendConditionStream, Qn as InspectorStorageHealth, Qr as ModelLoadFailedMessage, Qt as ISyncManager, R as PGliteSession, Ra as RemoteCursor, Ri as OperationTable, Rn as IInspectableQueue, Ro as OutOfOrderPair, Rr as SignatureVerificationMode, Rt as DecisionContext, S as LoadJobPlan, Sa as RevisionMismatchError, Si as DEFAULT_PURGE_DELETE_BATCH, Sn as SubscriptionErrorContext, So as JobResultSummary, Sr as PurgeMarkerContext, St as AdmissionDecision, T as ReactorModule, Ta as ChannelConfig, Ti as appliedDelete, Tn as DocumentPurgeService, To as PagingOptions, Tr as ReadModelIndexedEvent, Tt as selectDecisionModel, U as queryThroughDialect, Ua as RemoteRecord, Ui as IOperationIndex, Un as IReactorFactsSink, Ur as ErrorInfo, Ut as Projection, V as PGliteStatementTimeoutError, Va as RemotePeer, Vi as ICollectionMembershipCache, Vn as IInspectorStorageHealthProvider, Vr as DbConfig, Vt as Evaluation, W as IStorageHealthProvider, Wa as RemoteStatus, Wi as OperationIndexEntry, Wn as InspectorAccess, Wr as ExecuteMessage, Wt as StreamQuery, X as BaseReadModel, Xa as SyncHold, Xi as AppendCondition, Xn as InspectorDrivePage, Xr as LogMessage, Xt as IChannelFactory, Y as instrumentPgPool, Ya as SyncHeldEvent, Yi as APPEND_CONDITION_FAILED_PREFIX, Yn as InspectorDriveIntegrityRef, Yr as LoadModelMessage, Yt as IChannel, Z as BaseReadModelConfig, Za as SyncOperationErrorType, Zi as AppendConditionFailedError, Zn as InspectorProcessorInfo, Zr as MetricsMessage, Zt as ISyncAdmin, _ as ExecutionJobPlan, _a as ISyncRemoteStorage, _i as JobResult, _n as isDriveAuthError, _o as ConsistencyKey, _r as JobPendingEvent, _t as ModelReadGate, a as ModelNotWorkerImportableError, aa as DocumentRevisions, ai as SanitizedArg, an as SyncStatusTracker, ao as IReadModelCoordinator, ar as CatchUpStatus, at as InsertableDocumentSnapshot, b as InProcessReactorModule, ba as PurgeRefusalRecord, bi as IExecutionScope, bn as IReactorSubscriptionManager, bo as JobInfo, br as JobWriteReadyEvent, bt as SubjectScopePredicate, c as DocumentModelResolver, ca as IDocumentIndexer, ci as WorkerPoolConfig, cn as SyncOperation, co as IJobExecutionHandle, cr as ICatchUpConsumer, ct as makeConsistencyKey, d as BatchExecutionRequest, da as IOperationStore, di as ExecutorStartedEvent, dn as DRIVE_AUTH_ERROR_MESSAGES, do as JobKind, dr as SweepResult, dt as IJobExecutorManager, ea as DeadLetterRecord, ei as ModelManifestEntry, en as Remote, eo as SyncPurgeRefusedEvent, er as ReactorInfo, et as PurgeFence, f as BatchExecutionResult, fa as ISyncCursorStorage, fi as ExecutorStoppedEvent, fn as DriveRequestError, fo as JobRoutingMeta, fr as WatermarkStatus, ft as ActionEvaluationConfig, g as DegradedComponent, ga as ISyncReceivedMarkerStorage, gi as JobFailedEvent, gn as SyncRepairRefusedError, go as ConsistencyCoordinate, gr as JobFailedEvent$1, gt as IReadGate, h as Database, ha as ISyncPurgeRefusalStorage, hi as JobExecutorEventTypes, hn as RECOVERABLE_GRAPHQL_ERROR_CODES, ho as RetryAccounting, hr as EventBusAggregateError, ht as BareReadGate, i as InvalidModuleError, ia as DocumentRelationship, ii as ResultMessage, in as SyncStatusChangeCallback, io as IReadModel, ir as CatchUpConsumerStatus, it as DocumentViewDatabase, j as DEFAULT_LONG_STATEMENT_TIMEOUT_MS, ja as ConnectionStateChangedEvent, ji as IDocumentModelRegistry, jn as ISyncInspector, jo as ViewFilter, jr as AdmissionPath, jt as DocumentChangeEvent, k as GroupCommitPGliteInstance, ka as ChannelScheme, ki as IWriteCache, kn as IEventBus, ko as ShutdownStatus, kr as Subscriber, kt as ActionEvaluations, l as IDocumentModelResolver, la as IDocumentView, li as DEFAULT_MAX_PURGE_OPERATIONS, ln as SyncOperationAggregateError, lo as Job, lr as ISettledWatermark, lt as IExecutorWorker, m as BatchLoadResult, ma as ISyncHoldStorage, mi as JobExecutorConfig, mn as PollingChannelError, mo as QueueEventTypes, mr as CatchUpSweptEvent, mt as ALWAYS_READABLE_SCOPES, n as DuplicateManifestError, na as DocumentExistence, ni as ParentMessage, nn as ISyncStatusTracker, no as SyncSucceededEvent, nr as StoragePersistence, nt as defaultReadModelIndexingConfig, o as ModuleNotFoundError, oa as DuplicateOperationError, oi as ShutdownMessage, on as IMailbox, oo as ReadModelRegistrationStage, or as CatchUpThread, ot as ConsistencyTracker, p as BatchLoadRequest, pa as ISyncDeadLetterStorage, pi as JobCompletedEvent, pn as InvalidDeadLetterCursorError, po as PurgeJobOptions, pr as defaultCatchUpConfig, pt as ReactorClient, q as PoolInstrumentation, qa as SyncEventTypes, qi as KeyframeSnapshot, qn as InspectorDriveInfo, qr as InitMessage, qt as createPeerAgreement, r as DuplicateModuleError, ra as DocumentGraphEdge, ri as ReadyMessage, rn as SyncStatus, ro as ILiveReadModelCoordinator, rr as CatchUpConfig, rt as unchunkedReadModelIndexingConfig, s as loadDocumentModelSpec, sa as IDocumentGraph, si as WorkerMessage, sn as Mailbox, so as supportsLiveReadModelRegistration, sr as ICatchUp, st as IConsistencyTracker, t as DocumentModelRegistry, ta as DocumentAlreadyExistsError, ti as ModuleRef, tn as RemoteMeta, to as SyncReleasedEvent, tr as ReactorStorageFacts, tt as ReadModelIndexingConfig, u as NullDocumentModelResolver, ua as IKeyframeStore, ui as ExecutorManagerStatus, un as ChannelError, uo as JobAvailableEvent, ur as SweepBlockedAt, ut as IJobExecutor, v as IReactor, va as OperationFilter, vi as JobStartedEvent, vn as isRecoverableGraphQLError, vo as ConsistencyToken, vr as JobReadReadyEvent, vt as ReadGateOptions, w as ReactorFeatures, wa as ViewFilter$1, wi as PurgeStream, wn as JobAwaiter, wo as PagedResults, wr as ReadModelBatchCompletedEvent, wt as decideAtHead, x as InProcessSyncModule, xa as ReceivedMarkerRecord, xi as CollectionMember, xn as ISubscriptionErrorHandler, xo as JobMeta, xr as ModelLoadedEvent, xt as readDecisionModel, y as InProcessReactorClientModule, ya as OptimisticLockError, yi as ReactorFeatureFlags, yn as DocumentDeletedInfo, yo as ErrorInfo$1, yr as JobRunningEvent, yt as SeededStateReader, z as PGliteSessionError, za as RemoteFilter, zi as PurgeRemovedRows, zn as IInspector, zo as firstOutOfOrderPair, zr as SignerConfig, zt as DecisionModel } from "./index-dDm0fUBT.js";
+import { Action, AuthSubject, CreateDocumentActionInput, DocumentModelModule, ISigner, Operation, OperationContext, OperationWithContext, OperationWithContext as OperationWithContext$1, PHAuthState, PHDocument, PHDocumentState, PURGE_DOCUMENT, PeerCapability, PeerManifest, ProtocolVersions, PurgeDocumentAction, PurgeDocumentActionInput, PurgeMarkerOperation, SignaturePolicy, UpgradeDocumentActionInput, UpgradeManifest, actions as documentActions, isPurgeMarker } from "@powerhousedao/shared/document-model";
 import { DocumentDriveDocument, DriveInput, FolderNode, Node } from "@powerhousedao/shared/document-drive";
 import { ILogger } from "document-model";
-import { DatabaseIntrospector, Dialect, DialectAdapter, Driver, Kysely, QueryCompiler, Transaction } from "kysely";
+import { Kysely, Transaction } from "kysely";
 import { IProcessor, IProcessorHostModuleBase, IProcessorHostModuleBase as IProcessorHostModuleBase$1, IProcessorManager, IProcessorManager as IProcessorManager$1, IRelationalDb, ProcessorApp, ProcessorFactory, ProcessorFactory as ProcessorFactory$1, ProcessorFactoryBuilder, ProcessorFilter, ProcessorRecord, ProcessorRecord as ProcessorRecord$1, ProcessorStatus, RelationalDbProcessor, TrackedProcessor, TrackedProcessor as TrackedProcessor$1, createRelationalDb } from "@powerhousedao/shared/processors";
 import "node:worker_threads";
 //#region src/attachments/types.d.ts
@@ -55,14 +55,43 @@ export declare function updateRelationshipAction(sourceId: string, targetId: str
  */
 export declare function removeRelationshipAction(sourceId: string, targetId: string, relationshipType?: string): Action;
 //#endregion
+//#region src/storage/storage-flush.d.ts
+/**
+ * The durability barrier the reactor's two acknowledgment boundaries sit
+ * behind, for an embedded store whose statements do not flush themselves.
+ *
+ *  1. A sync cursor write flushes first, so no cursor row is ever durable
+ *     ahead of the operations it covers (FlushGuardedSyncCursorStorage).
+ *  2. A job's write-ready announcement, which `waitForJob` turns into terminal
+ *     success, waits for a flush covering the job's commit - except a load a
+ *     sync cursor protects, whose operations are re-pulled if lost.
+ *
+ * A store durable per statement uses {@link NoopStorageFlusher}.
+ */
+interface IStorageFlusher {
+  /**
+   * Resolves once every write issued before the call is durable. Rejects with
+   * {@link StoragePoisonedError} once the store can make nothing durable again.
+   */
+  flush(): Promise<void>;
+}
+/** The store's session is poisoned; only a host restart recovers it. */
+export declare class StoragePoisonedError extends Error {
+  constructor(message: string, cause?: unknown);
+}
+//#endregion
 //#region src/client/drive-client.d.ts
+/** The client members a {@link DriveClient} reads and writes through. */
+type DriveClientDeps = Pick<IReactorClient, "get" | "execute" | "create" | "setPreferredEditor" | "getCreateSignaturePolicy" | "getCreateProtocolVersions" | "waitForJob">;
+type BatchSubmitter = (request: BatchExecutionRequest, signal?: AbortSignal) => Promise<BatchExecutionResult>;
 export declare class DriveClient implements IDriveClient {
   private readonly client;
   private readonly logger;
-  private readonly reactor;
   private readonly signer;
   private readonly resolveReference;
-  constructor(client: IReactorClient, logger: ILogger, reactor: IReactor, signer: ISigner, resolveReference: (identifier: string, signal?: AbortSignal) => Promise<string>);
+  private readonly executeBatch;
+  /** `submitter` may still be an IReactor, whose executeBatch is used. */
+  constructor(client: DriveClientDeps, logger: ILogger, submitter: BatchSubmitter | IReactor, signer: ISigner, resolveReference: (identifier: string, signal?: AbortSignal) => Promise<string>);
   create(input: DriveInput, signal?: AbortSignal): Promise<DocumentDriveDocument>;
   addFile<TDocument extends PHDocument = PHDocument>(driveIdentifier: string, document: PHDocument, parentFolder?: string, signal?: AbortSignal): Promise<TDocument>;
   addFolder(driveIdentifier: string, name: string, parentFolder?: string, signal?: AbortSignal): Promise<FolderNode>;
@@ -84,6 +113,24 @@ export declare class DriveClient implements IDriveClient {
   private removeFileNode;
 }
 //#endregion
+//#region src/client/derivations.d.ts
+/** The signed jobs that create `document`, and attach it to `parentId`. */
+export declare function buildCreateJobs(document: PHDocument, parentId: string | undefined, signer: ISigner, signal?: AbortSignal): Promise<ExecutionJobPlan[]>;
+/** The registered module for a type: the requested version, else the latest. */
+export declare function selectDocumentModelModule(modules: readonly DocumentModelModule[], documentModelType: string, documentModelVersion?: number): DocumentModelModule;
+/** A new, empty document of `module`, under the create defaults given. */
+export declare function createEmptyDocument(module: DocumentModelModule, options: CreateDocumentOptions | undefined, defaultPolicy: SignaturePolicy, baseVersions: ProtocolVersions): PHDocument;
+type UpgradeDocumentDeps = {
+  readonly signer: ISigner;
+  read<TDocument extends PHDocument>(identifier: string, branch: string | undefined, consistencyToken: ConsistencyToken | undefined, signal?: AbortSignal): Promise<TDocument>;
+  getDocumentModelModule(documentType: string): Promise<DocumentModelModule>;
+  /** Submits signed actions and returns the job, without waiting. */
+  submit(documentId: string, branch: string, actions: Action[], signal?: AbortSignal): Promise<JobInfo>;
+  waitForJob(job: JobInfo, signal?: AbortSignal): Promise<JobInfo>;
+};
+/** Retries from a fresh read when a concurrent edit invalidates the snapshot. */
+export declare function upgradeDocumentWith<TDocument extends PHDocument>(deps: UpgradeDocumentDeps, documentIdentifier: string, toVersion?: number, options?: UpgradeDocumentOptions, signal?: AbortSignal): Promise<TDocument>;
+//#endregion
 //#region src/executor/worker-pool-job-executor-manager.d.ts
 /**
  * Factory invoked once per worker at `start()` time. The index is the
@@ -515,6 +562,7 @@ export declare class HybridProjectionCoordinator implements ILiveReadModelCoordi
   /** Wired as `onReadReady`; host trackers are already advanced (port FIFO). */
   acceptReadReady(event: JobReadReadyEvent): void;
   addReadModel(readModel: IReadModel, stage: ReadModelRegistrationStage): void;
+  removeReadModel(readModel: IReadModel): boolean;
   getChainDepth(): number;
   indexedReadModels(): readonly IReadModel[];
   catchUpStatuses(): CatchUpStatus[];
@@ -547,16 +595,20 @@ export declare class SyncBuilder {
   private holdStorage?;
   private receivedMarkerStorage?;
   private purgeRefusalStorage?;
+  private storageFlusher;
   private config;
   withChannelFactory(factory: IChannelFactory): this;
   withRemoteStorage(storage: ISyncRemoteStorage): this;
   withCursorStorage(storage: ISyncCursorStorage): this;
+  /** The barrier every cursor write, including a custom storage's, goes behind. */
+  withStorageFlusher(flusher: IStorageFlusher): this;
   withDeadLetterStorage(storage: ISyncDeadLetterStorage): this;
   withHoldStorage(storage: ISyncHoldStorage): this;
   withReceivedMarkerStorage(storage: ISyncReceivedMarkerStorage): this;
   withPurgeRefusalStorage(storage: ISyncPurgeRefusalStorage): this;
   withMaxDeadLettersPerRemote(limit: number): this;
   withMaxInboxBatchSize(limit: number): this;
+  withMaxConcurrentInboxChunks(limit: number): this;
   withMaxHeldOperationsPerRemote(limit: number): this;
   withStaleRemotePollWindowMs(windowMs: number): this;
   build(reactor: IReactor, logger: ILogger, operationIndex: IOperationIndex, eventBus: IEventBus, db: Kysely<Database$1>, driveContainerTypes: ReadonlySet<string>, watermark: ISettledWatermark, localPeer?: LocalPeer): ISyncManager;
@@ -687,6 +739,8 @@ export declare class ReactorBuilder {
   private readModelCoordinator?;
   private readModelCoordinatorFactory?;
   private kyselyInstance?;
+  private storageFactsOverride?;
+  private groupCommitPGlite?;
   private signer?;
   private workerSigner?;
   private trustPolicy?;
@@ -694,6 +748,7 @@ export declare class ReactorBuilder {
   private signalHandlersEnabled;
   private queueInstance?;
   private channelScheme?;
+  private readonly additionalChannelFactories;
   private jwtHandler?;
   private documentModelLoader?;
   private shutdownHooks;
@@ -771,6 +826,17 @@ export declare class ReactorBuilder {
   /** Whether {@link withTrustPolicy} was called. */
   hasTrustPolicy(): boolean;
   withKysely(kysely: Kysely<Database>): this;
+  /** Declares the store's facts; without it a caller-supplied store is unknown. */
+  withStorageFacts(facts: ReactorStorageFacts): this;
+  /**
+   * Runs the reactor on an embedded PGlite with group commit: statements stop
+   * syncing the filesystem, and the flush moves to a job's write-ready and
+   * every sync cursor write. A poisoned session goes to `onUnrecoverable`,
+   * since a fallback would leave in-memory read-model positions ahead of the
+   * store. The caller keeps `pg` if the build fails; once built, the module's
+   * `groupCommitStorage` closes it.
+   */
+  withGroupCommitPGlite(options: GroupCommitPGliteOptions): this;
   /**
    * Register an externally-constructed pg.Pool's {@link PoolInstrumentation}
    * so it surfaces through {@link ReactorModule.pools}. Use this when the
@@ -780,8 +846,17 @@ export declare class ReactorBuilder {
    */
   withInstrumentedPool(instrumentation: PoolInstrumentation): this;
   withQueue(queue: IQueue): this;
-  /** Mutually exclusive with {@link withSync}; setting both fails the build. */
+  /**
+   * Mutually exclusive with {@link withSync}; setting both fails the build.
+   * Compose further transports onto the scheme with {@link withAdditionalChannelFactory}.
+   */
   withChannelScheme(scheme: ChannelScheme): this;
+  /**
+   * Routes `type` to `factory` beside the {@link withChannelScheme} scheme's
+   * own factory, through a {@link CompositeChannelFactory}. Build refuses it
+   * without a scheme, or when `type` is the scheme's own.
+   */
+  withAdditionalChannelFactory(type: string, factory: IChannelFactory): this;
   withJwtHandler(handler: JwtHandler): this;
   withDocumentModelLoader(loader: IDocumentModelLoader): this;
   withSignalHandlers(): this;
@@ -830,6 +905,18 @@ export declare class ReactorBuilder {
   getImportableEntries(documentType: string): ModelManifestEntry[];
   build(): Promise<IReactor>;
   buildModule(): Promise<InProcessReactorModule>;
+  /** Refuses what would bypass the flush or leave a poison with no owner. */
+  private assertStorageConfiguration;
+  /**
+   * A committed job waits for its flush, the statement in flight then one
+   * sync, and withholds past that wait. Statements before the commit queue
+   * behind the same flush, so the job timeout outlasts the wait too.
+   */
+  private fitJobTimeoutToDurability;
+  private assembleModule;
+  private assertAdditionalChannelFactories;
+  /** Bare without additional factories, so an existing reactor routes as before. */
+  private buildSchemeChannelFactory;
   /**
    * The single Postgres config for the parent, executor workers, and
    * projection shards. They must share one physical database (the parent
@@ -1154,6 +1241,11 @@ export declare function parseDriveUrl(url: string): ParsedDriveUrl;
 export declare function driveIdFromUrl(url: string): string;
 //#endregion
 //#region src/shared/errors.d.ts
+/**
+ * Error thrown when attempting to access a deleted document.
+ */
+/** The error name on a job the reactor does not know. */
+export declare const JOB_NOT_FOUND_ERROR_NAME = "JobNotFoundError";
 /** The message carries the code: only name and message cross the queue. */
 export declare class InvalidSignatureError extends Error {
   readonly documentId: string;
@@ -1387,6 +1479,8 @@ export declare class InMemoryQueue implements IQueue {
   private jobIdToDocId;
   private completedJobs;
   private jobIndex;
+  private jobIdToSeq;
+  private nextSeq;
   private isBlocked;
   private onDrainedCallback?;
   private isPausedFlag;
@@ -1555,11 +1649,13 @@ export declare class SimpleJobExecutor implements IJobExecutor {
   private documentActionHandler;
   private executionScope;
   private signer;
+  private readonly flusher;
   /**
    * `signer` signs the operations the reducer synthesizes; unsigned if omitted.
    * `trustPolicy` decides which keys may sign as which users at admission.
+   * `flusher` makes a job durable before its write-ready is announced.
    */
-  constructor(logger: ILogger, registry: IDocumentModelRegistry, operationStore: IOperationStore, eventBus: IEventBus, writeCache: IWriteCache, operationIndex: IOperationIndex, documentMetaCache: IDocumentMetaCache, collectionMembershipCache: ICollectionMembershipCache, driveContainerTypes: ReadonlySet<string>, config: JobExecutorConfig, executionScope?: IExecutionScope, signer?: ISigner, trustPolicy?: SignatureTrustPolicy);
+  constructor(logger: ILogger, registry: IDocumentModelRegistry, operationStore: IOperationStore, eventBus: IEventBus, writeCache: IWriteCache, operationIndex: IOperationIndex, documentMetaCache: IDocumentMetaCache, collectionMembershipCache: ICollectionMembershipCache, driveContainerTypes: ReadonlySet<string>, config: JobExecutorConfig, executionScope?: IExecutionScope, signer?: ISigner, trustPolicy?: SignatureTrustPolicy, flusher?: IStorageFlusher);
   /**
    * Execute a single job by applying all its actions through the appropriate reducers.
    * Actions are processed sequentially in order.
@@ -1579,7 +1675,17 @@ export declare class SimpleJobExecutor implements IJobExecutor {
    * but nothing here closes it, and a caller that needs to know a write is
    * real has the job status to ask.
    */
-  executeJob(job: Job, signal?: AbortSignal): Promise<JobResult>;
+  executeJob(job: Job, signal?: AbortSignal, onCommitting?: () => void): Promise<JobResult>;
+  /**
+   * Waits for a flush covering the committed job before its write-ready goes
+   * out; false withholds the announcement. A failed flush is never a failed
+   * job, since the commit stands: it is retried, and the announcement is
+   * withheld once the store is poisoned (the host restarts), the attempts run
+   * out, the wait outlives `durabilityWaitMs`, or the job's signal aborts.
+   */
+  private awaitDurable;
+  /** Settles with TIMED_OUT at the deadline or on abort; the wait itself is abandoned. */
+  private withinDurabilityWait;
   /**
    * The body of a job, run inside the execution scope's transaction.
    *
@@ -1772,6 +1878,26 @@ export declare class SimpleJobExecutor implements IJobExecutor {
   private accumulateResultOrReturnError;
 }
 //#endregion
+//#region src/executor/worker-pool-router.d.ts
+/**
+ * Sticky-by-document routing for the executor worker pool.
+ *
+ * Hashes `documentId` to a stable bucket so every job on a given document
+ * lands on the same worker. The queue already enforces "at most one job
+ * executing per document at a time", so a sticky worker always sees a fresh
+ * post-commit snapshot before its next job on that document — which keeps
+ * the per-worker `IWriteCache` and `IDocumentMetaCache` coherent for free.
+ *
+ * The hash is FNV-1a 32-bit: deterministic, dependency-free, and stable
+ * across processes (so the same routing decision can be reproduced anywhere
+ * the documentId is known).
+ *
+ * @see Executor Worker Pool Design wiki page
+ *   (Powerhouse board wiki id: d400d711-f07e-4389-a226-4e9fdd4fa8ba)
+ */
+export declare function hashDocumentId(documentId: string): number;
+export declare function bucketFor(documentId: string, numWorkers: number): number;
+//#endregion
 //#region src/executor/worker/forwarding-logger.d.ts
 export declare function createForwardingLogger(post: (msg: LogMessage) => void, level?: ILogger["level"], tags?: string[]): ILogger;
 //#endregion
@@ -1829,32 +1955,6 @@ export declare class SyncScopeGate {
   scopePredicateById(documentId: string, subject: AuthSubject, branch: string, signal?: AbortSignal): Promise<(scope: string) => boolean>;
 }
 //#endregion
-//#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";
-};
-/**
- * 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.
- */
-export declare function firstOutOfOrderPair(operations: Operation[], options?: {
-  requireStrict?: boolean;
-}): OutOfOrderPair | undefined;
-//#endregion
 //#region src/storage/kysely/document-indexer.d.ts
 type IndexerDatabase = Database$1 & DocumentIndexerDatabase & DocumentViewDatabase;
 export declare class KyselyDocumentIndexer extends BaseReadModel implements IDocumentIndexer {
@@ -1879,69 +1979,6 @@ export declare class KyselyDocumentIndexer extends BaseReadModel implements IDoc
   private handleUpdateRelationship;
 }
 //#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;
-};
-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;
-};
-export declare const DEFAULT_STATEMENT_TIMEOUT_MS = 120000;
-export declare const DEFAULT_LONG_STATEMENT_TIMEOUT_MS = 900000;
-export declare const DEFAULT_RECOVERY_TIMEOUT_MS = 15000;
-/** Maintenance and DDL, matched on the leading keyword of the compiled SQL. */
-export declare function isLongRunningStatement(statement: string): boolean;
-type IntrospectedDatabase = Parameters<Dialect["createIntrospector"]>[0];
-export declare class PGliteSessionError extends Error {
-  readonly cause?: unknown;
-  constructor(message: string, cause?: unknown);
-}
-export declare class PGliteAcquireTimeoutError extends PGliteSessionError {
-  constructor(timeoutMs: number);
-}
-/** The call cannot be aborted, so it is abandoned and the session treated as poisoned. */
-export declare class PGliteStatementTimeoutError extends PGliteSessionError {
-  constructor(timeoutMs: number, statement: string);
-}
-export declare class PGliteAbortedTransactionError extends PGliteSessionError {
-  constructor(cause: unknown);
-}
-/** No statement can clear the session (e.g. a stuck active portal). */
-export declare class PGliteSessionPoisonedError extends PGliteSessionError {
-  constructor(cause: unknown);
-}
-/** `kysely-pglite-dialect` hardened for one shared session that a fault must not brick. */
-export 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. */
-export declare function queryThroughDialect<DB>(db: Kysely<DB>, sql: string, params?: unknown[]): Promise<unknown[]>;
-//#endregion
 //#region src/read-models/coordinator.d.ts
 /**
  * Coordinates read model synchronization by listening to operation write events
@@ -1971,6 +2008,7 @@ export declare class ReadModelCoordinator implements ILiveReadModelCoordinator {
   getChainDepth(): number;
   indexedReadModels(): readonly IReadModel[];
   addReadModel(readModel: IReadModel, stage: ReadModelRegistrationStage): void;
+  removeReadModel(readModel: IReadModel): boolean;
   private handleWriteReady;
   private emitEmptyReadReady;
   private runChain;
@@ -2141,7 +2179,56 @@ export declare class KyselySyncRemoteStorage implements ISyncRemoteStorage {
   remove(name: string, signal?: AbortSignal): Promise<void>;
 }
 //#endregion
+//#region src/sync/channels/composite-channel-factory.d.ts
+/**
+ * An {@link IChannelFactory} that dispatches to one of several factories on
+ * {@link ChannelConfig.type}.
+ *
+ * This is the seam that lets ONE reactor hold remotes of more than one
+ * transport at once -- gql remotes to a Switchboard AND brokered
+ * `LocalChannel` peers (multi-reactor W3.0). Before it, a reactor wired a
+ * single factory, so a local-sync reactor was local-only and a gql reactor
+ * could not adopt a local peer; every mixed topology was out of reach.
+ *
+ * Routing is strict and total: a config whose type no registered factory
+ * claims is refused by name rather than handed to whichever factory happens to
+ * be first. That refusal is the point -- the single-factory world answered a
+ * `{ type: "local" }` config on a gql reactor with a complaint about a missing
+ * `url`, which says nothing about what is actually wrong.
+ *
+ * The composite adds no behaviour of its own: it holds no queue, no transport
+ * and no logger, and every argument is passed through untouched. Which types a
+ * reactor registers is the builder's decision (`ReactorBuilder`), not this
+ * class's.
+ */
+export declare class CompositeChannelFactory implements IChannelFactory {
+  private readonly factories;
+  /**
+   * @param factories - (channel-config type -> factory) pairs. A duplicated
+   *   type is refused rather than silently resolved to the last entry: two
+   *   factories claiming one type is a configuration mistake with no correct
+   *   answer.
+   * @throws Error if `factories` is empty or names a type twice
+   */
+  constructor(factories: Iterable<readonly [string, IChannelFactory]>);
+  /**
+   * Creates a channel with the factory registered for `config.type`.
+   *
+   * @throws Error if no factory is registered for that type
+   */
+  instance(remoteId: string, remoteName: string, config: ChannelConfig, cursorStorage: ISyncCursorStorage, collectionId: DriveCollectionId, filter: RemoteFilter, operationIndex: IOperationIndex, options?: RemoteOptions): IChannel;
+  /** The types it routes, in registration order. */
+  get channelTypes(): readonly string[];
+}
+//#endregion
 //#region src/sync/channels/gql-request-channel-factory.d.ts
+/**
+ * The {@link ChannelConfig.type} a GqlRequestChannel is created from.
+ *
+ * Named so {@link CompositeChannelFactory} registration and the callers that
+ * build a `{ type: "gql" }` config agree on one spelling.
+ */
+export declare const GQL_CHANNEL_TYPE = "gql";
 /**
  * Factory for creating GqlRequestChannel instances.
  *
@@ -2152,6 +2239,7 @@ export declare class KyselySyncRemoteStorage implements ISyncRemoteStorage {
  * which is useful for short-lived tokens with audience-specific claims.
  */
 export declare class GqlRequestChannelFactory implements IChannelFactory {
+  readonly channelTypes: string[];
   private readonly logger;
   private readonly jwtHandler?;
   private readonly queue;
@@ -2169,15 +2257,30 @@ export declare class GqlRequestChannelFactory implements IChannelFactory {
 }
 //#endregion
 //#region src/sync/channels/gql-response-channel-factory.d.ts
+/**
+ * The {@link ChannelConfig.type} a GqlResponseChannel is created from.
+ *
+ * A response channel is never configured by this reactor: it is registered by
+ * the peer that polls it, over the `registerChannel` mutation, whose resolver
+ * (`packages/reactor-api`) writes exactly this type. Named here so
+ * {@link CompositeChannelFactory} registration for the SWITCHBOARD scheme
+ * routes the configs that actually arrive.
+ */
+export declare const POLLING_CHANNEL_TYPE = "polling";
 /**
  * Factory for creating GqlResponseChannel instances.
  */
 export declare class GqlResponseChannelFactory implements IChannelFactory {
+  readonly channelTypes: string[];
   private readonly logger;
   constructor(logger: ILogger);
   instance(remoteId: string, remoteName: string, config: ChannelConfig, cursorStorage: ISyncCursorStorage): IChannel;
 }
 //#endregion
+//#region src/sync/channels/channel-factory-types.d.ts
+/** The channel types a built factory declares; empty when it declares none. */
+export declare function channelFactoryTypes(factory: IChannelFactory): readonly string[];
+//#endregion
 //#region src/sync/channels/poll-timer.d.ts
 /** Once `signal` aborts, settle promptly and stop mutating shared state. */
 type PollDelegate = (signal: AbortSignal | undefined) => Promise<void>;
@@ -2480,6 +2583,395 @@ export declare class GqlResponseChannel implements IChannel {
   private unservedFloor;
 }
 //#endregion
+//#region src/sync/channels/local-channel-transport.d.ts
+/**
+ * The environment-neutral transport {@link LocalChannel} speaks over.
+ *
+ * A LocalChannel never touches a real MessagePort directly: it depends only on
+ * this interface so the same channel runs over a browser MessagePort, a
+ * `node:worker_threads` MessagePort, or an in-process stub in a test. Whatever
+ * crosses `postMessage` must be structured-clone-safe -- plain data, never a
+ * function or a closure -- because a real port clones it.
+ */
+interface LocalChannelPort {
+  /** Sends one structured-clone-safe message to the peer. */
+  postMessage(data: unknown): void;
+  /** Registers a listener for messages from the peer; returns its removal. */
+  onMessage(callback: (data: unknown) => void): () => void;
+  /** Releases the transport. Idempotent; the registrant calls it, not a channel. */
+  close(): void;
+}
+/**
+ * Resolves the transport for a remote from its channel config.
+ *
+ * The factory holds one of these rather than taking a port directly, because
+ * {@link IChannelFactory.instance} has no seam for a live object and a port is
+ * not clone-safe config. W1.2 supplies a real brokered MessagePort by keying it
+ * here under the same (peerId, channelName) the config names, with no change to
+ * the channel.
+ *
+ * Returns undefined when nothing is registered for the key; the factory turns
+ * that into a thrown error so a misconfigured remote fails loudly at init.
+ */
+type LocalChannelTransportProvider = (peerId: string, channelName: string) => LocalChannelPort | undefined;
+/**
+ * The shape both a browser MessagePort and a `node:worker_threads` MessagePort
+ * satisfy, narrowed to what {@link messagePortTransport} uses. Neither global
+ * MessagePort type is in scope in this package, so the adapter is written
+ * against this structural type instead.
+ */
+interface MessagePortLike {
+  postMessage(value: unknown): void;
+  close(): void;
+  on?(event: "message", listener: (value: unknown) => void): unknown;
+  off?(event: "message", listener: (value: unknown) => void): unknown;
+  addEventListener?(type: "message", listener: (event: unknown) => void): void;
+  removeEventListener?(type: "message", listener: (event: unknown) => void): void;
+  start?(): void;
+}
+/**
+ * Wraps a real MessagePort as a {@link LocalChannelPort}.
+ *
+ * A `node:worker_threads` port is an EventEmitter, so the EventEmitter surface
+ * (`on`/`off`) is preferred when present. A browser port is driven through
+ * `addEventListener` and an explicit `start()`, whose event carries the payload
+ * on `.data`; once started it drops what arrives with no listener attached.
+ * Register the result with a `LocalChannelPortRegistry`, which holds one
+ * listener for the port's life and queues frames between channels.
+ */
+export declare function messagePortTransport(port: MessagePortLike): LocalChannelPort;
+//#endregion
+//#region src/sync/channels/local-channel.d.ts
+/**
+ * A symmetric, push-capable synchronization channel between two reactors over a
+ * message port.
+ *
+ * Unlike the gql channels -- one polls and pushes over HTTP, the other never
+ * initiates and is filled by resolvers -- a LocalChannel is peer-to-peer: either
+ * side may push envelopes to the other at any time, with no GraphQL, no HTTP and
+ * no Switchboard. It is the productionized sibling of the test channel: a real
+ * wire protocol over an injected {@link LocalChannelPort}, the peer-manifest
+ * handshake wired into the sync manager, cursor persistence, and ACK-driven
+ * outbox trimming.
+ *
+ * The inbox holds its ack below unapplied purge markers, as the gql channels'
+ * inboxes do.
+ */
+export declare class LocalChannel implements IChannel {
+  readonly inbox: IMailbox;
+  readonly outbox: IMailbox;
+  readonly deadLetter: IMailbox;
+  private readonly logger;
+  private readonly channelId;
+  private readonly remoteName;
+  private readonly cursorStorage;
+  private readonly port;
+  private readonly collectionId;
+  private readonly filter;
+  private isShutdown;
+  private unsubscribeTransport?;
+  private localManifestProvider?;
+  /** Undefined until the first handshake; null for a peer that announces nothing. */
+  private peerManifest;
+  private readonly peerManifestCallbacks;
+  private connectionState;
+  /** Whether any valid frame has arrived since init. */
+  private heardPeer;
+  private failureCount;
+  private lastSuccessUtcMs?;
+  private lastFailureUtcMs?;
+  /** The highest inbox ack already reported to the peer; only an advance re-posts. */
+  private lastPostedAckOrdinal;
+  private pushFailureCount;
+  private pushRetryTimer?;
+  private readonly connectionStateCallbacks;
+  private readonly cursorWriters;
+  constructor(logger: ILogger, channelId: string, remoteName: string, cursorStorage: ISyncCursorStorage, port: LocalChannelPort, collectionId: DriveCollectionId, filter: RemoteFilter);
+  /**
+   * Loads the persisted cursors and initialises both mailboxes BEFORE
+   * subscribing to the transport, so no inbound message is ever processed
+   * against a zeroed mailbox. A frame processed before `inbox.init` runs would
+   * be added below an ack of 0, and the init that followed would overwrite the
+   * ack while leaving that frame pinning the floor -- dragging the live ack
+   * below the durable cursor and re-loading already-applied ops as fresh jobs.
+   *
+   * Loading first relies on the port holding frames until a listener attaches.
+   * A `LocalChannelPortRegistry` port does: it keeps one listener on the
+   * raw port for its whole registration and replays, in order, what arrived
+   * while no channel was attached. A raw browser MessagePort handed straight to
+   * a channel does not once started, so a frame arriving between a shutdown
+   * and the next init on it is lost.
+   */
+  init(): Promise<void>;
+  /** Leaves the port open: whoever registered it closes it. */
+  shutdown(): Promise<void>;
+  getConnectionState(): ConnectionStateSnapshot;
+  onConnectionStateChange(callback: ConnectionStateChangeCallback): () => void;
+  /**
+   * A push transport has nothing to poll, so this asks the peer to re-push
+   * whatever it still holds unacked for this side, from this side's inbox ack.
+   */
+  triggerPull(): void;
+  /** This channel pushes to its peer; it has no holder to hear from. */
+  notePoll(): void;
+  /** No holder, so nothing this channel reports may strand one. */
+  lastHolderPollUtcMs(): number | undefined;
+  setLocalManifest(provider: () => PeerManifest): void;
+  onPeerManifest(callback: PeerManifestListener): () => void;
+  /** Pushes freshly added outbox items that have not since been removed. */
+  private onOutboxAdded;
+  /**
+   * Persists the outbox cursor from the applied ordinal of what was removed,
+   * clamped below the lowest ordinal still in flight. Items for different
+   * documents apply out of order, so the highest applied ordinal can pass one
+   * still unacked; a restart from it would skip that one.
+   */
+  private onOutboxRemoved;
+  /**
+   * Persists the inbox ack and reports it to the peer so it trims its outbox.
+   * The ack is posted only when it strictly advances, so a burst of removals
+   * that does not move the floor does not flood the peer with duplicate acks.
+   */
+  private onInboxRemoved;
+  /** Unconditional, so a peer re-pushing what this side applied can trim. */
+  private postAck;
+  private receive;
+  /**
+   * A HELLO's sinceOrdinal is the peer's inbox ack, so the outbox is trimmed to
+   * it exactly as an ACK would, letting a reconnect resume without re-serving
+   * applied ops. An opening hello then re-pushes the remaining unacked items in
+   * case the peer reconnected and lost them. A reply does not: it answers this
+   * side's own opening, so the peer did not reset, and re-pushing would hand
+   * it every unacked op a second time.
+   */
+  private receiveHello;
+  /**
+   * Ingests a push into the inbox, dropping operations the inbox has already
+   * acked. A reconnecting peer may re-push durable ops before it hears this
+   * side's ack; adding one back as a fresh sync job would transiently drag the
+   * ack floor below the persisted cursor, so a batch entirely at or below the
+   * ack is skipped, and the ack is posted again so the peer can trim them. A
+   * frame {@link isLocalWireMessage} rejects never reaches here; one that still
+   * fails conversion is recorded as a failure.
+   */
+  private receivePush;
+  private receiveResend;
+  private sendHello;
+  /**
+   * Pushes the given outbox items to the peer, marking them in flight.
+   *
+   * A transport throw is classified rather than treated as terminal: only a
+   * structured-clone failure, which recurs identically on every retry, dead-
+   * letters its ops. Any other fault is transient -- the port is momentarily
+   * unusable -- so the ops stay in the outbox and {@link handlePushFailure}
+   * schedules a backoff re-push, keeping behaviour in step with the gql
+   * sibling's recoverable/unrecoverable split.
+   */
+  private pushOutbox;
+  /** Re-pushes every outbox item the peer has not acknowledged. */
+  private rePushUnacked;
+  /**
+   * Routes a push transport failure: a structured-clone (`DataCloneError`)
+   * failure is unrecoverable and dead-letters its ops; any other error is a
+   * transient transport fault, so the ops are left in the outbox to be
+   * re-pushed by the backoff retry and by the next hello/resend recovery.
+   */
+  private handlePushFailure;
+  /** A structured-clone failure cannot self-heal; every other fault can. */
+  private classifyPostError;
+  /** Schedules a single backoff re-push of the unacked outbox. */
+  private schedulePushRetry;
+  /** Clears the backoff state once a push lands or the channel stops. */
+  private clearPushRetry;
+  /** One envelope per SyncOperation, with key/dependsOn for batch ordering. */
+  private envelopesFor;
+  /**
+   * Hears the peer's manifest, deduped like the gql channel: an older or
+   * identical revision is ignored, so a reconnect that re-announces the same
+   * manifest does not re-run the sync manager's hold reconciliation.
+   */
+  private hearPeer;
+  /** Sends a message, returning whether the transport accepted it. */
+  private post;
+  /** Leaves the push retry alone: only a push that lands clears it. */
+  private markSuccess;
+  private recordFailure;
+  private transitionConnectionState;
+  /** The greatest operation ordinal a sync op carries, or 0 when it carries none. */
+  private highestOrdinal;
+  /** The lowest ordinal of an outbox item the peer has not applied. */
+  private unappliedOutboxFloor;
+  /**
+   * Advances a persisted cursor only once the write has landed, and never with
+   * two writes for the same row outstanding. See the gql request channel for
+   * the full argument: concurrent writers for one row are last-writer-wins, and
+   * the storage promises no FIFO, so a burst of removals is coalesced into one
+   * ordered write rather than a race.
+   */
+  private persistCursor;
+  /** One link of a cursor write chain; never rejects, so the chain survives. */
+  private writeCursor;
+}
+//#endregion
+//#region src/sync/channels/local-channel-factory.d.ts
+/** The {@link ChannelConfig.type} a LocalChannel is created from. */
+export declare const LOCAL_CHANNEL_TYPE = "local";
+/**
+ * Factory for {@link LocalChannel} instances.
+ *
+ * The channel's config is `{ type: "local", parameters: { peerId, channelName } }`
+ * -- no url, because there is no server. The factory does not take a port
+ * directly: {@link IChannelFactory.instance} has no seam for a live object, and
+ * a MessagePort is not clone-safe config that could ride in `parameters`.
+ * Instead the factory holds a {@link LocalChannelTransportProvider} and resolves
+ * the port from the (peerId, channelName) the config names. W1.2 supplies a real
+ * brokered MessagePort by registering it with the provider under that key, with
+ * no change to the channel or this factory.
+ */
+export declare class LocalChannelFactory implements IChannelFactory {
+  readonly channelTypes: string[];
+  private readonly logger;
+  private readonly transportProvider;
+  constructor(logger: ILogger, transportProvider: LocalChannelTransportProvider);
+  instance(remoteId: string, remoteName: string, config: ChannelConfig, cursorStorage: ISyncCursorStorage, collectionId: DriveCollectionId, filter: RemoteFilter, _operationIndex: IOperationIndex, _options?: RemoteOptions): IChannel;
+}
+//#endregion
+//#region src/sync/channels/local-channel-registry.d.ts
+type LocalChannelPortRegistryOptions = {
+  logger?: ILogger;
+  /** Frames held for a detached port before its queued pushes are discarded. */
+  maxQueuedFrames?: number;
+};
+/** Brokered local-sync ports by (peerId, channelName); owns closing them. */
+export declare class LocalChannelPortRegistry {
+  private readonly ports;
+  private readonly closedKeys;
+  private closed;
+  private readonly logger;
+  private readonly maxQueuedFrames;
+  constructor(options?: LocalChannelPortRegistryOptions);
+  /** Hand this to the {@link LocalChannelFactory}. */
+  readonly provider: LocalChannelTransportProvider;
+  /** Refuses a live key; a closed key may be registered again (a re-link). */
+  register(peerId: string, channelName: string, port: LocalChannelPort): void;
+  has(peerId: string, channelName: string): boolean;
+  isClosed(peerId: string, channelName: string): boolean;
+  /** Detaches the registry's listener and closes the port. */
+  unregister(peerId: string, channelName: string): void;
+  /** Closes every port and refuses later registrations; the host is going away. */
+  close(): void;
+  private key;
+}
+/** `branch: ""` matches every branch. */
+export declare const DEFAULT_LOCAL_FILTER: RemoteFilter;
+/** Session-scoped: no later boot can rebuild a brokered port. */
+export declare const LOCAL_REMOTE_OPTIONS: RemoteOptions;
+export declare function localChannelConfig(peerId: string, channelName: string): ChannelConfig;
+/** `fromKey` splits on the last dot, so neither part may hold one. */
+export declare function assertCollectionIdParts(driveId: string, branch: string): void;
+/** A dotted drive id parses as a dotted branch, so that is refused here. */
+export declare function collectionIdFromKey(key: string): DriveCollectionId;
+type LocalRemoteSpec = {
+  peerId: string;
+  channelName: string;
+  collectionId: DriveCollectionId;
+  remoteName: string;
+  filter: RemoteFilter;
+};
+type LocalRemoveSpec = {
+  remoteName: string;
+  peerId: string;
+  channelName: string;
+};
+type LocalPeerSyncManager = Pick<ISyncManager, "list" | "add" | "remove" | "resetSettled">;
+/** Registers before `add`, because `add` resolves the port through the factory. */
+export declare function registerLocalPeer(syncManager: LocalPeerSyncManager, registry: LocalChannelPortRegistry, spec: LocalRemoteSpec, port: LocalChannelPort): Promise<Remote>;
+/**
+ * Waits out a running reset, then removes. The port is closed only once the
+ * remote is gone, so a failed remove (a reset that started meanwhile) leaves
+ * the link intact for a retry.
+ */
+export declare function removeLocalPeer(syncManager: LocalPeerSyncManager, registry: LocalChannelPortRegistry, spec: LocalRemoveSpec): Promise<void>;
+//#endregion
+//#region src/sync/channels/local-wire.d.ts
+/**
+ * The messages two {@link LocalChannel}s exchange over a message port.
+ *
+ * The protocol is a stream, not a request/response: either side may send any
+ * message at any time and nothing is correlated by a reply. It is the symmetric
+ * analog of the gql channels' touchChannel/pushSyncEnvelopes/ackOrdinal, carried
+ * as structured-clone-safe plain data so a real MessagePort can clone it -- no
+ * functions, no class instances on the wire.
+ *
+ * Ordinal discipline mirrors the gql channels (see sync/design.md:178-204): an
+ * ordinal a side reports is always how far IT has applied of what the PEER sent,
+ * i.e. an ordinal in the peer's outbox frame. The receiver of such a report
+ * trims its own outbox against it with `trimMailboxFromAckOrdinal`.
+ */
+type LocalWireMessage = LocalHelloMessage | LocalPushMessage | LocalAckMessage | LocalResendMessage;
+/** Identifies which end of the handshake sent a message, for diagnostics. */
+type LocalWireKind = "hello" | "push" | "ack" | "resend";
+/**
+ * Opens (or re-opens) the link. Each side sends one on init. A side that hears
+ * an opening hello answers with one marked `reply`, so a side that resets while
+ * its peer stays up still completes a handshake; a reply is never answered.
+ *
+ * `sinceOrdinal` is the sender's inbox ack: the peer trims its outbox up to it,
+ * exactly as it would on an {@link LocalAckMessage}, so a HELLO after a restart
+ * resumes without re-serving what the sender already applied. `manifest` is the
+ * sender's PeerManifest (null for a peer that announces nothing), which drives
+ * the receiver's version-skew holds.
+ */
+type LocalHelloMessage = {
+  kind: "hello";
+  channelId: string;
+  collectionId: string;
+  filter: RemoteFilter;
+  sinceOrdinal: number;
+  manifest: PeerManifest | null;
+  reply?: boolean;
+};
+/**
+ * Carries sync envelopes to the peer's inbox. `envelopes` is the output of
+ * `serializeEnvelope`, which the receiver feeds back through
+ * `envelopesToSyncOperations`; the pair keeps the payload clone-safe and
+ * preserves key/dependsOn batch ordering across the wire.
+ */
+type LocalPushMessage = {
+  kind: "push";
+  channelId: string;
+  envelopes: unknown[];
+};
+/**
+ * Advances the peer's knowledge of what this side has applied. `ackOrdinal` is
+ * this side's inbox ack (the peer's outbox frame); the peer trims its outbox up
+ * to it. Sent whenever the inbox cursor advances.
+ */
+type LocalAckMessage = {
+  kind: "ack";
+  channelId: string;
+  ackOrdinal: number;
+};
+/**
+ * Asks the peer to re-push whatever it still holds unacked for this side. It is
+ * the push transport's stand-in for a pull: there is nothing to poll, so a
+ * resend request carries this side's inbox ack both to trim the peer's outbox
+ * and to let the peer re-send the remainder.
+ */
+type LocalResendMessage = {
+  kind: "resend";
+  channelId: string;
+  sinceOrdinal: number;
+};
+/**
+ * Whether a received value is a well-formed wire message.
+ *
+ * A push is validated down to what `envelopesToSyncOperations` dereferences:
+ * each envelope's `channelMeta.id` and, per operation, the `operation.action`
+ * and the `context` fields it batches on.
+ */
+export declare function isLocalWireMessage(data: unknown): data is LocalWireMessage;
+//#endregion
 //#region src/sync/channels/interval-poll-timer.d.ts
 type PollTimerConfig = {
   intervalMs: number;
@@ -2713,46 +3205,6 @@ type ReactorHostModuleBaseOptions = Pick<IProcessorHostModuleBase$1, "analyticsS
 /** Builds the reactor-level host module; hosts spread it and add their own fields. */
 export declare function createReactorHostModuleBase(options: ReactorHostModuleBaseOptions): IReactorProcessorHostModuleBase;
 //#endregion
-//#region src/admin/types.d.ts
-type KeyframeValidationIssue = {
-  scope: string;
-  branch: string;
-  revision: number;
-  keyframeHash: string;
-  replayedHash: string;
-};
-type SnapshotValidationIssue = {
-  scope: string;
-  branch: string;
-  snapshotHash: string;
-  replayedHash: string;
-};
-/** Effective operations whose stored order contradicts their timestamps. */
-type StreamOrderIssue = {
-  scope: string;
-  branch: string;
-  previous: Operation;
-  current: Operation;
-  kind: OutOfOrderPair["kind"];
-};
-type ValidationResult = {
-  documentId: string;
-  isConsistent: boolean;
-  keyframeIssues: KeyframeValidationIssue[];
-  snapshotIssues: SnapshotValidationIssue[];
-  streamOrderIssues: StreamOrderIssue[];
-};
-type RebuildResult = {
-  documentId: string;
-  keyframesDeleted: number;
-  scopesInvalidated: number;
-};
-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/admin/document-integrity-service.d.ts
 export declare class DocumentIntegrityService implements IDocumentIntegrityService {
   private readonly keyframeStore;
@@ -2913,6 +3365,456 @@ export declare class ContiguousCursor {
   advance(to: number): void;
 }
 //#endregion
+//#region src/inspector/drive-inspection.d.ts
+/** `IReactor` reads as the host; `IReactorClient` gates on `view.subject`. */
+type InspectorDocumentReader = {
+  find(search: SearchFilter, view?: ViewFilter, paging?: PagingOptions): Promise<PagedResults<PHDocument>>;
+  get(id: string, view?: ViewFilter): Promise<PHDocument>;
+};
+/** Drive listing and integrity, every read made through one reader and view. */
+export declare class DriveInspection {
+  private readonly reader;
+  private readonly registry?;
+  private readonly view;
+  constructor(reader: InspectorDocumentReader, registry?: IDocumentModelRegistry | undefined, view?: ViewFilter);
+  listDrives(cursor?: string, limit?: number): Promise<InspectorDrivePage>;
+  checkDriveIntegrity(driveId: string, branch: string): Promise<InspectorDriveIntegrity>;
+  private presentDocumentIds;
+  private supportedDocumentTypes;
+}
+//#endregion
+//#region src/inspector/reactor-inspector.d.ts
+/** The facts a `ReactorInspector` reports; `workflows` changes after build. */
+type ReactorInspectorFacts = {
+  storage?: ReactorStorageFacts;
+  syncChannels?: readonly string[];
+  access?: InspectorAccess;
+  workflows?: boolean;
+};
+/** A missing component reads as empty; an action on one is refused. */
+type ReactorInspectorComponents = {
+  queue?: IInspectableQueue;
+  processorManager?: IProcessorManager$1;
+  catchUp?: ICatchUp;
+  integrity?: IDocumentIntegrityService;
+  storageHealth?: IInspectorStorageHealthProvider;
+  documentModelRegistry?: IDocumentModelRegistry;
+  drives?: DriveInspection;
+  attachmentStore?: IInspectableAttachmentStore;
+  facts?: ReactorInspectorFacts;
+};
+/** In-process inspector over a reactor module's live components. */
+export declare class ReactorInspector implements IInspector, IInspectorAdmin, IReactorFactsSink {
+  private readonly components;
+  private readonly storageFacts;
+  private readonly syncChannels;
+  private readonly access;
+  private workflows;
+  constructor(components: ReactorInspectorComponents);
+  setWorkflows(composed: boolean): void;
+  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>;
+  validateDocument(documentId: string, branch?: string): Promise<ValidationResult>;
+  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>;
+}
+//#endregion
+//#region src/inspector/from-module.d.ts
+type ReactorInspectorOptions = {
+  /** Absent: a group-commit store's own health, else `tracked: false`. */
+  storageHealth?: IInspectorStorageHealthProvider;
+  attachmentStore?: IInspectableAttachmentStore;
+  /** The tiers the host serves beyond reads; defaults to reads only. */
+  access?: InspectorAccess;
+  /** Set later through `setWorkflows` when the runtime is composed after build. */
+  workflows?: boolean;
+};
+/** The in-process inspector over a built module; drive reads run as the host. */
+export declare function createReactorInspector(module: InProcessReactorModule, options?: ReactorInspectorOptions): ReactorInspector;
+//#endregion
+//#region src/inspector/ops.d.ts
+/** Reads serve every caller a transport admits; admin and sql need access. */
+type InspectorTier = "read" | "admin" | "sql";
+/** Only a read op has a GraphQL root field. */
+type InspectorOpSpec = {
+  readonly rpc: string;
+  readonly tier: "read";
+  readonly gql: string;
+} | {
+  readonly rpc: string;
+  readonly tier: "admin" | "sql";
+};
+/** The `inspector-op` channel, one row per member. */
+export declare const INSPECTOR_OPS: {
+  readonly info: {
+    readonly rpc: "reactor.info";
+    readonly tier: "read";
+    readonly gql: "info";
+  };
+  readonly listDocumentModels: {
+    readonly rpc: "registry.listDocumentModels";
+    readonly tier: "read";
+    readonly gql: "documentModels";
+  };
+  readonly listDrives: {
+    readonly rpc: "drives.list";
+    readonly tier: "read";
+    readonly gql: "drives";
+  };
+  readonly checkDriveIntegrity: {
+    readonly rpc: "drives.checkIntegrity";
+    readonly tier: "read";
+    readonly gql: "driveIntegrity";
+  };
+  readonly getAttachmentInfo: {
+    readonly rpc: "attachments.info";
+    readonly tier: "read";
+    readonly gql: "attachmentInfo";
+  };
+  readonly getQueueState: {
+    readonly rpc: "queue.getState";
+    readonly tier: "read";
+    readonly gql: "queueState";
+  };
+  readonly getProcessors: {
+    readonly rpc: "processors.getAll";
+    readonly tier: "read";
+    readonly gql: "processors";
+  };
+  readonly getCatchUpStatus: {
+    readonly rpc: "catchUp.status";
+    readonly tier: "read";
+    readonly gql: "catchUpStatus";
+  };
+  readonly getStorageHealth: {
+    readonly rpc: "storage.health";
+    readonly tier: "read";
+    readonly gql: "storageHealth";
+  };
+  readonly validateDocument: {
+    readonly rpc: "integrity.validate";
+    readonly tier: "read";
+    readonly gql: "validateDocument";
+  };
+  readonly pauseQueue: {
+    readonly rpc: "queue.pause";
+    readonly tier: "admin";
+  };
+  readonly resumeQueue: {
+    readonly rpc: "queue.resume";
+    readonly tier: "admin";
+  };
+  readonly retryProcessor: {
+    readonly rpc: "processors.retry";
+    readonly tier: "admin";
+  };
+  readonly sweepCatchUp: {
+    readonly rpc: "catchUp.sweepNow";
+    readonly tier: "admin";
+  };
+  readonly rebuildKeyframes: {
+    readonly rpc: "integrity.rebuildKeyframes";
+    readonly tier: "admin";
+  };
+  readonly rebuildSnapshots: {
+    readonly rpc: "integrity.rebuildSnapshots";
+    readonly tier: "admin";
+  };
+  readonly queryDb: {
+    readonly rpc: "db.query";
+    readonly tier: "sql";
+  };
+};
+/** The inspection and repair rows of the `sync-op` channel. */
+export declare const SYNC_INSPECTION_OPS: {
+  readonly inspectRemote: {
+    readonly rpc: "inspect.remote";
+    readonly tier: "read";
+    readonly gql: "remote";
+  };
+  readonly inspectRemotes: {
+    readonly rpc: "inspect.remotes";
+    readonly tier: "read";
+    readonly gql: "remotes";
+  };
+  readonly listDeadLetters: {
+    readonly rpc: "deadLetters.list";
+    readonly tier: "read";
+    readonly gql: "deadLetters";
+  };
+  readonly resetChannel: {
+    readonly rpc: "repair.resetChannel";
+    readonly tier: "admin";
+  };
+  readonly requeueDeadLetter: {
+    readonly rpc: "deadLetters.requeue";
+    readonly tier: "admin";
+  };
+  readonly clearDeadLetter: {
+    readonly rpc: "deadLetters.clear";
+    readonly tier: "admin";
+  };
+};
+type InspectorOpKey = keyof typeof INSPECTOR_OPS;
+type SyncInspectionOpKey = keyof typeof SYNC_INSPECTION_OPS;
+type ReadKeys<T> = { [K in keyof T]: T[K] extends {
+  readonly tier: "read";
+} ? K : never; }[keyof T];
+type InspectorReadOpKey = ReadKeys<typeof INSPECTOR_OPS>;
+type SyncInspectionReadOpKey = ReadKeys<typeof SYNC_INSPECTION_OPS>;
+/** Reads only, unless a host grants more. */
+export declare const READ_ONLY_ACCESS: InspectorAccess;
+export declare function tierAllowed(tier: InspectorTier, access: InspectorAccess): boolean;
+/** The table key whose rpc name is `method`, or undefined. */
+export declare function opKeyOf<K extends string>(table: Readonly<Record<K, InspectorOpSpec>>, method: string): K | undefined;
+/** The read rows' GraphQL root field names, keyed by member. */
+export declare function readOpFields<K extends string>(table: Readonly<Record<K, InspectorOpSpec>>): Partial<Record<K, string>>;
+export declare class UnknownInspectorOpError extends Error {
+  readonly method: string;
+  constructor(method: string);
+}
+export declare class InspectorOpRefusedError extends Error {
+  readonly method: string;
+  readonly tier: InspectorTier;
+  constructor(method: string, tier: InspectorTier);
+}
+export declare class InspectorOpUnavailableError extends Error {
+  readonly method: string;
+  constructor(method: string);
+}
+type OpHandler = (...args: unknown[]) => unknown;
+/** Refuses unknown methods and ungranted tiers before resolving a handler. */
+export declare function dispatchTableOp<K extends string>(table: Readonly<Record<K, InspectorOpSpec>>, resolve: (key: K) => OpHandler | undefined, access: InspectorAccess, method: string, args: readonly unknown[]): Promise<unknown>;
+/** Binds `key` on `target` when it is a method there. */
+export declare function methodOf(target: object | undefined, key: string): OpHandler | undefined;
+//#endregion
+//#region src/inspector/storage-facts.d.ts
+export declare const UNKNOWN_STORAGE_FACTS: ReactorStorageFacts;
+export declare const POSTGRES_STORAGE_FACTS: ReactorStorageFacts;
+export declare const IN_MEMORY_PGLITE_STORAGE_FACTS: ReactorStorageFacts;
+export declare const PGLITE_PATH_STORAGE_FACTS: ReactorStorageFacts;
+export declare const PGLITE_IDB_STORAGE_FACTS: ReactorStorageFacts;
+//#endregion
+//#region src/inspector/wire.d.ts
+type WireChannelConfig = {
+  readonly type?: string;
+  readonly parameters?: Record<string, unknown>;
+};
+/** `RemoteMeta` as JSON delivers it; a vanished remote is identity only. */
+type WireRemoteMeta = {
+  readonly id: string;
+  readonly name?: string;
+  readonly collectionId?: {
+    readonly driveId?: string;
+    readonly branch?: string;
+  };
+  readonly channelConfig?: WireChannelConfig;
+  readonly filter?: RemoteFilter;
+  readonly options?: RemoteOptions;
+  readonly peer?: RemotePeer;
+};
+type WireReactorStorageFacts = {
+  readonly engine: string;
+  readonly persistence: string;
+  readonly durable: boolean;
+  readonly selfHeal: boolean;
+};
+type WireInspectorAccess = {
+  readonly admin: boolean;
+  readonly sql: boolean;
+};
+/** `access` is null for a caller who is not an operator of the host. */
+type WireReactorInfo = {
+  readonly storage: WireReactorStorageFacts;
+  readonly workflows: boolean;
+  readonly syncChannels: readonly string[];
+  readonly access: WireInspectorAccess | null;
+};
+/** A queued job without its actions or operations. */
+type WireQueueJob = {
+  readonly id: string;
+  readonly kind: string;
+  readonly documentId: string;
+  readonly scope: string;
+  readonly branch: string;
+  readonly status: "pending" | "executing";
+  readonly actionCount: number;
+  readonly operationCount: number;
+  readonly retryCount: number;
+};
+type WireQueueState = {
+  readonly isPaused: boolean;
+  readonly totalPending: number;
+  readonly totalExecuting: number;
+  readonly pendingJobs: WireQueueJob[];
+  readonly executingJobs: WireQueueJob[];
+};
+type WireInspectorDocumentModel = {
+  readonly documentType: string;
+  readonly name: string;
+  readonly version: number;
+  readonly supportedVersions: number[];
+};
+type WireInspectorDrive = {
+  readonly driveId: string;
+  readonly name: string;
+  readonly branch: string;
+  readonly collectionId: string;
+  readonly documentType: string;
+  readonly nodeCount: number;
+  readonly fileCount: number;
+  readonly folderCount: number;
+  readonly otherNodeCount: number;
+  readonly unreadableNodeCount: number;
+  readonly icon: string | null;
+};
+type WireInspectorDrivePage = {
+  readonly results: WireInspectorDrive[];
+  readonly nextCursor: string | null;
+};
+type WireInspectorDriveIntegrityRef = {
+  readonly id: string;
+  readonly documentType: string;
+};
+type WireInspectorDriveIntegrity = {
+  readonly driveId: string;
+  readonly checkedNodeCount: number;
+  readonly totalFileNodeCount: number;
+  readonly missingDocuments: WireInspectorDriveIntegrityRef[];
+  readonly unsupportedTypes: WireInspectorDriveIntegrityRef[];
+};
+type WireInspectorAttachmentInfo = {
+  readonly present: boolean;
+  readonly storeKind: string;
+  readonly hasReplicator: boolean;
+  readonly replicatorRunning: boolean;
+  readonly backlogScanned: boolean;
+  readonly refsSeen: number;
+  readonly held: number;
+  readonly bytesHeld: number;
+  readonly queued: number;
+  readonly fetching: number;
+  readonly pendingFetches: number;
+  readonly waiting: number;
+  readonly notFound: number;
+  readonly failed: number;
+  readonly lastError: string | null;
+};
+type WireInspectorProcessor = {
+  readonly processorId: string;
+  readonly factoryId: string;
+  readonly driveId: string;
+  readonly processorIndex: number;
+  readonly lastOrdinal: number;
+  readonly status: string;
+  readonly lastError: string | null;
+  readonly lastErrorTimestampUtcMs: number | null;
+};
+type WireStorageHealth = {
+  readonly tracked: boolean;
+  readonly healthy: boolean;
+  readonly everRecreated: boolean;
+  readonly recreateCount: number;
+};
+/** Issues ride a JSON scalar; each carries the scope it was found in. */
+type WireValidationResult = {
+  readonly documentId: string;
+  readonly isConsistent: boolean;
+  readonly keyframeIssues: Record<string, unknown>[];
+  readonly snapshotIssues: Record<string, unknown>[];
+  readonly streamOrderIssues: Record<string, unknown>[];
+};
+type WireRemoteCursor = {
+  readonly cursorType: "inbox" | "outbox";
+  readonly cursorOrdinal: number;
+  readonly lastSyncedAtUtcMs: number | null;
+  readonly liveAckOrdinal: number;
+  readonly liveLatestOrdinal: number;
+};
+type WireMailboxDepths = {
+  readonly inbox: number;
+  readonly outbox: number;
+  readonly deadLetter: number;
+};
+type WireRemoteConnectionHealth = {
+  readonly snapshot: ConnectionStateSnapshot;
+  readonly neverSucceeded: boolean;
+  readonly stalenessMs: number | null;
+};
+/** One remote's inspection plus its configuration. */
+type WireRemoteSyncInspection = {
+  readonly remoteName: string;
+  readonly remoteId: string;
+  readonly inboxCursor: WireRemoteCursor;
+  readonly outboxCursor: WireRemoteCursor;
+  readonly mailboxDepths: WireMailboxDepths;
+  readonly connection: WireRemoteConnectionHealth;
+  readonly meta: WireRemoteMeta;
+};
+/** A dead letter without its operations. */
+type WireDeadLetter = {
+  readonly id: string;
+  readonly jobId: string;
+  readonly documentId: string;
+  readonly branch: string;
+  readonly scopes: string[];
+  readonly errorType: string;
+  readonly errorMessage: string;
+  readonly operationCount: number;
+};
+type WireDeadLetterPage = {
+  readonly remoteName: string;
+  readonly results: WireDeadLetter[];
+  readonly nextCursor: string | null;
+};
+/** The queue as the inspection surface serves it: no document content. */
+export declare function toWireQueueState(snapshot: QueueStateSnapshot): WireQueueState;
+/** A dead letter as the inspection surface serves it: no document content. */
+export declare function toWireDeadLetter(record: DeadLetterRecord): WireDeadLetter;
+/** Every wire record's fields, by the GraphQL type that serves it. */
+export declare const INSPECTION_WIRE_FIELDS: {
+  readonly ReactorInfo: readonly ["storage", "workflows", "syncChannels", "access"];
+  readonly ReactorStorageFacts: readonly ["engine", "persistence", "durable", "selfHeal"];
+  readonly InspectorAccess: readonly ["admin", "sql"];
+  readonly InspectionDocumentModel: readonly ["documentType", "name", "version", "supportedVersions"];
+  readonly InspectionDrive: readonly ["driveId", "name", "branch", "collectionId", "documentType", "nodeCount", "fileCount", "folderCount", "otherNodeCount", "unreadableNodeCount", "icon"];
+  readonly InspectionDrivePage: readonly ["results", "nextCursor"];
+  readonly InspectionDriveIntegrityRef: readonly ["id", "documentType"];
+  readonly InspectionDriveIntegrity: readonly ["driveId", "checkedNodeCount", "totalFileNodeCount", "missingDocuments", "unsupportedTypes"];
+  readonly InspectionAttachmentInfo: readonly ["present", "storeKind", "hasReplicator", "replicatorRunning", "backlogScanned", "refsSeen", "held", "bytesHeld", "queued", "fetching", "pendingFetches", "waiting", "notFound", "failed", "lastError"];
+  readonly InspectionQueueJob: readonly ["id", "kind", "documentId", "scope", "branch", "status", "actionCount", "operationCount", "retryCount"];
+  readonly InspectionQueueState: readonly ["isPaused", "totalPending", "totalExecuting", "pendingJobs", "executingJobs"];
+  readonly InspectionProcessor: readonly ["processorId", "factoryId", "driveId", "processorIndex", "lastOrdinal", "status", "lastError", "lastErrorTimestampUtcMs"];
+  readonly InspectionStorageHealth: readonly ["tracked", "healthy", "everRecreated", "recreateCount"];
+  readonly InspectionValidation: readonly ["documentId", "isConsistent", "keyframeIssues", "snapshotIssues", "streamOrderIssues"];
+  readonly InspectionCursor: readonly ["cursorType", "cursorOrdinal", "lastSyncedAtUtcMs", "liveAckOrdinal", "liveLatestOrdinal"];
+  readonly InspectionMailboxDepths: readonly ["inbox", "outbox", "deadLetter"];
+  readonly InspectionConnectionHealth: readonly ["snapshot", "neverSucceeded", "stalenessMs"];
+  readonly InspectionRemote: readonly ["remoteName", "remoteId", "inboxCursor", "outboxCursor", "mailboxDepths", "connection", "meta"];
+  readonly InspectionDeadLetter: readonly ["id", "jobId", "documentId", "branch", "scopes", "errorType", "errorMessage", "operationCount"];
+  readonly InspectionDeadLetterPage: readonly ["remoteName", "results", "nextCursor"];
+};
+/** The root fields the inspection subgraph serves: the read rows only. */
+export declare const INSPECTION_ROOT_FIELDS: {
+  readonly ReactorInspection: readonly string[];
+};
+/** Ordinals pass 2^31, so these are `Float` rather than `Int`. */
+export declare const INSPECTION_ORDINAL_FIELDS: {
+  readonly InspectionProcessor: readonly ["lastOrdinal"];
+  readonly InspectionCursor: readonly ["cursorOrdinal", "liveAckOrdinal", "liveLatestOrdinal"];
+};
+//#endregion
 //#region src/storage/kysely/document-purges.d.ts
 /** Class key of every purge lock; the stream locks use the single-key space. */
 export declare const PURGE_NS = 1347571013;
@@ -2925,6 +3827,6 @@ export declare function findPurged(db: Kysely<any>, ids: Iterable<string>): Prom
 /** Every tombstoned id, read in the handle's schema. */
 export declare function listPurged(db: Kysely<any>): Promise<string[]>;
 //#endregion
-export { ALWAYS_READABLE_SCOPES, APPEND_CONDITION_FAILED_PREFIX, type AbortMessage, type ActionCandidate, type ActionEvaluationConfig, type ActionEvaluations, type AdmissionDecision, type AdmissionPath, type AppendCondition, AppendConditionFailedError, type AppendConditionStream, type AtomicTxn, type AttachmentHash, type AttachmentRef, type AuthDecisionModel, BareReadGate, BaseReadModel, type BaseReadModelConfig, type BatchExecutionRequest, type BatchExecutionResult, type BatchLoadRequest, type BatchLoadResult, type BuiltDecisionModel, type BuiltInReadModelKind, type CachedSnapshot, type CatchUpConfig, type CatchUpConsumerStatus, type CatchUpStatus, type CatchUpSweptEvent, type CatchUpThread, type ChannelConfig, ChannelError, ChannelErrorSource, type ChannelHealth, type ChannelMeta, ChannelScheme, type CollectionMember, type ConnectionState, type ConnectionStateChangeCallback, type ConnectionStateChangedEvent, type ConnectionStateSnapshot, type ConsistencyCoordinate, type ConsistencyKey, type ConsistencyToken, ConsistencyTracker, DEFAULT_COMMIT_CHUNK_SIZE, DEFAULT_MAX_PURGE_OPERATIONS, DEFAULT_PURGE_DELETE_BATCH, DEFAULT_READ_MODEL_YIELD_DEADLINE_MS, DRIVE_AUTH_ERROR_MESSAGES, type Database, type DbConfig, type DeadLetterAddedEvent, type DecisionContext, type DecisionModel, type DecisionTarget, type DegradedComponent, type DeliveryLookup, type DeliveryMembership, type DeliveryRow, DocumentAlreadyExistsError, type DocumentChangeEvent, DocumentChangeType, type DocumentDecisionModel, type DocumentDeletedInfo, DocumentExistence, type DocumentGraphEdge, type DocumentIndexerDatabase, DocumentModelRegistry, DocumentModelResolver, type DocumentModelSource, type DocumentModelSpec, type DocumentPurgeRow, DocumentPurgeService, type DocumentRelationship, type DocumentRevisions, type DocumentStreamKey, type DocumentViewDatabase, DriveCollectionId, DriveRequestError, DuplicateManifestError, DuplicateModuleError, DuplicateOperationError, type EnqueuePurgeOptions, type Evaluation, EventBusAggregateError, type ExecuteMessage, type ExecutionJobPlan, type ExecutorStartedEvent, type ExecutorStoppedEvent, type FactorySpec, type FileModelSource, type GqlChannelConfig, type HardenedPGliteDialectOptions, type HeartbeatMessage, type HybridProjectionCoordinatorOptions, type HybridProjectionOptions, type ICatchUp, type ICatchUpConsumer, type IChannel, type IChannelFactory, type IConsistencyTracker, type IDeliveryTracking, type IDocumentGraph, type IDocumentIndexer, type IDocumentIntegrityService, type IDocumentModelLoader, type IDocumentModelRegistry, type IDocumentModelResolver, type IDocumentView, type IDriveClient, type IEventBus, type IJobAwaiter, type IJobExecutor, type IJobExecutorManager, type IJobTracker, type IKeyframeStore, type ILiveReadModelCoordinator, type IMailbox, type IOperationIndex, type IOperationStore, type IPeerAgreement, type IPollTimer, type IProcessor, type IProcessorHostModuleBase, type IProcessorManager, type IProjectionTransport, type IPurgeRefusalRecorder, type IQueue, type IReactor, type IReactorClient, type IReactorProcessorHostModuleBase, type IReactorSubscriptionManager, type IReadGate, type IReadModel, type IReadModelCoordinator, type IRelationalDb, type ISettledWatermark, type IStreamStateReader, type ISubscriptionErrorHandler, type ISyncAdmin, type ISyncCursorStorage, type ISyncHoldStorage, type ISyncManager, type ISyncPurgeRefusalStorage, type ISyncReceivedMarkerStorage, type ISyncRemoteStorage, type ISyncStatusTracker, type IWriteCache, SimpleJobExecutor as InMemoryJobExecutor, type InProcessReactorClientModule, type InProcessReactorModule, type InProcessSyncModule, type InitMessage, type InsertableDocumentSnapshot, InvalidModuleError, type Job, type JobAvailableEvent, JobAwaiter, type JobCompletedEvent, type JobExecutorConfig, JobExecutorEventTypes, type JobExecutorFactory, type JobFailedEvent, type JobInfo, type JobKind, type JobPendingEvent, type JobReadReadyEvent, type JobResult, type JobResultSummary, type JobRunningEvent, type JobStartedEvent, JobStatus, type JobWriteReadyEvent, type JobWriteReadyPayload, type JwtHandler, type KeyframeSnapshot, type KeyframeValidationIssue, KyselyDocumentPurger, KyselyKeyframeStore, KyselyOperationStore, KyselyWriteCache, type LoadJobPlan, type LoadModelMessage, type LocalPeer, type LogMessage, Mailbox, type MetricsMessage, type ModelLoadFailedMessage, type ModelLoadedEvent, type ModelLoadedMessage, type ModelManifestEntry, ModelNotWorkerImportableError, ModelReadGate, ModuleNotFoundError, type ModuleRef, NullDocumentModelResolver, type OperationBatch, type OperationContext, type OperationFilter, type OperationIndexEntry, type OperationTable, type OperationWithContext, OptimisticLockError, type OutOfOrderPair, type PGliteSession, PURGE_DOCUMENT, type PackageModelSource, type PagedResults, type PagingOptions, type ParentMessage, type ParsedDriveUrl, type ParsedPaging, type ParsedSnapshot, type PeerAgreementBasis, type PendingDelivery, PollBehavior, type PollDelegate, type PolledMarkerRefusal, PollingChannelError, type PoolInstrumentation, type PoolStats, type ProbeReading, type ProcessorApp, type ProcessorFactory, type ProcessorFactoryBuilder, type ProcessorFilter, type ProcessorRecord, type ProcessorStatus, type Projection, type ProjectionShardBuilderConfig, type ProjectionShardHooks, type ProjectionShardManagerConfig, type ProjectionWorkerFactory, PropagationMode, type ProtocolSelection, type PurgeDocumentAction, type PurgeDocumentActionInput, type PurgeFence, type PurgeJobOptions, type PurgeLockMode, type PurgeLookup, type PurgeMarkerContext, type PurgeMarkerOperation, type PurgeRefusalRecord, type PurgeRemovedRows, type PurgeStream, QueueEventTypes, RECOVERABLE_GRAPHQL_ERROR_CODES, ReactorClient, type ReactorClientModule, ReactorEventTypes, type ReactorFeatureFlags, type ReactorFeatures, type ReactorHostModuleBaseOptions, type JobFailedEvent$1 as ReactorJobFailedEvent, type ReactorModule, type ReactorReadModels, type ReadGateOptions, type ReadModelBatchCompletedEvent, type ReadModelCoordinatorFactory, type ReadModelCoordinatorFactoryDeps, type ReadModelFactory, type ReadModelFactoryDeps, type ReadModelIndexedEvent, type ReadModelIndexingConfig, type ReadModelIndexingStage, type ReadModelRegistrationStage, type ReadModelStage, type ReadyMessage, type RebuildResult, type ReceivedMarkerRecord, type RegisteredDecisionModel, RelationalDbProcessor, RelationshipChangeType, type Remote, type RemoteCursor, type RemoteFilter, type RemoteMeta, type RemoteOptions, type RemotePeer, type RemoteRecord, type RemoteStatus, type ResultMessage, RetryAccounting, RevisionMismatchError, SIGNATURE_REFUSAL_CODES, type SanitizedArg, type SearchFilter, SeededStateReader, type ShutdownMessage, type ShutdownStatus, type SignatureRefusalCode, type SignatureRefusedEvent, type SignatureScheme, type SignatureTrustPolicy, type SignatureVerificationHandler, type SignatureVerificationMode, type SignerConfig, type SnapshotFunctions, type SnapshotValidationIssue, type Database$1 as StorageDatabase, type StreamOrderIssue, type StreamQuery, type SubjectScopePredicate, type SubmittedActionResult, type SubscriptionErrorContext, type SweepBlockedAt, type SweepResult, type SyncEnvelope, type SyncEnvelopeType, SyncEventTypes, type SyncFailedEvent, type SyncHeldEvent, type SyncHold, type SyncHoldRecord, type SyncModule, SyncOperation, SyncOperationAggregateError, type SyncOperationErrorType, SyncOperationStatus, type SyncPendingEvent, type SyncPurgeRefusedEvent, type SyncReleasedEvent, SyncRepairRefusedError, SyncStatus, type SyncStatusChangeCallback, SyncStatusTracker, type SyncSucceededEvent, type TrackedProcessor, type Unsubscribe, type UnsupportedStoredDocuments, type ValidationResult, type VerificationTarget, type ViewFilter, type WatermarkProbe, type WatermarkStatus, type ErrorInfo as WorkerErrorInfo, type WorkerMessage, type WorkerPoolConfig, type WorkerPoolOptions, type WriteCacheConfig, appliedDelete, createPeerAgreement, createRelationalDb, decideAtHead, defaultCatchUpConfig, defaultReadModelIndexingConfig, documentActions, documentDecisionModel, instrumentPgPool, isDriveAuthError, isPurgeMarker, isRecoverableGraphQLError, loadDocumentModelSpec, makeConsistencyKey, readDecisionModel, selectDecisionModel, supportsLiveReadModelRegistration, unchunkedReadModelIndexingConfig };
+export { ALWAYS_READABLE_SCOPES, APPEND_CONDITION_FAILED_PREFIX, type AbortMessage, type ActionCandidate, type ActionEvaluationConfig, type ActionEvaluations, type AdmissionDecision, type AdmissionPath, type AppendCondition, AppendConditionFailedError, type AppendConditionStream, type AtomicTxn, type AttachmentHash, type AttachmentRef, type AuthDecisionModel, BareReadGate, BaseReadModel, type BaseReadModelConfig, type BatchExecutionRequest, type BatchExecutionResult, type BatchLoadRequest, type BatchLoadResult, type BatchSubmitter, type BuiltDecisionModel, type BuiltInReadModelKind, type CachedSnapshot, type CatchUpConfig, type CatchUpConsumerStatus, type CatchUpStatus, type CatchUpSweptEvent, type CatchUpThread, type ChannelConfig, ChannelError, ChannelErrorSource, type ChannelHealth, type ChannelMeta, ChannelScheme, type CollectionMember, type ConnectionState, type ConnectionStateChangeCallback, type ConnectionStateChangedEvent, type ConnectionStateSnapshot, type ConsistencyCoordinate, type ConsistencyKey, type ConsistencyToken, ConsistencyTracker, type CreateDocumentOptions, DEFAULT_COMMIT_CHUNK_SIZE, DEFAULT_LONG_STATEMENT_TIMEOUT_MS, DEFAULT_MAX_PURGE_OPERATIONS, DEFAULT_PURGE_DELETE_BATCH, DEFAULT_READ_MODEL_YIELD_DEADLINE_MS, DEFAULT_RECOVERY_TIMEOUT_MS, DEFAULT_STATEMENT_TIMEOUT_MS, DRIVE_AUTH_ERROR_MESSAGES, type Database, type DbConfig, type DeadLetterAddedEvent, type DeadLetterPage, type DecisionContext, type DecisionModel, type DecisionTarget, type DegradedComponent, type DeliveryLookup, type DeliveryMembership, type DeliveryRow, DocumentAlreadyExistsError, type DocumentChangeEvent, DocumentChangeType, type DocumentDecisionModel, type DocumentDeletedInfo, DocumentExistence, type DocumentGraphEdge, type DocumentIndexerDatabase, DocumentModelRegistry, DocumentModelResolver, type DocumentModelSource, type DocumentModelSpec, type DocumentPurgeRow, DocumentPurgeService, type DocumentRelationship, type DocumentRevisions, type DocumentStreamKey, type DocumentViewDatabase, type DriveClientDeps, DriveCollectionId, DriveRequestError, DuplicateManifestError, DuplicateModuleError, DuplicateOperationError, type EnqueuePurgeOptions, type Evaluation, EventBusAggregateError, type ExecuteMessage, type ExecutionJobPlan, type ExecutorStartedEvent, type ExecutorStoppedEvent, type FactorySpec, type FileModelSource, type GqlChannelConfig, type GroupCommitPGliteInstance, type GroupCommitPGliteOptions, HardenedPGliteDialect, type HardenedPGliteDialectOptions, type HeartbeatMessage, type HybridProjectionCoordinatorOptions, type HybridProjectionOptions, type ICatchUp, type ICatchUpConsumer, type IChannel, type IChannelFactory, type IConsistencyTracker, type IDeliveryTracking, type IDocumentGraph, type IDocumentIndexer, type IDocumentIntegrityService, type IDocumentModelLoader, type IDocumentModelRegistry, type IDocumentModelResolver, type IDocumentView, type IDriveClient, type IEventBus, type IGroupCommitStorage, type IInspectableAttachmentStore, type IInspectableQueue, type IInspector, type IInspectorAdmin, type IInspectorStorageHealthProvider, type IJobAwaiter, type IJobExecutor, type IJobExecutorManager, type IJobTracker, type IKeyframeStore, type ILiveReadModelCoordinator, type IMailbox, type IOperationIndex, type IOperationStore, type IPeerAgreement, type IPollTimer, type IProcessor, type IProcessorHostModuleBase, type IProcessorManager, type IProjectionTransport, type IPurgeRefusalRecorder, type IQueue, type IReactor, type IReactorClient, type IReactorDbQuery, type IReactorFactsSink, type IReactorProcessorHostModuleBase, type IReactorSubscriptionManager, type IReadGate, type IReadModel, type IReadModelCoordinator, type IRelationalDb, type ISettledWatermark, type IStorageFlusher, type IStorageHealthProvider, type IStreamStateReader, type ISubscriptionErrorHandler, type ISyncAdmin, type ISyncCursorStorage, type ISyncHoldStorage, type ISyncInspector, type ISyncManager, type ISyncPurgeRefusalStorage, type ISyncReceivedMarkerStorage, type ISyncRemoteStorage, type ISyncStatusTracker, type IWriteCache, SimpleJobExecutor as InMemoryJobExecutor, type InProcessReactorClientModule, type InProcessReactorModule, type InProcessSyncModule, type InitMessage, type InsertableDocumentSnapshot, type InspectorAccess, type InspectorAttachmentInfo, type InspectorDocumentModelInfo, type InspectorDocumentReader, type InspectorDriveInfo, type InspectorDriveIntegrity, type InspectorDriveIntegrityRef, type InspectorDrivePage, type InspectorOpKey, type InspectorOpSpec, type InspectorProcessorInfo, type InspectorReadOpKey, type InspectorStorageHealth, type InspectorTier, InvalidDeadLetterCursorError, InvalidModuleError, type Job, type JobAvailableEvent, JobAwaiter, type JobCompletedEvent, type JobExecutorConfig, JobExecutorEventTypes, type JobExecutorFactory, type JobFailedEvent, type JobInfo, type JobKind, type JobPendingEvent, type JobReadReadyEvent, type JobResult, type JobResultSummary, type JobRunningEvent, type JobStartedEvent, JobStatus, type JobWriteReadyEvent, type JobWriteReadyPayload, type JwtHandler, type KeyframeSnapshot, type KeyframeValidationIssue, KyselyDocumentPurger, KyselyKeyframeStore, KyselyOperationStore, KyselyWriteCache, type LoadJobPlan, type LoadModelMessage, type LocalAckMessage, type LocalChannelPort, type LocalChannelPortRegistryOptions, type LocalChannelTransportProvider, type LocalHelloMessage, type LocalPeer, type LocalPeerSyncManager, type LocalPushMessage, type LocalRemoteSpec, type LocalRemoveSpec, type LocalResendMessage, type LocalWireKind, type LocalWireMessage, type LogMessage, Mailbox, type MailboxDepths, type MessagePortLike, type MetricsMessage, type ModelLoadFailedMessage, type ModelLoadedEvent, type ModelLoadedMessage, type ModelManifestEntry, ModelNotWorkerImportableError, ModelReadGate, ModuleNotFoundError, type ModuleRef, NullDocumentModelResolver, type OperationBatch, type OperationContext, type OperationFilter, type OperationIndexEntry, type OperationTable, type OperationWithContext, OptimisticLockError, type OutOfOrderPair, PGliteAbortedTransactionError, PGliteAcquireTimeoutError, PGliteFlushSyncTimeoutError, type PGliteSession, PGliteSessionError, PGliteSessionPoisonedError, PGliteStatementTimeoutError, PURGE_DOCUMENT, type PackageModelSource, type PagedResults, type PagingOptions, type ParentMessage, type ParsedDriveUrl, type ParsedPaging, type ParsedSnapshot, type PeerAgreementBasis, type PendingDelivery, PollBehavior, type PollDelegate, type PolledMarkerRefusal, PollingChannelError, type PoolInstrumentation, type PoolStats, type ProbeReading, type ProcessorApp, type ProcessorFactory, type ProcessorFactoryBuilder, type ProcessorFilter, type ProcessorRecord, type ProcessorStatus, type Projection, type ProjectionShardBuilderConfig, type ProjectionShardHooks, type ProjectionShardManagerConfig, type ProjectionWorkerFactory, PropagationMode, type ProtocolSelection, type PurgeDocumentAction, type PurgeDocumentActionInput, type PurgeFence, type PurgeJobOptions, type PurgeLockMode, type PurgeLookup, type PurgeMarkerContext, type PurgeMarkerOperation, type PurgeRefusalRecord, type PurgeRemovedRows, type PurgeStream, QueueEventTypes, type QueueStateSnapshot, RECOVERABLE_GRAPHQL_ERROR_CODES, ReactorClient, type ReactorClientModule, ReactorEventTypes, type ReactorFeatureFlags, type ReactorFeatures, type ReactorHostModuleBaseOptions, type ReactorInfo, type ReactorInspectorComponents, type ReactorInspectorFacts, type ReactorInspectorOptions, type JobFailedEvent$1 as ReactorJobFailedEvent, type ReactorModule, type ReactorReadModels, type ReactorStorageFacts, type ReadGateOptions, type ReadModelBatchCompletedEvent, type ReadModelCoordinatorFactory, type ReadModelCoordinatorFactoryDeps, type ReadModelFactory, type ReadModelFactoryDeps, type ReadModelIndexedEvent, type ReadModelIndexingConfig, type ReadModelIndexingStage, type ReadModelRegistrationStage, type ReadModelStage, type ReadyMessage, type RebuildResult, type ReceivedMarkerRecord, type RegisteredDecisionModel, RelationalDbProcessor, RelationshipChangeType, type Remote, type RemoteConnectionHealth, type RemoteCursor, type RemoteCursorInfo, type RemoteFilter, type RemoteMeta, type RemoteOptions, type RemotePeer, RemotePersistence, type RemoteRecord, type RemoteStatus, type RemoteSyncInspection, type ResultMessage, RetryAccounting, RevisionMismatchError, SIGNATURE_REFUSAL_CODES, type SanitizedArg, type SearchFilter, SeededStateReader, type ShutdownMessage, type ShutdownStatus, type SignatureRefusalCode, type SignatureRefusedEvent, type SignatureScheme, type SignatureTrustPolicy, type SignatureVerificationHandler, type SignatureVerificationMode, type SignerConfig, type SnapshotFunctions, type SnapshotValidationIssue, type Database$1 as StorageDatabase, type StorageHealth, type StoragePersistence, type StreamOrderIssue, type StreamQuery, type SubjectScopePredicate, type SubmittedActionResult, type SubscriptionErrorContext, type SweepBlockedAt, type SweepResult, type SyncEnvelope, type SyncEnvelopeType, SyncEventTypes, type SyncFailedEvent, type SyncHeldEvent, type SyncHold, type SyncHoldRecord, type SyncInspectionOpKey, type SyncInspectionReadOpKey, type SyncModule, SyncOperation, SyncOperationAggregateError, type SyncOperationErrorType, SyncOperationStatus, type SyncPendingEvent, type SyncPurgeRefusedEvent, type SyncReleasedEvent, SyncRepairRefusedError, SyncStatus, type SyncStatusChangeCallback, SyncStatusTracker, type SyncSucceededEvent, type TrackedProcessor, type Unsubscribe, type UnsupportedStoredDocuments, type UpgradeDocumentDeps, type UpgradeDocumentOptions, type ValidationResult, type VerificationTarget, type ViewFilter, type WatermarkProbe, type WatermarkStatus, type WireChannelConfig, type WireDeadLetter, type WireDeadLetterPage, type WireInspectorAccess, type WireInspectorAttachmentInfo, type WireInspectorDocumentModel, type WireInspectorDrive, type WireInspectorDriveIntegrity, type WireInspectorDriveIntegrityRef, type WireInspectorDrivePage, type WireInspectorProcessor, type WireMailboxDepths, type WireQueueJob, type WireQueueState, type WireReactorInfo, type WireReactorStorageFacts, type WireRemoteConnectionHealth, type WireRemoteCursor, type WireRemoteMeta, type WireRemoteSyncInspection, type WireStorageHealth, type WireValidationResult, type ErrorInfo as WorkerErrorInfo, type WorkerMessage, type WorkerPoolConfig, type WorkerPoolOptions, type WriteCacheConfig, appliedDelete, createPeerAgreement, createRelationalDb, decideAtHead, defaultCatchUpConfig, defaultReadModelIndexingConfig, deriveConnectionHealth, documentActions, documentDecisionModel, firstOutOfOrderPair, instrumentPgPool, isDriveAuthError, isLongRunningStatement, isPurgeMarker, isRecoverableGraphQLError, loadDocumentModelSpec, makeConsistencyKey, queryThroughDialect, readDecisionModel, selectDecisionModel, supportsLiveReadModelRegistration, unchunkedReadModelIndexingConfig };
 export {};
 //# sourceMappingURL=index.d.ts.map