@powerhousedao/reactor 6.2.3-dev.2 → 6.2.3-dev.4

package/dist/index.js

@@ -4229,9 +4229,35 @@ const DRIVE_AUTH_ERROR_MESSAGES = {
 	forbidden: "Forbidden: insufficient permissions",
 	authenticationRequired: "Forbidden: authentication required"
 };
+/**
+* A non-GraphQL HTTP failure against a drive endpoint.
+*
+* Drive discovery (`GET <base>/d/:drive`) is REST, not GraphQL, so its
+* failures cannot be a `GraphQLRequestError` without the name lying about
+* what was called. It carries the status for the same reason that one does:
+* `isDriveAuthError` is what decides whether a failure prompts a login, and a
+* bare `Error` tells it nothing.
+*/
+var DriveRequestError = class extends Error {
+	statusCode;
+	constructor(message, statusCode) {
+		super(message);
+		this.name = "DriveRequestError";
+		this.statusCode = statusCode;
+	}
+};
 /** True when the remote rejected the caller as unauthenticated/unauthorized:
-* an HTTP 401/403, or a Forbidden/Unauthorized GraphQL error. */
+* an HTTP 401/403, or a Forbidden/Unauthorized GraphQL error.
+*
+* 403 and 401 only — NOT 404. The drive info endpoint answers a drive the
+* caller may not read with the same 404 it gives a drive that does not exist,
+* so that an unauthorized caller cannot enumerate drives by probing slugs.
+* That is deliberate, and it costs exactly this: a protected drive is
+* indistinguishable from a typo, and prompting for a login on every 404 would
+* fire on every mistyped URL. See the `WWW-Authenticate` note on the endpoint
+* for the signal that would let a client tell the two apart. */
 function isDriveAuthError(error) {
+	if (error instanceof DriveRequestError) return error.statusCode === 401 || error.statusCode === 403;
 	if (!(error instanceof GraphQLRequestError)) return false;
 	if (error.category === "http") return error.statusCode === 401 || error.statusCode === 403;
 	if (error.category === "graphql") return Object.values(DRIVE_AUTH_ERROR_MESSAGES).some((m) => error.message.includes(m));
@@ -5028,6 +5054,10 @@ var GqlRequestChannel = class {
 		if (this.isShutdown) return;
 		this.pollTimer.triggerNow();
 	}
+	/** This channel polls a remote itself; it has no holder to hear from. */
+	notePoll() {}
+	/** No holder, so nothing this channel reports may strand one. */
+	lastHolderPollUtcMs() {}
 	/**
 	* Initializes the channel by registering it on the remote server and starting polling.
 	*/
@@ -5611,6 +5641,7 @@ var GqlResponseChannel = class {
 	lastPersistedOutboxOrdinal = 0;
 	evictedOutboxFloor = Number.POSITIVE_INFINITY;
 	appliedOutboxOrdinal = 0;
+	lastPollUtcMs = Date.now();
 	connectionState = "connecting";
 	connectionStateCallbacks = /* @__PURE__ */ new Set();
 	constructor(logger, channelId, remoteName, cursorStorage) {
@@ -5653,7 +5684,7 @@ var GqlResponseChannel = class {
 		return {
 			state: this.connectionState,
 			failureCount: 0,
-			lastSuccessUtcMs: 0,
+			lastSuccessUtcMs: this.lastPollUtcMs,
 			lastFailureUtcMs: 0,
 			pushBlocked: false,
 			pushFailureCount: 0,
@@ -5669,6 +5700,13 @@ var GqlResponseChannel = class {
 	}
 	/** Response channels are push-driven; resolvers populate mailboxes directly. */
 	triggerPull() {}
+	notePoll() {
+		this.lastPollUtcMs = Date.now();
+	}
+	/** This channel is served: its holder's polls are the liveness it reports. */
+	lastHolderPollUtcMs() {
+		return this.lastPollUtcMs;
+	}
 	async init() {
 		const cursors = await this.cursorStorage.list(this.remoteName);
 		const inboxOrdinal = cursors.find((c) => c.cursorType === "inbox")?.cursorOrdinal ?? 0;
@@ -6348,9 +6386,19 @@ var OutboxMode = /* @__PURE__ */ function(OutboxMode) {
 const defaultSyncManagerConfig = {
 	maxDeadLettersPerRemote: 100,
 	maxInboxBatchSize: 32,
-	maxHeldOperationsPerRemote: 1e4
+	maxHeldOperationsPerRemote: 1e4,
+	staleRemotePollWindowMs: 5 * 6e4
 };
 const PLAN_KEY_TO_JOB_UUID_CAP = 1e4;
+/**
+* Whether a channel failure says the caller could not authenticate or could not
+* reach the remote, rather than that the remote itself is misconfigured. The
+* remote record stays on disk for these so a retry after sign-in can re-add it.
+*/
+function isCredentialOrNetworkError(error) {
+	if (isDriveAuthError(error)) return true;
+	return error instanceof GraphQLRequestError && error.category === "network";
+}
 /** Where a sync operation's run of ordinals begins. */
 function firstOrdinalOf(syncOp) {
 	return syncOp.operations.length > 0 ? syncOp.operations[0].context.ordinal : 0;
@@ -6379,6 +6427,11 @@ var SyncManager = class {
 	backfillAbortControllers = /* @__PURE__ */ new Map();
 	planKeyToJobUuid = /* @__PURE__ */ new Map();
 	evictedOutboxFloors = /* @__PURE__ */ new Map();
+	prunePending = /* @__PURE__ */ new Set();
+	pruneChain = Promise.resolve();
+	derivingOutboxes = 0;
+	pruneDrainDeferred = false;
+	removing = /* @__PURE__ */ new Set();
 	lastEnqueuedJobIdByKey = /* @__PURE__ */ new Map();
 	inboxChunkChain = Promise.resolve();
 	constructor(logger, remoteStorage, cursorStorage, deadLetterStorage, channelFactory, operationIndex, reactor, eventBus, driveContainerTypes, config = {}) {
@@ -6430,7 +6483,7 @@ var SyncManager = class {
 				await channel.init();
 			} catch (error) {
 				this.logger.error("Error initializing channel for remote (@name, @error)", record.name, error instanceof Error ? error.message : String(error));
-				this.remotes.delete(record.name);
+				await this.dropRemoteAfterFailedInit(remote, false);
 				continue;
 			}
 			const outboxAckOrdinal = remote.channel.outbox.ackOrdinal;
@@ -6442,6 +6495,7 @@ var SyncManager = class {
 					this.logger.error("Backfill failed for remote @RemoteName: @Error", remote.meta.name, error instanceof Error ? error : new Error(String(error)));
 				}).finally(() => {
 					this.backfillAbortControllers.delete(record.name);
+					this.drainPrunes();
 				});
 			}
 		}
@@ -6455,6 +6509,8 @@ var SyncManager = class {
 		this.backfillAbortControllers.clear();
 		this.planKeyToJobUuid.clear();
 		this.lastEnqueuedJobIdByKey.clear();
+		this.prunePending.clear();
+		this.pruneDrainDeferred = false;
 		this.batchAggregator.clear();
 		if (this.eventUnsubscribe) {
 			this.eventUnsubscribe();
@@ -6548,8 +6604,7 @@ var SyncManager = class {
 		try {
 			await channel.init();
 		} catch (error) {
-			this.remotes.delete(name);
-			await this.remoteStorage.remove(name);
+			await this.dropRemoteAfterFailedInit(remote, !isCredentialOrNetworkError(error));
 			throw error;
 		}
 		const backfillController = new AbortController();
@@ -6559,6 +6614,7 @@ var SyncManager = class {
 			this.logger.error("Backfill failed for remote @RemoteName: @Error", remote.meta.name, error instanceof Error ? error : new Error(String(error)));
 		}).finally(() => {
 			this.backfillAbortControllers.delete(name);
+			this.drainPrunes();
 		});
 		return remote;
 	}
@@ -6570,21 +6626,62 @@ var SyncManager = class {
 	async remove(name) {
 		const remote = this.remotes.get(name);
 		if (!remote) throw new Error(`Remote with name '${name}' does not exist`);
+		this.removing.add(name);
+		try {
+			await this.teardownRemoteResources(remote);
+			await this.remoteStorage.remove(name);
+			await this.cursorStorage.remove(name);
+		} finally {
+			this.remotes.delete(name);
+			this.removing.delete(name);
+		}
+	}
+	/**
+	* Drops a remote whose channel.init() rejected, optionally removing its
+	* stored record. Ordered like remove(): the registry slot is released last,
+	* so a concurrent add of the same name cannot slip in and have its record
+	* deleted by the removal below. A failure to tear down must not replace the
+	* init error the caller has to classify.
+	*/
+	async dropRemoteAfterFailedInit(remote, removeStorageRecord) {
+		const name = remote.meta.name;
+		this.removing.add(name);
+		try {
+			await this.teardownRemoteResources(remote);
+			if (removeStorageRecord) await this.remoteStorage.remove(name);
+		} catch (error) {
+			this.logger.error("Error tearing down remote after failed init (@name, @error)", name, error instanceof Error ? error.message : String(error));
+		} finally {
+			this.remotes.delete(name);
+			this.removing.delete(name);
+		}
+	}
+	/**
+	* Releases everything wiring a remote up holds: the in-flight backfill, the
+	* channel, the status tracker entry and the connection-state subscription.
+	* The registry slot is deliberately NOT released here -- the caller holds it
+	* until any storage removal has finished, so a concurrent add of the same
+	* name is refused for the whole teardown.
+	*/
+	async teardownRemoteResources(remote) {
+		const name = remote.meta.name;
 		const backfillController = this.backfillAbortControllers.get(name);
 		if (backfillController) {
 			backfillController.abort();
 			this.backfillAbortControllers.delete(name);
 		}
-		await remote.channel.shutdown();
-		await this.remoteStorage.remove(name);
-		await this.cursorStorage.remove(name);
-		this.syncStatusTracker.untrackRemote(name);
-		const unsub = this.connectionStateUnsubscribes.get(name);
-		if (unsub) {
-			unsub();
-			this.connectionStateUnsubscribes.delete(name);
+		try {
+			await remote.channel.shutdown();
+		} finally {
+			this.syncStatusTracker.untrackRemote(name);
+			const unsub = this.connectionStateUnsubscribes.get(name);
+			if (unsub) {
+				unsub();
+				this.connectionStateUnsubscribes.delete(name);
+			}
+			this.evictedOutboxFloors.delete(name);
+			this.prunePending.delete(name);
 		}
-		this.remotes.delete(name);
 	}
 	list() {
 		return Array.from(this.remotes.values());
@@ -6679,7 +6776,7 @@ var SyncManager = class {
 		this.logger.debug("Loaded @count persisted dead letters for remote @name", records.length, remote.meta.name);
 	}
 	getRemotesForCollection(collectionId) {
-		return Array.from(this.remotes.values()).filter((remote) => remote.meta.collectionId.key === collectionId);
+		return Array.from(this.remotes.values()).filter((remote) => remote.meta.collectionId.key === collectionId && !this.removing.has(remote.meta.name));
 	}
 	async processCompleteBatch(batch) {
 		if (this.isShutdown) return;
@@ -6690,7 +6787,11 @@ var SyncManager = class {
 			for (const remote of remotes) if (!affectedRemotes.includes(remote)) affectedRemotes.push(remote);
 		}
 		for (const remote of affectedRemotes) trimMailboxFromBatch(remote.channel.inbox, batch);
-		for (const remote of affectedRemotes) await this.updateOutbox(remote, remote.channel.outbox.latestOrdinal, OutboxMode.BatchTriggered);
+		for (const remote of affectedRemotes) {
+			if (!this.remotes.has(remote.meta.name) || this.removing.has(remote.meta.name)) continue;
+			await this.updateOutbox(remote, remote.channel.outbox.latestOrdinal, OutboxMode.BatchTriggered);
+		}
+		await this.drainPrunes();
 	}
 	handleInboxAdded(remote, syncOps) {
 		if (this.isShutdown) return;
@@ -6891,15 +6992,95 @@ var SyncManager = class {
 		const floor = firstOrdinalOf(evicted[0]);
 		const known = this.evictedOutboxFloors.get(remote.meta.name);
 		this.evictedOutboxFloors.set(remote.meta.name, known === void 0 ? floor : Math.min(known, floor));
-		this.logger.warn("Outbox for @RemoteName is past its bound of @Cap operations; evicting @Count entries from ordinal @Floor, to be derived again once it drains", remote.meta.name, cap, evicted.length, floor);
+		const staleMs = this.stalePollAgeMs(remote);
+		if (staleMs !== void 0) {
+			let held = kept;
+			for (const syncOp of evicted) held += syncOp.operations.length;
+			if (!this.prunePending.has(remote.meta.name)) {
+				this.prunePending.add(remote.meta.name);
+				this.logger.warn("Outbox for @RemoteName (@Collection) is past its bound of @Cap operations holding @Held, and it has not been polled for @StaleMs ms; marking the channel for removal once this derivation ends", remote.meta.name, remote.meta.collectionId.key, cap, held, staleMs);
+			}
+		} else this.logger.warn("Outbox for @RemoteName is past its bound of @Cap operations; evicting @Count entries from ordinal @Floor, to be derived again once it drains", remote.meta.name, cap, evicted.length, floor);
 		remote.channel.outbox.remove(...evicted);
 	}
+	/**
+	* How long a served remote's holder has been silent, if past the window.
+	*
+	* The channel is asked, rather than its config inspected: SyncManager serves
+	* and subscribes with the same interface, both kinds report lastSuccessUtcMs,
+	* and the caller-supplied channelConfig.type is a free-form string the
+	* factories do not read -- so neither could tell a dead served channel from a
+	* client whose switchboard is merely unreachable. Only a channel that claims
+	* a holder by reporting when it last heard from one can be removed for that
+	* holder's silence; a channel that reports nothing (or 0) is never pruned.
+	*/
+	stalePollAgeMs(remote) {
+		const last = remote.channel.lastHolderPollUtcMs();
+		if (last === void 0 || last <= 0) return;
+		const age = Date.now() - last;
+		return age >= this.config.staleRemotePollWindowMs ? age : void 0;
+	}
+	/**
+	* Removes the remotes marked stale during eviction.
+	*
+	* Removing a remote that a derivation is still iterating would pull its
+	* mailboxes out from under it, so a drain that arrives during one is deferred
+	* rather than run; the last derivation to finish re-arms it.
+	*/
+	drainPrunes() {
+		if (this.derivingOutboxes > 0) {
+			this.pruneDrainDeferred = true;
+			return Promise.resolve();
+		}
+		const next = this.pruneChain.then(async () => {
+			if (this.isShutdown) return;
+			for (const name of [...this.prunePending]) {
+				if (this.derivingOutboxes > 0) {
+					this.pruneDrainDeferred = true;
+					return;
+				}
+				this.prunePending.delete(name);
+				const remote = this.remotes.get(name);
+				if (!remote) continue;
+				if (this.stalePollAgeMs(remote) === void 0) {
+					this.logger.info("Stale removal of @name revoked: its holder polled while the outbox was being derived", name);
+					continue;
+				}
+				try {
+					await this.remove(name);
+				} catch (error) {
+					this.logger.error("Failed to remove stale remote (@name, @error)", name, error instanceof Error ? error.message : String(error));
+				}
+			}
+		});
+		this.pruneChain = next.catch(() => {});
+		return next;
+	}
 	outboxOperationCount(remote) {
 		let count = 0;
 		for (const syncOp of remote.channel.outbox.items) count += syncOp.operations.length;
 		return count;
 	}
+	/**
+	* Derives this remote's outbox, holding off prunes for the duration.
+	*
+	* A backfill elsewhere can finish at any await in here and drain the prunes
+	* it marked; the count is what keeps that drain from removing the remote this
+	* call is still adding to.
+	*/
 	async updateOutbox(remote, ackOrdinal, mode = OutboxMode.Backfill, signal) {
+		this.derivingOutboxes++;
+		try {
+			await this.deriveOutbox(remote, ackOrdinal, mode, signal);
+		} finally {
+			this.derivingOutboxes--;
+			if (this.derivingOutboxes === 0 && this.pruneDrainDeferred) {
+				this.pruneDrainDeferred = false;
+				this.drainPrunes();
+			}
+		}
+	}
+	async deriveOutbox(remote, ackOrdinal, mode, signal) {
 		const composedSignal = signal ? AbortSignal.any([signal, this.abortController.signal]) : this.abortController.signal;
 		const startOrdinal = this.refillOrdinal(remote, ackOrdinal);
 		let maxOrdinal = startOrdinal;
@@ -7001,6 +7182,10 @@ var SyncBuilder = class {
 		this.config.maxHeldOperationsPerRemote = limit;
 		return this;
 	}
+	withStaleRemotePollWindowMs(windowMs) {
+		this.config.staleRemotePollWindowMs = windowMs;
+		return this;
+	}
 	build(reactor, logger, operationIndex, eventBus, db, driveContainerTypes) {
 		return this.buildModule(reactor, logger, operationIndex, eventBus, db, driveContainerTypes).syncManager;
 	}
@@ -7903,19 +8088,27 @@ var ReactorBuilder = class {
 		} else executorManager = new SimpleJobExecutorManager(() => new SimpleJobExecutor(this.logger, documentModelRegistry, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, collectionMembershipCache, this.driveContainerTypes, this.executorConfig, this.signatureVerifier, executionScope), eventBus, queue, jobTracker, this.logger, resolver, this.executorConfig.jobTimeoutMs, this.executorConfig.deferredJobTtlMs);
 		await executorManager.start(executorStartCount);
 		const callerReadModels = Array.from(new Set([...this.readModels]));
+		const degradedComponents = [];
+		const startDegraded = (component, error) => {
+			degradedComponents.push({
+				component,
+				error: error instanceof Error ? error : new Error(String(error))
+			});
+			this.logger?.error("Reactor component started degraded: @component", component, error);
+		};
 		const documentViewConsistencyTracker = new ConsistencyTracker();
 		const documentView = new KyselyDocumentView(database, operationStore, operationIndex, writeCache, documentViewConsistencyTracker, featureFlags.documentDecisions);
 		try {
 			await documentView.init();
 		} catch (error) {
-			console.error("Error initializing document view", error);
+			startDegraded("document view", error);
 		}
 		const documentIndexerConsistencyTracker = new ConsistencyTracker();
 		const documentIndexer = new KyselyDocumentIndexer(database, operationIndex, writeCache, documentIndexerConsistencyTracker);
 		try {
 			await documentIndexer.init();
 		} catch (error) {
-			console.error("Error initializing document indexer", error);
+			startDegraded("document indexer", error);
 		}
 		const subscriptionManager = new ReactorSubscriptionManager(new DefaultSubscriptionErrorHandler());
 		const subscriptionNotificationReadModel = new SubscriptionNotificationReadModel(subscriptionManager, documentView);
@@ -7924,9 +8117,9 @@ var ReactorBuilder = class {
 		try {
 			await processorManager.init();
 		} catch (error) {
-			console.error("Error initializing processor manager", error);
+			startDegraded("processor manager", error);
 		}
-		for (const factory of this.readModelFactories) {
+		for (const [index, factory] of this.readModelFactories.entries()) try {
 			const readModel = await factory({
 				documentModelRegistry,
 				operationIndex,
@@ -7934,6 +8127,8 @@ var ReactorBuilder = class {
 				processorManagerConsistencyTracker
 			});
 			callerReadModels.push(readModel);
+		} catch (error) {
+			startDegraded(`read model ${index}${factory.name ? ` (${factory.name})` : ""}`, error);
 		}
 		const readModelInstances = [
 			...callerReadModels,
@@ -7993,8 +8188,10 @@ var ReactorBuilder = class {
 			syncModule,
 			reactor,
 			groupReevaluationTrigger,
-			pools: this.instrumentedPools
+			pools: this.instrumentedPools,
+			degradedComponents
 		};
+		if (degradedComponents.length > 0) this.logger.warn("Reactor started with @count degraded component(s): @components", degradedComponents.length, degradedComponents.map(({ component }) => component).join(", "));
 		if (this.signalHandlersEnabled) this.attachSignalHandlers(module);
 		return module;
 	}
@@ -8792,6 +8989,6 @@ var DocumentIntegrityService = class {
 	}
 };
 //#endregion
-export { ALWAYS_READABLE_SCOPES, APPEND_CONDITION_FAILED_PREFIX, AppendConditionFailedError, AuthEnforcementDisabledError, BareReadGate, BaseReadModel, ChannelError, ChannelErrorSource, ChannelScheme, ConsistencyTracker, DEFAULT_DRIVE_CONTAINER_TYPES, DOCUMENT_INDEXER_READ_MODEL, DOCUMENT_VIEW_READ_MODEL, DRIVE_AUTH_ERROR_MESSAGES, DefaultSubscriptionErrorHandler, DocumentAlreadyExistsError, DocumentChangeType, DocumentExistence, DocumentIntegrityService, DocumentModelRegistry, DocumentModelResolver, DriveClient, DriveCollectionId, DuplicateManifestError, DuplicateModuleError, DuplicateOperationError, EventBus, EventBusAggregateError, GqlRequestChannel, GqlRequestChannelFactory, GqlResponseChannel, GqlResponseChannelFactory, HybridProjectionCoordinator, SimpleJobExecutor as InMemoryJobExecutor, SimpleJobExecutor, InMemoryJobTracker, InMemoryQueue, IntervalPollTimer, InvalidModuleError, JobAwaiter, JobExecutorEventTypes, JobStatus, KyselyDocumentIndexer, KyselyDocumentView, KyselyKeyframeStore, KyselyOperationStore, KyselySyncCursorStorage, KyselySyncRemoteStorage, KyselyWriteCache, Mailbox, ModelReadGate, ModuleNotFoundError, NullDocumentModelResolver, OptimisticLockError, PollBehavior, PollingChannelError, ProcessorManager, PropagationMode, QueueEventTypes, REACTOR_SCHEMA, RECOVERABLE_GRAPHQL_ERROR_CODES, Reactor, ReactorBuilder, ReactorClient, ReactorClientBuilder, ReactorEventTypes, ReactorSubscriptionManager, ReadModelCoordinator, RelationalDbProcessor, RelationshipChangeType, RetryAccounting, RevisionMismatchError, SeededStateReader, SimpleJobExecutorManager, SyncBuilder, SyncEventTypes, SyncOperation, SyncOperationAggregateError, SyncOperationStatus, SyncScopeGate, SyncStatus, SyncStatusTracker, addRelationshipAction, authDecisionModel, batchOperationsByDocument, buildDecisionModel, classifyJobFailure, consolidateSyncOperations, createDocumentAction, createForwardingLogger, createHybridProjectionCoordinatorFactory, createMutableShutdownStatus, createReactorHostModuleBase, createRelationalDb, decideAtHead, deleteDocumentAction, documentActions, documentDecisionModel, driveIdFromUrl, envelopesToSyncOperations, errorToInfo, firstOutOfOrderPair, getMigrationStatus, instrumentPgPool, isDriveAuthError, isRecoverableGraphQLError, makeConsistencyKey, parseDriveUrl, parsePagingOptions, quarantinesDocument, readDecisionModel, removeRelationshipAction, runMigrations, sanitizeArg, selectDecisionModel, supportsLiveReadModelRegistration, syncOperationErrorType, trimMailboxFromAckOrdinal, updateRelationshipAction, upgradeDocumentAction, workerEntryPath };
+export { ALWAYS_READABLE_SCOPES, APPEND_CONDITION_FAILED_PREFIX, AppendConditionFailedError, AuthEnforcementDisabledError, BareReadGate, BaseReadModel, ChannelError, ChannelErrorSource, ChannelScheme, ConsistencyTracker, DEFAULT_DRIVE_CONTAINER_TYPES, DOCUMENT_INDEXER_READ_MODEL, DOCUMENT_VIEW_READ_MODEL, DRIVE_AUTH_ERROR_MESSAGES, DefaultSubscriptionErrorHandler, DocumentAlreadyExistsError, DocumentChangeType, DocumentExistence, DocumentIntegrityService, DocumentModelRegistry, DocumentModelResolver, DriveClient, DriveCollectionId, DriveRequestError, DuplicateManifestError, DuplicateModuleError, DuplicateOperationError, EventBus, EventBusAggregateError, GqlRequestChannel, GqlRequestChannelFactory, GqlResponseChannel, GqlResponseChannelFactory, HybridProjectionCoordinator, SimpleJobExecutor as InMemoryJobExecutor, SimpleJobExecutor, InMemoryJobTracker, InMemoryQueue, IntervalPollTimer, InvalidModuleError, JobAwaiter, JobExecutorEventTypes, JobStatus, KyselyDocumentIndexer, KyselyDocumentView, KyselyKeyframeStore, KyselyOperationStore, KyselySyncCursorStorage, KyselySyncRemoteStorage, KyselyWriteCache, Mailbox, ModelReadGate, ModuleNotFoundError, NullDocumentModelResolver, OptimisticLockError, PollBehavior, PollingChannelError, ProcessorManager, PropagationMode, QueueEventTypes, REACTOR_SCHEMA, RECOVERABLE_GRAPHQL_ERROR_CODES, Reactor, ReactorBuilder, ReactorClient, ReactorClientBuilder, ReactorEventTypes, ReactorSubscriptionManager, ReadModelCoordinator, RelationalDbProcessor, RelationshipChangeType, RetryAccounting, RevisionMismatchError, SeededStateReader, SimpleJobExecutorManager, SyncBuilder, SyncEventTypes, SyncOperation, SyncOperationAggregateError, SyncOperationStatus, SyncScopeGate, SyncStatus, SyncStatusTracker, addRelationshipAction, authDecisionModel, batchOperationsByDocument, buildDecisionModel, classifyJobFailure, consolidateSyncOperations, createDocumentAction, createForwardingLogger, createHybridProjectionCoordinatorFactory, createMutableShutdownStatus, createReactorHostModuleBase, createRelationalDb, decideAtHead, deleteDocumentAction, documentActions, documentDecisionModel, driveIdFromUrl, envelopesToSyncOperations, errorToInfo, firstOutOfOrderPair, getMigrationStatus, instrumentPgPool, isDriveAuthError, isRecoverableGraphQLError, makeConsistencyKey, parseDriveUrl, parsePagingOptions, quarantinesDocument, readDecisionModel, removeRelationshipAction, runMigrations, sanitizeArg, selectDecisionModel, supportsLiveReadModelRegistration, syncOperationErrorType, trimMailboxFromAckOrdinal, updateRelationshipAction, upgradeDocumentAction, workerEntryPath };
 
 //# sourceMappingURL=index.js.map