@powerhousedao/reactor 6.2.2 → 6.2.3-dev.1

package/dist/index.js

@@ -7611,6 +7611,20 @@ var Reactor = class {
 function sameDatabaseTarget(a, b) {
 	return a.host === b.host && a.port === b.port && a.database === b.database;
 }
+/**
+* Requires each built-in kind exactly once across both lists. A kind in
+* neither list is indexed by nobody (host copies never index under a
+* worker), so its reads go stale and its consistency-token waits never
+* resolve; a kind in both is indexed twice per operation.
+*/
+function validateBuiltInKindCoverage(preReadyKinds, postReadyKinds) {
+	const named = [...preReadyKinds, ...postReadyKinds];
+	const missing = BUILT_IN_READ_MODEL_KINDS.filter((kind) => !named.includes(kind));
+	const duplicated = BUILT_IN_READ_MODEL_KINDS.filter((kind) => named.filter((entry) => entry === kind).length > 1);
+	if (missing.length === 0 && duplicated.length === 0) return;
+	const problems = [missing.length > 0 ? `never named: ${missing.join(", ")} (would be indexed by no shard, leaving those reads permanently stale and their consistency-token waits unresolvable)` : void 0, duplicated.length > 0 ? `named more than once: ${duplicated.join(", ")} (would be indexed twice per operation)` : void 0].filter((problem) => problem !== void 0);
+	throw new Error(`withProjectionShards requires preReadyKinds and postReadyKinds to name each built-in read model (${BUILT_IN_READ_MODEL_KINDS.join(", ")}) exactly once between them; ${problems.join("; ")}`);
+}
 var ReactorBuilder = class {
 	logger;
 	documentModelSources = [];
@@ -7628,6 +7642,7 @@ var ReactorBuilder = class {
 	syncBuilder;
 	eventBus;
 	readModelCoordinator;
+	readModelCoordinatorFactory;
 	signatureVerifier;
 	kyselyInstance;
 	signalHandlersEnabled = false;
@@ -7639,6 +7654,7 @@ var ReactorBuilder = class {
 	driveContainerTypes = DEFAULT_DRIVE_CONTAINER_TYPES;
 	workerPool;
 	resolvedModelManifest;
+	moduleOnlyModelKeys = [];
 	projectionShardConfig;
 	projectionWorkerFactory;
 	instrumentedPools = [];
@@ -7687,6 +7703,15 @@ var ReactorBuilder = class {
 		this.readModelCoordinator = readModelCoordinator;
 		return this;
 	}
+	/**
+	* Register a factory that builds the coordinator once the subscription
+	* read model, processor manager and host read models exist. Use this, not
+	* `withReadModelCoordinator`, for coordinators that compose those internals.
+	*/
+	withReadModelCoordinatorFactory(factory) {
+		this.readModelCoordinatorFactory = factory;
+		return this;
+	}
 	withExecutor(executor) {
 		this.executorManager = executor;
 		return this;
@@ -7816,23 +7841,18 @@ var ReactorBuilder = class {
 	async buildModule() {
 		if (!this.logger) this.logger = new ConsoleLogger(["reactor"]);
 		const featureFlags = resolveFeatureFlags(this.executorConfig.featureFlags);
+		if (this.readModelCoordinator !== void 0 && this.readModelCoordinatorFactory !== void 0) throw new Error("withReadModelCoordinator and withReadModelCoordinatorFactory are mutually exclusive; register one coordinator source");
+		if (this.projectionShardConfig !== void 0 && this.readModelCoordinatorFactory !== void 0) throw new Error("withProjectionShards and withReadModelCoordinatorFactory are mutually exclusive; the factory owns the projection worker through its createProjectionShardManager dependency");
 		if (this.projectionShardConfig !== void 0 && this.readModelFactories.length > 0) throw new Error("withProjectionShards does not support read models registered through withReadModelFactory; projection workers cannot receive host-only factory dependencies");
 		if (this.projectionShardConfig !== void 0 && this.readModels.length > 0) throw new Error("withProjectionShards does not support read models registered through withReadModel; projection workers build their own read models from the shard config and would silently omit these");
-		if (this.projectionShardConfig !== void 0) {
-			const named = [...this.projectionShardConfig.preReadyKinds, ...this.projectionShardConfig.postReadyKinds];
-			const missing = BUILT_IN_READ_MODEL_KINDS.filter((kind) => !named.includes(kind));
-			const duplicated = BUILT_IN_READ_MODEL_KINDS.filter((kind) => named.filter((entry) => entry === kind).length > 1);
-			if (missing.length > 0 || duplicated.length > 0) {
-				const problems = [missing.length > 0 ? `never named: ${missing.join(", ")} (would be indexed by no shard, leaving those reads permanently stale and their consistency-token waits unresolvable)` : void 0, duplicated.length > 0 ? `named more than once: ${duplicated.join(", ")} (would be indexed twice per operation)` : void 0].filter((problem) => problem !== void 0);
-				throw new Error(`withProjectionShards requires preReadyKinds and postReadyKinds to name each built-in read model (${BUILT_IN_READ_MODEL_KINDS.join(", ")}) exactly once between them; ${problems.join("; ")}`);
-			}
-		}
+		if (this.projectionShardConfig !== void 0) validateBuiltInKindCoverage(this.projectionShardConfig.preReadyKinds, this.projectionShardConfig.postReadyKinds);
 		const resolvedSources = await resolveModelSources(this.documentModelSources);
 		if (this.workerPool) {
 			if (resolvedSources.manifest.length === 0) throw new Error("withWorkerPool requires at least one worker-importable document-model source ({ filePath } or { packageName }).");
 			if (resolvedSources.moduleOnlyKeys.length > 0) throw new Error(`withWorkerPool requires worker-importable sources, but these models were registered only as live modules: ${resolvedSources.moduleOnlyKeys.join(", ")}. Provide a { filePath } or { packageName } source for each.`);
 		}
 		this.resolvedModelManifest = resolvedSources.manifest.length > 0 ? resolvedSources.manifest : void 0;
+		this.moduleOnlyModelKeys = resolvedSources.moduleOnlyKeys;
 		const documentModelRegistry = new DocumentModelRegistry();
 		if (this.upgradeManifests.length > 0) {
 			const results = documentModelRegistry.registerUpgradeManifests(...this.upgradeManifests);
@@ -7882,7 +7902,7 @@ var ReactorBuilder = class {
 			if (resolver instanceof DocumentModelResolver) resolver.setBroadcastHook((entry) => poolManager.loadModel(entry));
 		} 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 readModelInstances = Array.from(new Set([...this.readModels]));
+		const callerReadModels = Array.from(new Set([...this.readModels]));
 		const documentViewConsistencyTracker = new ConsistencyTracker();
 		const documentView = new KyselyDocumentView(database, operationStore, operationIndex, writeCache, documentViewConsistencyTracker, featureFlags.documentDecisions);
 		try {
@@ -7890,7 +7910,6 @@ var ReactorBuilder = class {
 		} catch (error) {
 			console.error("Error initializing document view", error);
 		}
-		readModelInstances.push(documentView);
 		const documentIndexerConsistencyTracker = new ConsistencyTracker();
 		const documentIndexer = new KyselyDocumentIndexer(database, operationIndex, writeCache, documentIndexerConsistencyTracker);
 		try {
@@ -7898,7 +7917,6 @@ var ReactorBuilder = class {
 		} catch (error) {
 			console.error("Error initializing document indexer", error);
 		}
-		readModelInstances.push(documentIndexer);
 		const subscriptionManager = new ReactorSubscriptionManager(new DefaultSubscriptionErrorHandler());
 		const subscriptionNotificationReadModel = new SubscriptionNotificationReadModel(subscriptionManager, documentView);
 		const processorManagerConsistencyTracker = new ConsistencyTracker();
@@ -7915,12 +7933,28 @@ var ReactorBuilder = class {
 				writeCache,
 				processorManagerConsistencyTracker
 			});
-			readModelInstances.push(readModel);
+			callerReadModels.push(readModel);
 		}
-		const readModelCoordinator = this.readModelCoordinator ? this.readModelCoordinator : this.projectionShardConfig ? await this.createProjectionShardManager(this.projectionShardConfig, eventBus, {
+		const readModelInstances = [
+			...callerReadModels,
+			documentView,
+			documentIndexer
+		];
+		const hostTrackers = {
 			"document-view": documentViewConsistencyTracker,
 			"document-indexer": documentIndexerConsistencyTracker
-		}) : new ReadModelCoordinator(eventBus, readModelInstances, [subscriptionNotificationReadModel, processorManager]);
+		};
+		const readModelCoordinator = this.readModelCoordinator ? this.readModelCoordinator : this.readModelCoordinatorFactory ? await this.readModelCoordinatorFactory({
+			eventBus,
+			logger: this.logger,
+			readModels: callerReadModels,
+			subscriptionNotificationReadModel,
+			processorManager,
+			documentView,
+			documentIndexer,
+			createProjectionShardManager: (config) => this.createProjectionShardManager(config, eventBus, hostTrackers, false),
+			registerShutdownHook: (hook) => this.shutdownHooks.push(hook)
+		}) : this.projectionShardConfig ? await this.createProjectionShardManager(this.projectionShardConfig, eventBus, hostTrackers, true) : new ReadModelCoordinator(eventBus, readModelInstances, [subscriptionNotificationReadModel, processorManager]);
 		const reactor = new Reactor(this.logger, documentModelRegistry, queue, jobTracker, readModelCoordinator, this.features, documentView, documentIndexer, operationStore, eventBus, executorManager);
 		let syncModule = void 0;
 		if (this.channelScheme) {
@@ -7989,15 +8023,28 @@ var ReactorBuilder = class {
 	*   models never index an operation, so the manager advances these from the
 	*   shards' relayed indexing reports; without them every read carrying a
 	*   consistency token waits forever.
+	* @param registerShutdownHook Whether the builder owns `manager.shutdown()`
+	*   at signal time. False for the coordinator-factory path, whose factory
+	*   registers its own hook so host chains drain before the worker stops.
 	*/
-	async createProjectionShardManager(config, eventBus, consistencyTrackers) {
-		const baseDb = this.resolveReactorDbConfig();
-		if (!baseDb) throw new Error("withProjectionShards requires a db (or an executor worker pool configured with one); projection workers need connection info to open their own pools.");
+	async createProjectionShardManager(config, eventBus, consistencyTrackers, registerShutdownHook) {
+		const parentDb = this.resolveReactorDbConfig();
+		const baseDb = config.db ?? parentDb;
+		const caller = this.projectionShardConfig !== void 0 ? "withProjectionShards" : "withReadModelCoordinatorFactory";
+		if (!baseDb) throw new Error(`${caller} requires a db (or an executor worker pool configured with one); projection workers need connection info to open their own pools.`);
+		const workerDb = this.workerPool?.db;
+		if (config.db && workerDb && !sameDatabaseTarget(workerDb, config.db)) throw new Error("withWorkerPool({ db }) and the projection worker db must address the same Postgres database (same host, port, and database); the parent writes operations there and the projection shards read them.");
+		if (config.db && this.kyselyInstance === void 0) {
+			if (!parentDb) throw new Error(`The projection worker db passed to ${caller} must also be the parent reactor's database, but nothing configures the parent: it would fall back to the default embedded database while the worker projects into Postgres. Pass the same { db } to withWorkerPool, or give the parent its connection with withKysely.`);
+			if (!sameDatabaseTarget(config.db, parentDb)) throw new Error(`The projection worker db passed to ${caller} and the parent reactor database must address the same Postgres database (same host, port, and database); the parent writes operations there and the projection shards read them.`);
+		}
+		validateBuiltInKindCoverage(config.preReadyKinds, config.postReadyKinds);
+		if (this.moduleOnlyModelKeys.length > 0) throw new Error(`projection workers require worker-importable sources, but these models were registered only as live modules: ${this.moduleOnlyModelKeys.join(", ")}. Provide a { filePath } or { packageName } source for each.`);
 		const models = this.resolvedModelManifest ?? [];
 		const db = {
 			...baseDb,
 			poolSize: config.poolSize ?? baseDb.poolSize,
-			applicationName: "reactor-projection-shard"
+			applicationName: config.db?.applicationName ?? "reactor-projection-shard"
 		};
 		const factory = this.projectionWorkerFactory ?? await this.createDefaultProjectionWorkerFactory();
 		const poolInstrumentations = [];
@@ -8006,7 +8053,7 @@ var ReactorBuilder = class {
 			poolInstrumentations.push(forwarder);
 			this.instrumentedPools.push(forwarder);
 		}
-		const { ProjectionShardManager } = await import("./projection-shard-manager-D6KYcEZi.js");
+		const { ProjectionShardManager } = await import("./projection-shard-manager-CPQc5XHL.js");
 		const manager = new ProjectionShardManager({
 			shardCount: config.shardCount,
 			db,
@@ -8021,10 +8068,21 @@ var ReactorBuilder = class {
 			drainTimeoutMs: config.drainTimeoutMs,
 			chainDepthReportIntervalMs: config.chainDepthReportIntervalMs,
 			poolInstrumentations,
-			consistencyTrackers
+			consistencyTrackers,
+			onReadReady: config.onReadReady,
+			onShardFatal: config.onShardFatal
 		});
-		await manager.startup();
-		this.shutdownHooks.push(() => manager.shutdown());
+		try {
+			await manager.startup();
+		} catch (error) {
+			try {
+				await manager.shutdown();
+			} catch (shutdownError) {
+				this.logger.warn("projection shard manager shutdown after a failed startup also failed: @error", shutdownError);
+			}
+			throw error;
+		}
+		if (registerShutdownHook) this.shutdownHooks.push(() => manager.shutdown());
 		return manager;
 	}
 	async createDefaultProjectionWorkerFactory() {
@@ -8143,6 +8201,168 @@ var ReactorBuilder = class {
 	}
 };
 //#endregion
+//#region src/projection/hybrid-projection-coordinator.ts
+/** Host-side stages on a per-queueKey chain driven by the worker's read-ready. */
+var HybridProjectionCoordinator = class {
+	/** One array, mutated in place: reactor-api captures it by reference once. */
+	readModels;
+	eventBus;
+	logger;
+	manager;
+	preReady;
+	postReady;
+	chains = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.eventBus = options.eventBus;
+		this.logger = options.logger;
+		this.manager = options.manager;
+		this.preReady = options.preReady;
+		this.postReady = options.postReady;
+		this.readModels = [
+			...options.preReady,
+			...options.postReady,
+			...options.lookupOnly
+		];
+	}
+	start() {
+		this.manager.start();
+	}
+	stop() {
+		this.manager.stop();
+	}
+	/** Wired as `onReadReady`; host trackers are already advanced (port FIFO). */
+	acceptReadReady(event) {
+		if (event.operations.length === 0) {
+			this.manager.emitReadReady(event).catch((err) => this.logger.error("JOB_READ_READY emit failed for job @jobId: @Error", { jobId: event.jobId }, err));
+			return;
+		}
+		const enqueuedAt = performance.now();
+		const key = this.queueKeyFor(event);
+		const current = (this.chains.get(key) ?? Promise.resolve()).then(() => this.runHostChain(event, enqueuedAt));
+		this.chains.set(key, current);
+		current.finally(() => {
+			if (this.chains.get(key) === current) this.chains.delete(key);
+		});
+	}
+	addReadModel(readModel, stage) {
+		if (this.readModels.some(({ name }) => name === readModel.name)) throw new Error(`Read model "${readModel.name}" is already registered`);
+		if (stage === "pre_ready") this.preReady.push(readModel);
+		else this.postReady.push(readModel);
+		this.readModels.push(readModel);
+	}
+	getChainDepth() {
+		return this.manager.getChainDepth() + this.chains.size;
+	}
+	/** Worker chains flush first, so every relayed read-ready is in `chains`. */
+	async drain() {
+		await this.manager.drain();
+		while (this.chains.size > 0) {
+			const pending = Array.from(this.chains.values());
+			await Promise.allSettled(pending);
+		}
+	}
+	/** Builder shutdown hook; reaches `manager.shutdown()` even when drain fails. */
+	async shutdown() {
+		try {
+			await this.drain();
+		} catch (error) {
+			this.logger.warn("hybrid coordinator drain failed during shutdown: @Error", error);
+		}
+		await this.manager.shutdown();
+	}
+	async runHostChain(event, enqueuedAt) {
+		const chainWaitDurationMs = performance.now() - enqueuedAt;
+		const preReadyStart = performance.now();
+		try {
+			await Promise.all(this.preReady.map((readModel) => this.indexWithTiming(readModel, "pre_ready", event)));
+		} catch (error) {
+			this.logger.error("Host pre-ready read model indexing failed for job @jobId: @Error", { jobId: event.jobId }, error);
+		}
+		const preReadyDurationMs = performance.now() - preReadyStart;
+		const emitStart = performance.now();
+		try {
+			await this.manager.emitReadReady(event);
+		} catch (error) {
+			this.logger.error("JOB_READ_READY emit failed for job @jobId: @Error", { jobId: event.jobId }, error);
+		}
+		const emitDurationMs = performance.now() - emitStart;
+		const postReadyStart = performance.now();
+		try {
+			await Promise.all(this.postReady.map((readModel) => this.indexWithTiming(readModel, "post_ready", event)));
+		} catch (error) {
+			this.logger.error("Host post-ready read model indexing failed for job @jobId: @Error", { jobId: event.jobId }, error);
+		}
+		const postReadyDurationMs = performance.now() - postReadyStart;
+		this.emitBatchCompleted({
+			jobId: event.jobId,
+			batchSize: event.operations.length,
+			chainWaitDurationMs,
+			preReadyDurationMs,
+			emitDurationMs,
+			postReadyDurationMs
+		});
+	}
+	async indexWithTiming(readModel, stage, event) {
+		const start = performance.now();
+		let success = false;
+		try {
+			await readModel.indexOperations(event.operations);
+			success = true;
+		} finally {
+			this.emitReadModelIndexed({
+				jobId: event.jobId,
+				readModelName: readModel.name,
+				stage,
+				durationMs: performance.now() - start,
+				operationCount: event.operations.length,
+				success
+			});
+		}
+	}
+	emitBatchCompleted(payload) {
+		this.eventBus.emit(ReactorEventTypes.READMODEL_BATCH_COMPLETED, payload).catch((err) => this.logger.error("READMODEL_BATCH_COMPLETED emit failed for job @jobId: @Error", { jobId: payload.jobId }, err));
+	}
+	emitReadModelIndexed(payload) {
+		this.eventBus.emit(ReactorEventTypes.READMODEL_INDEXED, payload).catch((err) => this.logger.error("READMODEL_INDEXED emit failed for job @jobId: @Error", { jobId: payload.jobId }, err));
+	}
+	queueKeyFor(event) {
+		const ctx = event.operations[0].context;
+		return `${ctx.documentId}:${ctx.scope}:${ctx.branch}`;
+	}
+};
+//#endregion
+//#region src/projection/create-hybrid-projection-coordinator.ts
+/** Built-ins in one projection worker; all other read models stay on the host. */
+function createHybridProjectionCoordinatorFactory(options = {}) {
+	return async (deps) => {
+		const ref = { current: void 0 };
+		const manager = await deps.createProjectionShardManager({
+			shardCount: options.shardCount ?? 1,
+			preReadyKinds: ["document-view", "document-indexer"],
+			postReadyKinds: [],
+			db: options.db,
+			poolSize: options.poolSize,
+			initTimeoutMs: options.initTimeoutMs,
+			shutdownGraceMs: options.shutdownGraceMs,
+			drainTimeoutMs: options.drainTimeoutMs,
+			chainDepthReportIntervalMs: options.chainDepthReportIntervalMs,
+			onReadReady: (event) => ref.current.acceptReadReady(event),
+			onShardFatal: options.onFatal
+		});
+		const coordinator = new HybridProjectionCoordinator({
+			eventBus: deps.eventBus,
+			logger: deps.logger,
+			manager,
+			preReady: deps.readModels,
+			postReady: [deps.subscriptionNotificationReadModel, deps.processorManager],
+			lookupOnly: [deps.documentView, deps.documentIndexer]
+		});
+		ref.current = coordinator;
+		deps.registerShutdownHook(() => coordinator.shutdown());
+		return coordinator;
+	};
+}
+//#endregion
 //#region src/signer/passthrough-signer.ts
 /**
 * A no-op signer that returns empty values for all methods.
@@ -8572,6 +8792,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, 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, 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, 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