@powerhousedao/reactor 6.2.3-dev.22 → 6.2.3-dev.24

package/dist/index.js

@@ -1,10 +1,10 @@
-import { $ as parsePagingOptions, A as targetDocumentId, B as DuplicateOperationError, C as InvalidModuleError, D as createEmptyConsistencyToken, E as createConsistencyToken, F as buildDecisionModel, G as AuthorizationDeniedError, H as RevisionMismatchError, I as APPEND_CONDITION_FAILED_PREFIX, J as ExcessiveReshuffleError, K as DocumentDeletedError, L as AppendConditionFailedError, M as selectDecisionModel, N as documentDecisionModel, O as submittedActionIds, P as authDecisionModel, Q as matchesScope, R as DocumentAlreadyExistsError, S as DuplicateModuleError, T as GATED_DOCUMENT_ACTIONS, U as AuthEnforcementDisabledError, V as OptimisticLockError, W as AuthTimestampNotMonotonicError, X as RelationshipNotFoundError, Y as InvalidOperationTimestampError, Z as UpgradePreconditionFailedError, _ as DocumentMetaCache, a as createForwardingPoolInstrumentation, b as JobExecutorEventTypes, c as KyselyKeyframeStore, d as DriveCollectionId, et as throwIfAborted, f as KyselyExecutionScope, g as KyselyOperationIndex, h as KyselyWriteCache, i as runMigrations, j as decideAtHead, k as summarizeSubmittedActions, l as DocumentModelRegistry, m as EventBus, n as REACTOR_SCHEMA, o as instrumentPgPool, p as resolveFeatureFlags, q as DocumentNotFoundError, r as getMigrationStatus, s as KyselyOperationStore, t as DEFAULT_DRIVE_CONTAINER_TYPES, u as SimpleJobExecutor, v as CollectionMembershipCache, w as ModuleNotFoundError, x as DuplicateManifestError, y as DEFAULT_DEFERRED_JOB_TTL_MS, z as DocumentExistence } from "./drive-container-types-CS5IxDiA.js";
-import { n as ReactorEventTypes, t as EventBusAggregateError } from "./types-DMKLa0Ok.js";
+import { $ as RelationshipNotFoundError, A as submittedActionIds, B as DocumentAlreadyExistsError, C as DuplicateManifestError, D as GATED_DOCUMENT_ACTIONS, E as ModuleNotFoundError, F as documentDecisionModel, G as AuthEnforcementDisabledError, H as DuplicateOperationError, I as authDecisionModel, J as DocumentDeletedError, K as AuthTimestampNotMonotonicError, L as buildDecisionModel, M as targetDocumentId, N as decideAtHead, O as createConsistencyToken, P as selectDecisionModel, Q as InvalidSignatureError, R as APPEND_CONDITION_FAILED_PREFIX, S as JobExecutorEventTypes, T as InvalidModuleError, U as OptimisticLockError, V as DocumentExistence, W as RevisionMismatchError, X as ExcessiveReshuffleError, Y as DocumentNotFoundError, Z as InvalidOperationTimestampError, _ as KyselyWriteCache, a as createForwardingPoolInstrumentation, b as CollectionMembershipCache, c as KyselyKeyframeStore, d as verifyActionSignature, et as UpgradePreconditionFailedError, f as PassthroughSigner, g as EventBus, h as resolveFeatureFlags, i as runMigrations, j as summarizeSubmittedActions, k as createEmptyConsistencyToken, l as DocumentModelRegistry, m as KyselyExecutionScope, n as REACTOR_SCHEMA, nt as parsePagingOptions, o as instrumentPgPool, p as DriveCollectionId, q as AuthorizationDeniedError, r as getMigrationStatus, rt as throwIfAborted, s as KyselyOperationStore, t as DEFAULT_DRIVE_CONTAINER_TYPES, tt as matchesScope, u as SimpleJobExecutor, v as KyselyOperationIndex, w as DuplicateModuleError, x as DEFAULT_DEFERRED_JOB_TTL_MS, y as DocumentMetaCache, z as AppendConditionFailedError } from "./drive-container-types-Be5-EY9W.js";
+import { n as ReactorEventTypes, t as EventBusAggregateError } from "./types-DxDCmtId.js";
 import { i as WorkerInitFailedError, r as WorkerExitedError, t as WorkerAbortTimeoutError } from "./errors-D3S6Eysd.js";
-import { a as KyselyDocumentView, c as ReadModelCoordinator, d as DEFAULT_READ_MODEL_YIELD_DEADLINE_MS, f as defaultReadModelIndexingConfig, i as DeletedDocumentRead, l as BaseReadModel, n as ConsistencyTracker, o as DOCUMENT_INDEXER_READ_MODEL, p as unchunkedReadModelIndexingConfig, r as makeConsistencyKey, s as DOCUMENT_VIEW_READ_MODEL, t as KyselyDocumentIndexer, u as DEFAULT_COMMIT_CHUNK_SIZE } from "./document-indexer-C1oY6CaR.js";
+import { a as KyselyDocumentView, c as ReadModelCoordinator, d as DEFAULT_READ_MODEL_YIELD_DEADLINE_MS, f as defaultReadModelIndexingConfig, i as DeletedDocumentRead, l as BaseReadModel, n as ConsistencyTracker, o as DOCUMENT_INDEXER_READ_MODEL, p as unchunkedReadModelIndexingConfig, r as makeConsistencyKey, s as DOCUMENT_VIEW_READ_MODEL, t as KyselyDocumentIndexer, u as DEFAULT_COMMIT_CHUNK_SIZE } from "./document-indexer-Dn9RB0sg.js";
 import { n as errorToInfo, r as sanitizeArg, t as createForwardingLogger } from "./forwarding-logger-BBkMSxuJ.js";
-import { t as workerEntryPath } from "./worker-g03lNM42.js";
-import { DowngradeNotSupportedError, MAX_AUTH_GRANTS, UnsupportedDocumentModelVersionError, actions, actions as documentActions, createPresignedHeader, decide, deserializeSignature, garbageCollect, generateId, groupDocumentType, groupMembershipActionTypes, hashDocumentStateForScope, normalizeDocumentModelVersion, sortOperations, toTransportAction } from "@powerhousedao/shared/document-model";
+import { t as workerEntryPath } from "./worker-BDVzCtuf.js";
+import { DEFAULT_SIGNATURE_POLICY, DowngradeNotSupportedError, MAX_AUTH_GRANTS, UnsupportedDocumentModelVersionError, actionSignerIdentity, actionSigningTarget, actions, actions as documentActions, createCopyHeader, decide, deserializeSignature, garbageCollect, generateId, groupDocumentType, groupMembershipActionTypes, hashDocumentStateForScope, normalizeDocumentModelVersion, requestedSignaturePolicy, sortOperations, toTransportAction, withSignaturePolicy } from "@powerhousedao/shared/document-model";
 import { addFile, addFolder, copyNode, deleteNode, driveCreateDocument, generateNodesCopy, getDescendants, handleTargetNameCollisions, isFileNode, isFolderNode, moveNode, updateNode } from "@powerhousedao/shared/document-drive";
 import { v4 } from "uuid";
 import { ConsoleLogger, childLogger } from "document-model";
@@ -237,37 +237,31 @@ function getSharedActionScope(actions) {
 	return baseScope;
 }
 /**
-* Signs an action with the provided signer.
-* If the action already has valid signatures, it is returned unchanged.
+* Signs an action for `target`, the log it is written to. An action already
+* signed under a key is returned unchanged; one whose signer or last tuple has
+* no key is unsigned, and is signed like any other.
 */
-const signAction = async (action, signer, signal) => {
-	const existingSignatures = action.context?.signer?.signatures;
-	if (existingSignatures && existingSignatures.length > 0) return action;
-	const signature = await signer.signAction(action, signal);
+const signAction = async (action, signer, target, signal) => {
+	const existing = action.context?.signer;
+	if (existing?.app?.key && existing.signatures.at(-1)?.[1]) return action;
+	const signature = await signer.signAction(action, target, signal);
 	return {
 		...action,
 		context: {
 			...action.context,
 			signer: {
-				user: {
-					address: signer.user?.address || "",
-					networkId: signer.user?.networkId || "",
-					chainId: signer.user?.chainId || 0
-				},
-				app: {
-					name: signer.app?.name || "",
-					key: signer.app?.key || ""
-				},
+				...actionSignerIdentity(signer),
 				signatures: [signature]
 			}
 		}
 	};
 };
 /**
-* Signs multiple actions with the provided signer
+* Signs the actions of a job on `job.documentId`, each for the log it is
+* written to: a relationship action lands in its source document.
 */
-const signActions = async (actions, signer, signal) => {
-	return Promise.all(actions.map((action) => signAction(action, signer, signal)));
+const signActions = async (actions, signer, job, signal) => {
+	return Promise.all(actions.map((action) => signAction(action, signer, actionSigningTarget(action, job.documentId, job.branch), signal)));
 };
 function buildSingleJobMeta(jobId, callerMeta) {
 	return {
@@ -329,11 +323,11 @@ var DriveClient = class {
 	}
 	async create(input, signal) {
 		this.logger.verbose("drives.create(@input)", input);
-		const driveDoc = driveCreateDocument({ global: {
+		const driveDoc = withSignaturePolicy(driveCreateDocument({ global: {
 			name: input.global.name || "",
 			icon: input.global.icon ?? null,
 			nodes: []
-		} });
+		} }), requestedSignaturePolicy(input, await this.client.getCreateSignaturePolicy()), { protocolVersions: input.protocolVersions });
 		if (input.preferredEditor) driveDoc.header.meta = {
 			...driveDoc.header.meta,
 			preferredEditor: input.preferredEditor
@@ -369,13 +363,19 @@ var DriveClient = class {
 				initialState: document.state
 			}),
 			addRelationshipAction(driveIdentifier, documentId, "child")
-		], this.signer, signal);
+		], this.signer, {
+			documentId,
+			branch: "main"
+		}, signal);
 		const driveActions = await signActions([addFile({
 			id: documentId,
 			name: document.header.name || documentId,
 			documentType: document.header.documentType,
 			parentFolder
-		})], this.signer, signal);
+		})], this.signer, {
+			documentId: driveIdentifier,
+			branch: "main"
+		}, signal);
 		await this.runJobs([{
 			key: "document",
 			documentId,
@@ -465,18 +465,20 @@ var DriveClient = class {
 			});
 			resolvedNamesByTargetId.set(entry.targetId, resolved);
 		}
+		const policy = await this.client.getCreateSignaturePolicy();
 		for (const entry of copyPlan) {
 			const node = drive.state.global.nodes.find((n) => n.id === entry.srcId);
 			if (!node || !isFileNode(node)) continue;
 			const srcDoc = await this.client.get(entry.srcId, void 0, signal);
 			const duplicated = {
 				...srcDoc,
-				header: createPresignedHeader(entry.targetId, srcDoc.header.documentType),
+				header: createCopyHeader(srcDoc.header, entry.targetId, policy),
 				initialState: srcDoc.state,
 				operations: {}
 			};
 			const resolvedName = resolvedNamesByTargetId.get(entry.targetId);
 			if (resolvedName) duplicated.header.name = resolvedName;
+			entry.targetId = duplicated.header.id;
 			await this.addFile(driveIdentifier, duplicated, entry.targetParentFolder ?? void 0, signal);
 		}
 		return this.client.execute(driveIdentifier, "main", copyPlan.map((entry) => copyNode(entry)), signal);
@@ -529,8 +531,14 @@ var DriveClient = class {
 		}
 	}
 	async removeFileNode(driveId, fileId, signal) {
-		const relationshipActions = await signActions([removeRelationshipAction(driveId, fileId, "child")], this.signer, signal);
-		const driveActions = await signActions([deleteNode({ id: fileId })], this.signer, signal);
+		const relationshipActions = await signActions([removeRelationshipAction(driveId, fileId, "child")], this.signer, {
+			documentId: driveId,
+			branch: "main"
+		}, signal);
+		const driveActions = await signActions([deleteNode({ id: fileId })], this.signer, {
+			documentId: driveId,
+			branch: "main"
+		}, signal);
 		const batchResult = await this.reactor.executeBatch({ jobs: [{
 			key: "relationship",
 			documentId: driveId,
@@ -1049,8 +1057,9 @@ var ReactorClient = class {
 	documentView;
 	readGate;
 	actionEvaluation;
+	createSignaturePolicy;
 	drives;
-	constructor(logger, reactor, signer, subscriptionManager, jobAwaiter, documentIndexer, documentView, readGate = new BareReadGate(), actionEvaluation) {
+	constructor(logger, reactor, signer, subscriptionManager, jobAwaiter, documentIndexer, documentView, readGate = new BareReadGate(), actionEvaluation, createSignaturePolicy = DEFAULT_SIGNATURE_POLICY) {
 		this.logger = logger;
 		this.reactor = reactor;
 		this.signer = signer;
@@ -1060,6 +1069,7 @@ var ReactorClient = class {
 		this.documentView = documentView;
 		this.readGate = readGate;
 		this.actionEvaluation = actionEvaluation;
+		this.createSignaturePolicy = createSignaturePolicy;
 		this.drives = new DriveClient(this, logger, reactor, signer);
 		this.logger.verbose("ReactorClient initialized");
 	}
@@ -1403,12 +1413,16 @@ var ReactorClient = class {
 			scopeStates: document.state ?? {}
 		};
 	}
+	getCreateSignaturePolicy() {
+		return Promise.resolve(this.createSignaturePolicy);
+	}
 	/**
 	* Creates a document and waits for completion
 	*/
 	async create(document, parentIdentifier, signal) {
 		this.logger.verbose("create(@id, @parentIdentifier)", document.header.id, parentIdentifier);
 		const documentId = document.header.id;
+		const branch = document.header.branch || "main";
 		const createActions = await signActions([createDocumentAction({
 			model: document.header.documentType,
 			version: 0,
@@ -1431,17 +1445,23 @@ var ReactorClient = class {
 			fromVersion: 0,
 			toVersion: normalizeDocumentModelVersion(document.state.document?.version),
 			initialState: document.state
-		})], this.signer, signal);
+		})], this.signer, {
+			documentId,
+			branch
+		}, signal);
 		const jobs = [{
 			key: "create",
 			documentId,
 			scope: getSharedActionScope(createActions),
-			branch: "main",
+			branch,
 			actions: createActions,
 			dependsOn: []
 		}];
 		if (parentIdentifier) {
-			const parentActions = await signActions([addRelationshipAction(parentIdentifier, documentId, "child")], this.signer, signal);
+			const parentActions = await signActions([addRelationshipAction(parentIdentifier, documentId, "child")], this.signer, {
+				documentId: parentIdentifier,
+				branch: "main"
+			}, signal);
 			jobs.push({
 				key: "parent",
 				documentId: parentIdentifier,
@@ -1475,7 +1495,7 @@ var ReactorClient = class {
 			}, void 0);
 			if (!module) throw new Error(`Document model not found for type: ${documentModelType}`);
 		}
-		const document = module.utils.createDocument();
+		const document = withSignaturePolicy(module.utils.createDocument(), requestedSignaturePolicy(options, this.createSignaturePolicy), { protocolVersions: options?.protocolVersions });
 		document.state.document.version = normalizeDocumentModelVersion(module.version);
 		return this.create(document, options?.parentIdentifier, signal);
 	}
@@ -1510,7 +1530,10 @@ var ReactorClient = class {
 				fromVersion,
 				toVersion: targetVersion,
 				revision: { ...document.header.revision }
-			})], this.signer, signal);
+			})], this.signer, {
+				documentId,
+				branch
+			}, signal);
 			const jobInfo = await this.reactor.execute(documentId, branch, signedActions, signal);
 			const completedJob = await this.waitForJob(jobInfo, signal);
 			if (completedJob.status !== JobStatus.FAILED) {
@@ -1540,8 +1563,12 @@ var ReactorClient = class {
 	*/
 	async execute(documentIdentifier, branch, actions, signal, subject) {
 		this.logger.verbose("execute(@documentIdentifier, @branch, @count actions)", documentIdentifier, branch, actions.length);
-		const signedActions = await signActions(actions, this.signer, signal);
-		const jobInfo = await this.reactor.execute(documentIdentifier, branch, signedActions, signal);
+		const documentId = await this.resolveWriteTarget(documentIdentifier, branch, actions, signal);
+		const signedActions = await signActions(actions, this.signer, {
+			documentId,
+			branch
+		}, signal);
+		const jobInfo = await this.reactor.execute(documentId, branch, signedActions, signal);
 		const completedJob = await this.waitForJob(jobInfo, signal);
 		if (completedJob.status === JobStatus.FAILED) throw new Error(completedJob.error?.message);
 		const view = {
@@ -1556,15 +1583,38 @@ var ReactorClient = class {
 	*/
 	async executeAsync(documentIdentifier, branch, actions, signal) {
 		this.logger.verbose("executeAsync(@documentIdentifier, @branch, @count actions)", documentIdentifier, branch, actions.length);
-		const signedActions = await signActions(actions, this.signer, signal);
-		return this.reactor.execute(documentIdentifier, branch, signedActions, signal);
+		const documentId = await this.resolveWriteTarget(documentIdentifier, branch, actions, signal);
+		const signedActions = await signActions(actions, this.signer, {
+			documentId,
+			branch
+		}, signal);
+		return this.reactor.execute(documentId, branch, signedActions, signal);
+	}
+	/**
+	* The id a write on `identifier` is stored under, which its signatures bind.
+	* A create names its own id, and an id no slug maps to is taken as given, so
+	* a document still in flight resolves to itself.
+	*/
+	async resolveWriteTarget(identifier, branch, actions, signal) {
+		if (actions.some((action) => action.type === "CREATE_DOCUMENT")) return identifier;
+		const view = { branch };
+		const bySlug = await this.documentView.resolveSlug(identifier, view, void 0, signal);
+		if (bySlug === void 0 || bySlug === identifier) return identifier;
+		return this.documentView.resolveIdOrSlug(identifier, view, void 0, signal);
 	}
 	async executeBatch(request, signal) {
 		this.logger.verbose("executeBatch(@count jobs)", request.jobs.length);
-		const signedJobs = await Promise.all(request.jobs.map(async (job) => ({
-			...job,
-			actions: await signActions(job.actions, this.signer, signal)
-		})));
+		const signedJobs = await Promise.all(request.jobs.map(async (job) => {
+			const documentId = await this.resolveWriteTarget(job.documentId, job.branch, job.actions, signal);
+			return {
+				...job,
+				documentId,
+				actions: await signActions(job.actions, this.signer, {
+					documentId,
+					branch: job.branch
+				}, signal)
+			};
+		}));
 		const batchResult = await this.reactor.executeBatch({ jobs: signedJobs }, signal);
 		const completedJobs = await Promise.all(Object.values(batchResult.jobs).map((job) => this.waitForJob(job, signal)));
 		for (const job of completedJobs) if (job.status === JobStatus.FAILED) throw new Error(job.error?.message);
@@ -1870,7 +1920,7 @@ var JobResultHandler = class {
 			callbacks.deferJob(result.error.documentId, handle.job);
 			return;
 		}
-		if (result.error && (DocumentDeletedError.isError(result.error) || DocumentAlreadyExistsError.isError(result.error) || DocumentNotFoundError.isError(result.error) || AuthorizationDeniedError.isError(result.error) || AuthTimestampNotMonotonicError.isError(result.error) || InvalidOperationTimestampError.isError(result.error) || ExcessiveReshuffleError.isError(result.error) || UpgradePreconditionFailedError.isError(result.error))) {
+		if (result.error && (DocumentDeletedError.isError(result.error) || DocumentAlreadyExistsError.isError(result.error) || DocumentNotFoundError.isError(result.error) || AuthorizationDeniedError.isError(result.error) || AuthTimestampNotMonotonicError.isError(result.error) || InvalidOperationTimestampError.isError(result.error) || ExcessiveReshuffleError.isError(result.error) || InvalidSignatureError.isError(result.error) || UpgradePreconditionFailedError.isError(result.error))) {
 			const errorInfo = toErrorInfo(result.error);
 			this.jobTracker.markFailed(handle.job.id, errorInfo, handle.job);
 			this.eventBus.emit(ReactorEventTypes.JOB_FAILED, {
@@ -2258,6 +2308,7 @@ var WorkerPoolJobExecutorManager = class {
 			await this.tryDispatchFor(worker);
 			return;
 		}
+		for (const refusal of outcome.signatureRefusals ?? []) this.eventBus.emit(ReactorEventTypes.SIGNATURE_REFUSED, refusal).catch(() => {});
 		if (outcome.result.success) {
 			this.totalJobsProcessed++;
 			const completedEvent = {
@@ -2727,24 +2778,267 @@ function resolveProcessorSlots(records, legacy) {
 	});
 }
 //#endregion
+//#region src/processors/processor-queue.ts
+function isDelivery(task) {
+	return task?.kind === "live" || task?.kind === "advance";
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function lowestOf(ops) {
+	let lowest = ops[0].context.ordinal;
+	for (const op of ops) lowest = Math.min(lowest, op.context.ordinal);
+	return lowest;
+}
+function highestOf(ops) {
+	let highest = 0;
+	for (const op of ops) highest = Math.max(highest, op.context.ordinal);
+	return highest;
+}
+var ProcessorQueue = class {
+	tasks = [];
+	running = false;
+	closed = false;
+	replaysAhead = 0;
+	unrouted = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.options = options;
+	}
+	get isClosed() {
+		return this.closed;
+	}
+	/** Resolves at once behind a replay, so a pass never waits out a backfill. */
+	live(ops) {
+		const delivered = this.push((done) => ({
+			kind: "live",
+			ops,
+			done
+		}));
+		return this.replaysAhead > 0 ? Promise.resolve() : delivered;
+	}
+	/** Raises the cursor past a batch with nothing for this processor. */
+	advance(through) {
+		const last = this.tasks.at(-1);
+		if (last?.kind === "advance") {
+			last.through = Math.max(last.through, through);
+			return Promise.resolve();
+		}
+		return this.push((done) => ({
+			kind: "advance",
+			through,
+			done
+		}));
+	}
+	/** Replays from the cursor as it stands when the task runs. */
+	backfill() {
+		return this.replay("backfill", () => this.runBackfill());
+	}
+	/** Clears an error and replays from the cursor. No-op when active. */
+	retry() {
+		return this.replay("retry", async () => {
+			const { cursor } = this.options;
+			if (cursor.status !== "errored") return;
+			cursor.status = "active";
+			cursor.lastError = void 0;
+			cursor.lastErrorTimestamp = void 0;
+			await this.persist();
+			await this.runBackfill();
+		});
+	}
+	/** Stops cursor writes now; queued tasks still run before the disconnect. */
+	close() {
+		if (this.closed) return Promise.resolve();
+		const disconnect = this.enqueue("disconnect", async () => {
+			try {
+				await this.options.processor.onDisconnect();
+			} catch (error) {
+				this.options.logger.error("Error disconnecting processor '@ProcessorId': @Error", this.options.processorId, error);
+			}
+		});
+		this.closed = true;
+		return disconnect;
+	}
+	replay(kind, run) {
+		if (this.closed) return Promise.resolve();
+		this.replaysAhead++;
+		return this.enqueue(kind, async () => {
+			try {
+				await run();
+			} finally {
+				this.replaysAhead--;
+			}
+		});
+	}
+	enqueue(kind, run) {
+		return this.push((done) => ({
+			kind,
+			run,
+			done
+		}));
+	}
+	push(task) {
+		if (this.closed) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.tasks.push(task(resolve));
+			if (this.running) return;
+			this.running = true;
+			queueMicrotask(() => void this.drain());
+		});
+	}
+	async drain() {
+		while (this.tasks.length > 0) {
+			const task = this.tasks.shift();
+			const batch = [];
+			if (isDelivery(task)) {
+				batch.push(task);
+				let size = task.kind === "live" ? task.ops.length : 0;
+				let next = this.tasks[0];
+				while (isDelivery(next) && size < 500) {
+					if (next.kind === "live") size += next.ops.length;
+					batch.push(next);
+					this.tasks.shift();
+					next = this.tasks[0];
+				}
+			}
+			try {
+				await (isDelivery(task) ? this.deliverLive(batch) : task.run());
+			} catch (error) {
+				this.options.logger.error("Processor '@ProcessorId' task '@Kind' failed: @Error", this.options.processorId, task.kind, error);
+			} finally {
+				task.done();
+				for (const merged of batch.slice(1)) merged.done();
+			}
+		}
+		this.running = false;
+	}
+	async deliverLive(batch) {
+		const { cursor, floor } = this.options;
+		const ops = [];
+		let through = 0;
+		for (const task of batch) if (task.kind === "live") ops.push(...task.ops);
+		else through = Math.max(through, task.through);
+		const fresh = ops.filter((op) => {
+			const ordinal = op.context.ordinal;
+			if (ordinal <= floor) return false;
+			return !this.unrouted.delete(ordinal);
+		});
+		if (fresh.length === 0) {
+			await this.raiseCursor(through);
+			return;
+		}
+		if (cursor.status !== "active") {
+			await this.parkBelow(fresh);
+			return;
+		}
+		if (!await this.deliver(fresh)) {
+			await this.parkBelow(fresh);
+			return;
+		}
+		await this.raiseCursor(Math.max(highestOf(fresh), through));
+	}
+	async runBackfill() {
+		const { cursor, filter, floor } = this.options;
+		if (cursor.status !== "active") return;
+		let page;
+		try {
+			page = await this.options.readSince(cursor.lastOrdinal);
+		} catch (error) {
+			await this.fail(error, "reading backfill");
+			return;
+		}
+		while (page.results.length > 0) {
+			if (this.closed) return;
+			const matching = page.results.filter((op) => op.context.ordinal > floor && matchesFilter(op, filter));
+			if (matching.length > 0) {
+				if (!await this.deliver(matching)) {
+					await this.persist();
+					return;
+				}
+				this.dedupeQueued(matching);
+			}
+			await this.raiseCursor(highestOf(page.results));
+			if (!page.next) break;
+			try {
+				page = await page.next();
+			} catch (error) {
+				await this.fail(error, "reading backfill");
+				return;
+			}
+		}
+	}
+	dedupeQueued(delivered) {
+		const routed = this.options.routedThrough();
+		const queued = /* @__PURE__ */ new Set();
+		for (const op of delivered) {
+			const ordinal = op.context.ordinal;
+			if (ordinal > routed) this.unrouted.add(ordinal);
+			else queued.add(ordinal);
+		}
+		if (queued.size === 0) return;
+		for (const task of this.tasks) {
+			if (task.kind !== "live") continue;
+			task.ops = task.ops.filter((op) => !queued.has(op.context.ordinal));
+		}
+	}
+	async deliver(ops) {
+		try {
+			await this.options.processor.onOperations(ops);
+			return true;
+		} catch (error) {
+			this.markErrored(error);
+			this.options.logger.error("Processor '@ProcessorId' failed at ordinal @Ordinal: @Error", this.options.processorId, lowestOf(ops), error);
+			return false;
+		}
+	}
+	async fail(error, during) {
+		this.markErrored(error);
+		await this.persist();
+		this.options.logger.error("Processor '@ProcessorId' failed @During: @Error", this.options.processorId, during, error);
+	}
+	markErrored(error) {
+		const { cursor } = this.options;
+		cursor.status = "errored";
+		cursor.lastError = errorMessage(error);
+		cursor.lastErrorTimestamp = /* @__PURE__ */ new Date();
+	}
+	async raiseCursor(through) {
+		const { cursor } = this.options;
+		if (cursor.status !== "active") return;
+		if (through <= cursor.lastOrdinal) return;
+		cursor.lastOrdinal = through;
+		await this.persist();
+	}
+	async parkBelow(missed) {
+		const { cursor } = this.options;
+		cursor.lastOrdinal = Math.min(cursor.lastOrdinal, lowestOf(missed) - 1);
+		await this.persist();
+	}
+	async persist() {
+		if (this.closed) return;
+		const { cursor } = this.options;
+		try {
+			await this.options.persist({
+				lastOrdinal: cursor.lastOrdinal,
+				status: cursor.status,
+				lastError: cursor.lastError,
+				lastErrorTimestamp: cursor.lastErrorTimestamp
+			});
+		} catch (error) {
+			this.options.logger.error("Failed to persist cursor for '@ProcessorId': @Error", this.options.processorId, error);
+		}
+	}
+};
+//#endregion
 //#region src/processors/processor-manager.ts
-/**
-* Manages processor lifecycle based on operations.
-* Extends BaseReadModel to receive operations from ReadModelCoordinator.
-*
-* Responsibilities:
-* 1. Detect drive creation from CREATE_DOCUMENT operations
-* 2. Create processors for each drive using registered factories
-* 3. Route operations to matching processors based on filters
-* 4. Clean up processors when drives are deleted or factories are unregistered
-* 5. Track per-processor cursors for failure recovery and backfill
-*/
 var ProcessorManager = class extends BaseReadModel {
 	factoryRegistry = /* @__PURE__ */ new Map();
 	processorsByDrive = /* @__PURE__ */ new Map();
-	factoryToProcessors = /* @__PURE__ */ new Map();
+	pendingSlots = /* @__PURE__ */ new Set();
 	knownDrives = /* @__PURE__ */ new Map();
+	highestRoutedOrdinal = 0;
 	cursorCache = /* @__PURE__ */ new Map();
+	cursorWrites = /* @__PURE__ */ new Map();
+	draining = /* @__PURE__ */ new Map();
 	logger;
 	driveContainerTypes;
 	legacyProcessorIds;
@@ -2759,39 +3053,31 @@ var ProcessorManager = class extends BaseReadModel {
 		this.legacyProcessorIds = options.legacyProcessorIds ?? true;
 	}
 	async init() {
-		await super.init();
 		await this.loadAllCursors();
+		await super.init();
 		await this.discoverExistingDrives();
 	}
 	async commitOperations(items) {
-		await this.detectAndRegisterNewDrives(items);
-		await this.detectAndCleanupDeletedDrives(items);
-		await this.routeOperationsToProcessors(items);
+		const { runs, reserved } = this.detectNewDrives(items);
+		const disconnects = this.detectDeletedDrives(items);
+		const deliveries = this.enqueueRouted(items, reserved);
+		await Promise.all([
+			...runs.map((run) => run()),
+			...disconnects,
+			...deliveries
+		]);
 	}
 	async registerFactory(identifier, factory) {
-		if (this.factoryRegistry.has(identifier)) await this.unregisterFactory(identifier);
+		const removals = this.removeFactory(identifier);
 		this.factoryRegistry.set(identifier, factory);
-		this.factoryToProcessors.set(identifier, /* @__PURE__ */ new Map());
-		for (const [driveId, documentType] of this.knownDrives) {
-			const driveHeader = createMinimalDriveHeader(driveId, documentType);
-			await this.createProcessorsForDrive(driveId, identifier, factory, driveHeader);
-		}
+		const previous = this.draining.get(identifier);
+		const creationOrdinal = this.highWater() + 1;
+		const runs = [];
+		for (const [driveId, documentType] of this.knownDrives) runs.push(this.reserveSlot(identifier, factory, driveId, createMinimalDriveHeader(driveId, documentType), creationOrdinal, void 0, false, previous).run);
+		await Promise.all([...removals, ...runs.map((run) => run())]);
 	}
 	async unregisterFactory(identifier) {
-		const factoryProcessors = this.factoryToProcessors.get(identifier);
-		if (!factoryProcessors) return;
-		for (const [driveId, tracked] of factoryProcessors) {
-			for (const t of tracked) await this.safeDisconnect(t.record.processor);
-			const driveProcessors = this.processorsByDrive.get(driveId);
-			if (driveProcessors) {
-				const remaining = driveProcessors.filter((p) => !tracked.includes(p));
-				if (remaining.length > 0) this.processorsByDrive.set(driveId, remaining);
-				else this.processorsByDrive.delete(driveId);
-			}
-		}
-		await this.deleteProcessorCursors({ factoryId: identifier });
-		this.factoryToProcessors.delete(identifier);
-		this.factoryRegistry.delete(identifier);
+		await Promise.all(this.removeFactory(identifier));
 	}
 	get(processorId) {
 		for (const tracked of this.allTrackedProcessors()) if (tracked.processorId === processorId) return tracked;
@@ -2799,208 +3085,283 @@ var ProcessorManager = class extends BaseReadModel {
 	getAll() {
 		return Array.from(this.allTrackedProcessors());
 	}
-	*allTrackedProcessors() {
-		for (const tracked of this.processorsByDrive.values()) yield* tracked;
-	}
-	async detectAndRegisterNewDrives(operations) {
-		for (const op of operations) {
+	/** Synchronous: reserves a slot per registered factory for each new drive. */
+	detectNewDrives(items) {
+		const runs = [];
+		const reserved = /* @__PURE__ */ new Set();
+		for (const op of items) {
 			if (!this.isDriveCreation(op)) continue;
 			const driveId = op.context.documentId;
 			if (this.knownDrives.has(driveId)) continue;
 			this.knownDrives.set(driveId, op.context.documentType);
 			const driveHeader = extractDriveHeader(op);
 			if (!driveHeader) continue;
-			for (const [identifier, factory] of this.factoryRegistry) await this.createProcessorsForDrive(driveId, identifier, factory, driveHeader);
+			for (const [identifier, factory] of this.factoryRegistry) {
+				const { slot, run } = this.reserveSlot(identifier, factory, driveId, driveHeader, op.context.ordinal, items, true);
+				reserved.add(slot);
+				runs.push(run);
+			}
 		}
+		return {
+			runs,
+			reserved
+		};
 	}
-	isDriveCreation(op) {
-		return op.operation.action.type === "CREATE_DOCUMENT" && this.driveContainerTypes.has(op.context.documentType);
-	}
-	async detectAndCleanupDeletedDrives(operations) {
-		for (const op of operations) {
+	/** Synchronous: drops a deleted drive's processors from the tables. */
+	detectDeletedDrives(items) {
+		const pending = [];
+		for (const op of items) {
 			if (!isDriveDeletion(op)) continue;
 			const driveId = extractDeletedDocumentId(op);
 			if (!driveId || !this.knownDrives.has(driveId)) continue;
-			if (!this.isDeletedDocumentADrive(driveId)) continue;
-			await this.cleanupDriveProcessors(driveId);
 			this.knownDrives.delete(driveId);
+			for (const slot of this.pendingSlots) if (slot.driveId === driveId) this.pendingSlots.delete(slot);
+			for (const { queue } of this.processorsByDrive.get(driveId) ?? []) queue.close();
+			this.processorsByDrive.delete(driveId);
+			pending.push(...this.deleteCursors((row) => row.driveId === driveId));
+		}
+		return pending;
+	}
+	/** Synchronous: puts each processor's share of the batch on its queue. */
+	enqueueRouted(items, reserved) {
+		if (items.length === 0) return [];
+		let lowest = items[0].context.ordinal;
+		let highest = 0;
+		for (const item of items) {
+			lowest = Math.min(lowest, item.context.ordinal);
+			highest = Math.max(highest, item.context.ordinal);
+		}
+		this.highestRoutedOrdinal = Math.max(this.highestRoutedOrdinal, highest);
+		for (const slot of this.pendingSlots) {
+			if (reserved.has(slot)) continue;
+			slot.lowestRoutedOrdinal = Math.min(slot.lowestRoutedOrdinal ?? lowest, lowest);
+		}
+		const deliveries = [];
+		for (const { tracked, queue } of this.allBound()) {
+			const matching = items.filter((op) => matchesFilter(op, tracked.record.filter));
+			if (matching.length > 0) deliveries.push(queue.live(matching));
+			else queue.advance(highest);
+		}
+		return deliveries;
+	}
+	/** Synchronous: binds records, or discards them if the slot was cancelled. */
+	bind(slot, records, creationOrdinal, creationItems) {
+		const released = this.pendingSlots.delete(slot);
+		if (!records || records.length === 0) {
+			const settled = Promise.resolve();
+			return {
+				persisted: settled,
+				delivered: settled
+			};
 		}
+		if (!released) {
+			const discarded = records.map((record) => this.discard(slot, record.processor.onDisconnect.bind(record.processor)));
+			const settled = Promise.all(discarded).then(() => void 0);
+			return {
+				persisted: settled,
+				delivered: settled
+			};
+		}
+		const { factoryId, driveId, lowestRoutedOrdinal } = slot;
+		const ids = resolveProcessorSlots(records, this.legacyProcessorIds);
+		const bound = records.map((record, i) => this.track(slot, record, i, `${factoryId}:${driveId}:${ids[i]}`, creationOrdinal, lowestRoutedOrdinal));
+		const drive = this.processorsByDrive.get(driveId) ?? [];
+		this.processorsByDrive.set(driveId, [...drive, ...bound]);
+		const liveIds = new Set(bound.map((b) => b.tracked.processorId));
+		const writes = this.deleteCursors((row) => row.factoryId === factoryId && row.driveId === driveId && !liveIds.has(row.processorId));
+		for (const { tracked } of bound) writes.push(this.writeCursor(tracked, tracked));
+		const deliveries = [];
+		for (const { tracked, queue } of bound) {
+			const missed = tracked.lastOrdinal < slot.reservedAt || lowestRoutedOrdinal !== void 0;
+			if (tracked.status === "active" && missed) deliveries.push(queue.backfill());
+			const matching = creationItems?.filter((op) => matchesFilter(op, tracked.record.filter));
+			if (matching && matching.length > 0) deliveries.push(queue.live(matching));
+		}
+		return {
+			persisted: Promise.all(writes).then(() => void 0),
+			delivered: Promise.all(deliveries).then(() => void 0)
+		};
 	}
-	async discoverExistingDrives() {
-		const drives = await this.db.selectFrom("DocumentSnapshot").select(["documentId", "documentType"]).where("documentType", "in", [...this.driveContainerTypes]).where("isDeleted", "=", false).execute();
-		for (const drive of drives) this.knownDrives.set(drive.documentId, drive.documentType);
+	/** Synchronous: removes a factory's slots, processors and cursor rows. */
+	removeFactory(identifier) {
+		if (!this.factoryRegistry.delete(identifier)) return [];
+		const closing = [];
+		for (const slot of this.pendingSlots) {
+			if (slot.factoryId !== identifier) continue;
+			this.pendingSlots.delete(slot);
+			if (slot.settled) closing.push(slot.settled);
+		}
+		for (const [driveId, drive] of this.processorsByDrive) {
+			const remaining = [];
+			for (const b of drive) if (b.tracked.factoryId === identifier) closing.push(b.queue.close());
+			else remaining.push(b);
+			if (remaining.length > 0) this.processorsByDrive.set(driveId, remaining);
+			else this.processorsByDrive.delete(driveId);
+		}
+		if (closing.length > 0) {
+			const drained = Promise.all([this.draining.get(identifier), ...closing]).then(() => void 0);
+			this.draining.set(identifier, drained);
+			drained.then(() => {
+				if (this.draining.get(identifier) === drained) this.draining.delete(identifier);
+			});
+		}
+		return this.deleteCursors((row) => row.factoryId === identifier);
 	}
-	isDeletedDocumentADrive(documentId) {
-		return this.knownDrives.has(documentId);
+	reserveSlot(factoryId, factory, driveId, driveHeader, creationOrdinal, creationItems, awaitDelivery, previous) {
+		const slot = {
+			factoryId,
+			driveId,
+			reservedAt: this.highWater(),
+			lowestRoutedOrdinal: void 0,
+			settled: void 0
+		};
+		this.pendingSlots.add(slot);
+		const run = async () => {
+			const bound = (async () => {
+				await previous;
+				const records = await this.runFactory(slot, factory, driveHeader);
+				return this.bind(slot, records, creationOrdinal, creationItems);
+			})();
+			slot.settled = bound.then(({ persisted }) => persisted);
+			const { persisted, delivered } = await bound;
+			await (awaitDelivery ? Promise.all([persisted, delivered]) : persisted);
+		};
+		return {
+			slot,
+			run
+		};
 	}
-	async createProcessorsForDrive(driveId, identifier, factory, driveHeader) {
-		let records;
+	async runFactory(slot, factory, driveHeader) {
 		try {
-			records = await factory(driveHeader);
+			return await factory(driveHeader);
 		} catch (error) {
-			this.logger.error("Factory '@FactoryId' failed for drive '@DriveId': @Error", identifier, driveId, error);
+			this.logger.error("Factory '@FactoryId' failed for drive '@DriveId': @Error", slot.factoryId, slot.driveId, error);
 			return;
 		}
-		if (records.length === 0) return;
-		const trackedList = [];
-		const slots = resolveProcessorSlots(records, this.legacyProcessorIds);
-		for (let i = 0; i < records.length; i++) {
-			const record = records[i];
-			const processorId = `${identifier}:${driveId}:${slots[i]}`;
-			const cached = this.cursorCache.get(processorId);
-			let lastOrdinal;
-			let status;
-			let lastError;
-			let lastErrorTimestamp;
-			if (cached) {
-				lastOrdinal = cached.lastOrdinal;
-				status = cached.status;
-				lastError = cached.lastError ?? void 0;
-				lastErrorTimestamp = cached.lastErrorTimestamp ?? void 0;
-			} else {
-				lastOrdinal = (record.startFrom ?? "beginning") === "current" ? this.lastOrdinal : 0;
-				status = "active";
-				lastError = void 0;
-				lastErrorTimestamp = void 0;
-			}
-			const tracked = {
-				processorId,
-				factoryId: identifier,
-				driveId,
-				processorIndex: i,
-				record,
-				lastOrdinal,
-				status,
-				lastError,
-				lastErrorTimestamp,
-				retry: () => this.retryProcessor(tracked)
+	}
+	track(slot, record, processorIndex, processorId, creationOrdinal, lowestRoutedOrdinal) {
+		const cached = this.cursorCache.get(processorId);
+		let floor = 0;
+		let cursor;
+		if (cached) cursor = {
+			lastOrdinal: cached.lastOrdinal,
+			status: cached.status,
+			lastError: cached.lastError ?? void 0,
+			lastErrorTimestamp: cached.lastErrorTimestamp ?? void 0
+		};
+		else {
+			if (record.startFrom === "current") floor = creationOrdinal - 1;
+			cursor = {
+				lastOrdinal: floor,
+				status: "active",
+				lastError: void 0,
+				lastErrorTimestamp: void 0
 			};
-			trackedList.push(tracked);
-			await this.saveProcessorCursor(tracked);
-		}
-		const liveIds = new Set(trackedList.map((t) => t.processorId));
-		await this.db.deleteFrom("ProcessorCursor").where("factoryId", "=", identifier).where("driveId", "=", driveId).where("processorId", "not in", [...liveIds]).execute();
-		for (const [id, row] of this.cursorCache) if (row.factoryId === identifier && row.driveId === driveId && !liveIds.has(id)) this.cursorCache.delete(id);
-		const factoryProcessors = this.factoryToProcessors.get(identifier);
-		if (factoryProcessors) factoryProcessors.set(driveId, trackedList);
-		const existingDriveProcessors = this.processorsByDrive.get(driveId) ?? [];
-		this.processorsByDrive.set(driveId, [...existingDriveProcessors, ...trackedList]);
-		for (const tracked of trackedList) if (tracked.status === "active" && tracked.lastOrdinal < this.lastOrdinal) await this.backfillProcessor(tracked);
-	}
-	async backfillProcessor(tracked) {
-		let page = await this.operationIndex.getSinceOrdinal(tracked.lastOrdinal);
-		while (page.results.length > 0) {
-			const matching = page.results.filter((op) => matchesFilter(op, tracked.record.filter));
-			if (matching.length > 0) try {
-				await tracked.record.processor.onOperations(matching);
-			} catch (error) {
-				tracked.status = "errored";
-				tracked.lastError = error instanceof Error ? error.message : String(error);
-				tracked.lastErrorTimestamp = /* @__PURE__ */ new Date();
-				await this.safeSaveProcessorCursor(tracked);
-				this.logger.error("Processor '@ProcessorId' failed during backfill at ordinal @Ordinal: @Error", tracked.processorId, tracked.lastOrdinal, error);
-				return;
-			}
-			tracked.lastOrdinal = page.results[page.results.length - 1].context.ordinal;
-			await this.safeSaveProcessorCursor(tracked);
-			if (!page.next) break;
-			page = await page.next();
-		}
-	}
-	async retryProcessor(tracked) {
-		if (tracked.status !== "errored") return;
-		tracked.status = "active";
-		tracked.lastError = void 0;
-		tracked.lastErrorTimestamp = void 0;
-		await this.saveProcessorCursor(tracked);
-		await this.backfillProcessor(tracked);
-	}
-	async cleanupDriveProcessors(driveId) {
-		const processors = this.processorsByDrive.get(driveId);
-		if (!processors) return;
-		for (const tracked of processors) await this.safeDisconnect(tracked.record.processor);
-		this.processorsByDrive.delete(driveId);
-		for (const factoryProcessors of this.factoryToProcessors.values()) factoryProcessors.delete(driveId);
-		await this.deleteProcessorCursors({ driveId });
-	}
-	async safeDisconnect(processor) {
+		}
+		if (lowestRoutedOrdinal !== void 0) cursor.lastOrdinal = Math.max(floor, Math.min(cursor.lastOrdinal, lowestRoutedOrdinal - 1));
+		const tracked = {
+			processorId,
+			factoryId: slot.factoryId,
+			driveId: slot.driveId,
+			processorIndex,
+			record,
+			...cursor,
+			retry: () => queue.retry()
+		};
+		const queue = new ProcessorQueue({
+			processorId,
+			processor: record.processor,
+			filter: record.filter,
+			cursor: tracked,
+			floor,
+			readSince: (ordinal) => this.operationIndex.getSinceOrdinal(ordinal),
+			routedThrough: () => this.highWater(),
+			persist: (state) => this.writeCursor(tracked, state),
+			logger: this.logger
+		});
+		return {
+			tracked,
+			queue
+		};
+	}
+	async discard(slot, disconnect) {
 		try {
-			await processor.onDisconnect();
+			await disconnect();
 		} catch (error) {
-			this.logger.error("Error disconnecting processor: @Error", error);
+			this.logger.error("Error disconnecting discarded processor for '@FactoryId' on '@DriveId': @Error", slot.factoryId, slot.driveId, error);
 		}
 	}
-	async routeOperationsToProcessors(operations) {
-		let maxOrdinal = 0;
-		for (const op of operations) maxOrdinal = Math.max(maxOrdinal, op.context.ordinal);
-		const allTracked = Array.from(this.allTrackedProcessors());
-		await Promise.all(allTracked.map(async (tracked) => {
-			if (tracked.status !== "active") return;
-			const matching = operations.filter((op) => op.context.ordinal > tracked.lastOrdinal).filter((op) => matchesFilter(op, tracked.record.filter));
-			if (matching.length > 0) try {
-				await tracked.record.processor.onOperations(matching);
-			} catch (error) {
-				tracked.status = "errored";
-				tracked.lastError = error instanceof Error ? error.message : String(error);
-				tracked.lastErrorTimestamp = /* @__PURE__ */ new Date();
-				await this.safeSaveProcessorCursor(tracked);
-				this.logger.error("Processor '@ProcessorId' failed at ordinal @Ordinal: @Error", tracked.processorId, tracked.lastOrdinal, error);
-				return;
-			}
-			tracked.lastOrdinal = maxOrdinal;
-			await this.safeSaveProcessorCursor(tracked);
-		}));
+	highWater() {
+		return Math.max(this.lastOrdinal, this.highestRoutedOrdinal);
+	}
+	*allBound() {
+		for (const drive of this.processorsByDrive.values()) yield* drive;
+	}
+	*allTrackedProcessors() {
+		for (const { tracked } of this.allBound()) yield tracked;
+	}
+	isDriveCreation(op) {
+		return op.operation.action.type === "CREATE_DOCUMENT" && this.driveContainerTypes.has(op.context.documentType);
+	}
+	async discoverExistingDrives() {
+		const drives = await this.db.selectFrom("DocumentSnapshot").select(["documentId", "documentType"]).where("documentType", "in", [...this.driveContainerTypes]).where("isDeleted", "=", false).execute();
+		for (const drive of drives) this.knownDrives.set(drive.documentId, drive.documentType);
 	}
 	async loadAllCursors() {
 		const rows = await this.db.selectFrom("ProcessorCursor").selectAll().execute();
 		for (const row of rows) this.cursorCache.set(row.processorId, row);
 	}
-	async safeSaveProcessorCursor(tracked) {
-		try {
-			await this.saveProcessorCursor(tracked);
-		} catch (error) {
-			this.logger.error("Failed to persist cursor for '@ProcessorId': @Error", tracked.processorId, error);
-		}
+	lane(processorId, write) {
+		const next = (this.cursorWrites.get(processorId) ?? Promise.resolve()).then(write).then(() => void 0, (error) => {
+			this.logger.error("Failed to write cursor for '@ProcessorId': @Error", processorId, error);
+		});
+		this.cursorWrites.set(processorId, next);
+		next.then(() => {
+			if (this.cursorWrites.get(processorId) === next) this.cursorWrites.delete(processorId);
+		});
+		return next;
 	}
-	async saveProcessorCursor(tracked) {
-		await this.db.insertInto("ProcessorCursor").values({
+	writeCursor(tracked, state) {
+		const now = /* @__PURE__ */ new Date();
+		const row = {
 			processorId: tracked.processorId,
 			factoryId: tracked.factoryId,
 			driveId: tracked.driveId,
 			processorIndex: tracked.processorIndex,
-			lastOrdinal: tracked.lastOrdinal,
-			status: tracked.status,
-			lastError: tracked.lastError ?? null,
-			lastErrorTimestamp: tracked.lastErrorTimestamp ?? null,
-			updatedAt: /* @__PURE__ */ new Date()
+			lastOrdinal: state.lastOrdinal,
+			status: state.status,
+			lastError: state.lastError ?? null,
+			lastErrorTimestamp: state.lastErrorTimestamp ?? null,
+			createdAt: now,
+			updatedAt: now
+		};
+		this.cursorCache.set(row.processorId, row);
+		return this.lane(row.processorId, () => this.db.insertInto("ProcessorCursor").values({
+			processorId: row.processorId,
+			factoryId: row.factoryId,
+			driveId: row.driveId,
+			processorIndex: row.processorIndex,
+			lastOrdinal: row.lastOrdinal,
+			status: row.status,
+			lastError: row.lastError,
+			lastErrorTimestamp: row.lastErrorTimestamp,
+			updatedAt: now
 		}).onConflict((oc) => oc.column("processorId").doUpdateSet({
-			lastOrdinal: tracked.lastOrdinal,
-			status: tracked.status,
-			lastError: tracked.lastError ?? null,
-			lastErrorTimestamp: tracked.lastErrorTimestamp ?? null,
-			updatedAt: /* @__PURE__ */ new Date()
-		})).execute();
-		this.cursorCache.set(tracked.processorId, {
-			processorId: tracked.processorId,
-			factoryId: tracked.factoryId,
-			driveId: tracked.driveId,
-			processorIndex: tracked.processorIndex,
-			lastOrdinal: tracked.lastOrdinal,
-			status: tracked.status,
-			lastError: tracked.lastError ?? null,
-			lastErrorTimestamp: tracked.lastErrorTimestamp ?? null,
-			createdAt: /* @__PURE__ */ new Date(),
-			updatedAt: /* @__PURE__ */ new Date()
-		});
-	}
-	async deleteProcessorCursors(filter) {
-		if ("factoryId" in filter) {
-			await this.db.deleteFrom("ProcessorCursor").where("factoryId", "=", filter.factoryId).execute();
-			for (const [id, row] of this.cursorCache) if (row.factoryId === filter.factoryId) this.cursorCache.delete(id);
-		} else {
-			await this.db.deleteFrom("ProcessorCursor").where("driveId", "=", filter.driveId).execute();
-			for (const [id, row] of this.cursorCache) if (row.driveId === filter.driveId) this.cursorCache.delete(id);
-		}
+			lastOrdinal: row.lastOrdinal,
+			status: row.status,
+			lastError: row.lastError,
+			lastErrorTimestamp: row.lastErrorTimestamp,
+			updatedAt: now
+		})).execute());
+	}
+	deleteCursors(matches) {
+		const deletes = [];
+		for (const [processorId, row] of this.cursorCache) {
+			if (!matches(row)) continue;
+			this.cursorCache.delete(processorId);
+			deletes.push(this.lane(processorId, () => this.db.deleteFrom("ProcessorCursor").where("processorId", "=", processorId).execute()));
+		}
+		return deletes;
 	}
 };
 //#endregion
@@ -7497,7 +7858,7 @@ var Reactor = class {
 		this.logger.verbose("create(@id, @type, @slug)", document.header.id, document.header.documentType, document.header.slug);
 		const createdAtUtcIso = (/* @__PURE__ */ new Date()).toISOString();
 		throwIfAborted(signal, () => new AbortError());
-		let actions = [createDocumentAction({
+		const createAction = createDocumentAction({
 			model: document.header.documentType,
 			version: 0,
 			documentId: document.header.id,
@@ -7513,14 +7874,20 @@ var Reactor = class {
 			branch: document.header.branch,
 			meta: document.header.meta,
 			protocolVersions: document.header.protocolVersions ?? { "base-reducer": 2 }
-		}), upgradeDocumentAction({
+		});
+		const upgradeAction = upgradeDocumentAction({
 			documentId: document.header.id,
 			model: document.header.documentType,
 			fromVersion: 0,
 			toVersion: normalizeDocumentModelVersion(document.state.document?.version),
 			initialState: document.state
-		})];
-		if (signer) actions = await signActions(actions, signer, signal);
+		});
+		const branch = document.header.branch || "main";
+		let actions = [createAction, upgradeAction];
+		if (signer) actions = await signActions(actions, signer, {
+			documentId: document.header.id,
+			branch
+		}, signal);
 		const jobId = v4();
 		const jobMeta = buildSingleJobMeta(jobId, meta);
 		const job = {
@@ -7528,7 +7895,7 @@ var Reactor = class {
 			kind: "mutation",
 			documentId: document.header.id,
 			scope: "document",
-			branch: "main",
+			branch,
 			actions,
 			operations: [],
 			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7559,7 +7926,10 @@ var Reactor = class {
 		const createdAtUtcIso = (/* @__PURE__ */ new Date()).toISOString();
 		throwIfAborted(signal, () => new AbortError());
 		let action = deleteDocumentAction(id);
-		if (signer) action = await signAction(action, signer, signal);
+		if (signer) action = await signAction(action, signer, {
+			documentId: id,
+			branch: "main"
+		}, signal);
 		const jobId = v4();
 		const jobMeta = buildSingleJobMeta(jobId, meta);
 		const job = {
@@ -7816,21 +8186,30 @@ var Reactor = class {
 		this.logger.verbose("addRelationship(@sourceId, @targetId, @relationshipType, @metadata, @branch)", sourceId, targetId, relationshipType, metadata, branch);
 		throwIfAborted(signal, () => new AbortError());
 		let actions = [addRelationshipAction(sourceId, targetId, relationshipType, metadata)];
-		if (signer) actions = await signActions(actions, signer, signal);
+		if (signer) actions = await signActions(actions, signer, {
+			documentId: sourceId,
+			branch
+		}, signal);
 		return await this.execute(sourceId, branch, actions, signal);
 	}
 	async updateRelationship(sourceId, targetId, relationshipType, metadata, branch = "main", signer, signal) {
 		this.logger.verbose("updateRelationship(@sourceId, @targetId, @relationshipType, @metadata, @branch)", sourceId, targetId, relationshipType, metadata, branch);
 		throwIfAborted(signal, () => new AbortError());
 		let actions = [updateRelationshipAction(sourceId, targetId, relationshipType, metadata)];
-		if (signer) actions = await signActions(actions, signer, signal);
+		if (signer) actions = await signActions(actions, signer, {
+			documentId: sourceId,
+			branch
+		}, signal);
 		return await this.execute(sourceId, branch, actions, signal);
 	}
 	async removeRelationship(sourceId, targetId, relationshipType, branch = "main", signer, signal) {
 		this.logger.verbose("removeRelationship(@sourceId, @targetId, @relationshipType, @branch)", sourceId, targetId, relationshipType, branch);
 		throwIfAborted(signal, () => new AbortError());
 		let actions = [removeRelationshipAction(sourceId, targetId, relationshipType)];
-		if (signer) actions = await signActions(actions, signer, signal);
+		if (signer) actions = await signActions(actions, signer, {
+			documentId: sourceId,
+			branch
+		}, signal);
 		return await this.execute(sourceId, branch, actions, signal);
 	}
 	getJobStatus(jobId, signal) {
@@ -7934,8 +8313,11 @@ var ReactorBuilder = class {
 	eventBus;
 	readModelCoordinator;
 	readModelCoordinatorFactory;
-	signatureVerifier;
 	kyselyInstance;
+	signer;
+	workerSigner;
+	trustPolicy;
+	workerTrustPolicy;
 	signalHandlersEnabled = false;
 	queueInstance;
 	channelScheme;
@@ -8034,10 +8416,34 @@ var ReactorBuilder = class {
 		this.eventBus = eventBus;
 		return this;
 	}
-	withSignatureVerifier(verifier) {
-		this.signatureVerifier = verifier;
+	/**
+	* Signs the operations the executor synthesizes: the NOOP an UNDO becomes and
+	* the action a REDO rebuilds. Without one they are stored unsigned. Pooled
+	* workers import `workerSigner` to build the same signer.
+	*/
+	withSigner(signer, workerSigner) {
+		this.signer = signer;
+		this.workerSigner = workerSigner;
+		return this;
+	}
+	/** Whether {@link withSigner} was called. */
+	hasSigner() {
+		return this.signer !== void 0;
+	}
+	/**
+	* Decides at admission whether a key may sign as the user it claims; see
+	* {@link SignatureTrustPolicy} for the contract and the default. Pooled
+	* workers import `workerTrustPolicy` to build the same policy.
+	*/
+	withTrustPolicy(trustPolicy, workerTrustPolicy) {
+		this.trustPolicy = trustPolicy;
+		this.workerTrustPolicy = workerTrustPolicy;
 		return this;
 	}
+	/** Whether {@link withTrustPolicy} was called. */
+	hasTrustPolicy() {
+		return this.trustPolicy !== void 0;
+	}
 	withKysely(kysely) {
 		this.kyselyInstance = kysely;
 		return this;
@@ -8091,8 +8497,7 @@ var ReactorBuilder = class {
 	* this enables the pool — there is no `enabled` flag. Provide `db`
 	* (each worker opens its own Postgres pool; the parent database is built
 	* from it too unless {@link withKysely} is set) or a custom `factory`
-	* transport. `verifier` is imported by the default transport's workers;
-	* omitted = no executor-side signature verification.
+	* transport.
 	*/
 	withWorkerPool(options) {
 		this.workerPool = options;
@@ -8185,13 +8590,15 @@ var ReactorBuilder = class {
 			let factory = pool.factory;
 			if (!factory) {
 				if (pool.db === void 0) throw new Error("unreachable: worker pool configured without db or factory");
-				factory = await this.createDefaultWorkerFactory(pool.numWorkers, pool.db, pool.verifier);
+				if (this.signer && !this.workerSigner) this.logger.warn("Worker pool has no signer spec; pooled workers store synthesized operations unsigned");
+				if (this.trustPolicy && !this.workerTrustPolicy) this.logger.warn("Worker pool has no trust policy spec; pooled workers apply the default trust policy");
+				factory = await this.createDefaultWorkerFactory(pool.numWorkers, pool.db);
 			}
 			const poolManager = new WorkerPoolJobExecutorManager(factory, eventBus, queue, jobTracker, this.logger, resolver, operationIndex, this.executorConfig.jobTimeoutMs, this.executorConfig.deferredJobTtlMs);
 			executorManager = poolManager;
 			executorStartCount = pool.numWorkers;
 			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);
+		} else executorManager = new SimpleJobExecutorManager(() => new SimpleJobExecutor(this.logger, documentModelRegistry, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, collectionMembershipCache, this.driveContainerTypes, this.executorConfig, executionScope, this.signer, this.trustPolicy), 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 = [];
@@ -8364,7 +8771,7 @@ var ReactorBuilder = class {
 			poolInstrumentations.push(forwarder);
 			this.instrumentedPools.push(forwarder);
 		}
-		const { ProjectionShardManager } = await import("./projection-shard-manager-CUo4bF4O.js");
+		const { ProjectionShardManager } = await import("./projection-shard-manager-mQhfVipO.js");
 		const manager = new ProjectionShardManager({
 			shardCount: config.shardCount,
 			db,
@@ -8406,11 +8813,11 @@ var ReactorBuilder = class {
 	* custom `factory`. Each worker spawns a real `node:worker_threads`
 	* Worker pointing at the compiled `worker/entry.js`.
 	*/
-	async createDefaultWorkerFactory(numWorkers, db, signatureVerifier) {
+	async createDefaultWorkerFactory(numWorkers, db) {
 		const [{ WorkerHandle }, { createThreadTransport }, { workerEntryPath }] = await Promise.all([
-			import("./worker-handle-CrERzl8s.js"),
+			import("./worker-handle-B3p-nuqG.js"),
 			import("./transport-ByGviWdZ.js"),
-			import("./worker-g03lNM42.js").then((n) => n.n)
+			import("./worker-BDVzCtuf.js").then((n) => n.n)
 		]);
 		const poolConfig = {
 			enabled: true,
@@ -8430,9 +8837,10 @@ var ReactorBuilder = class {
 				initPayload: {
 					poolConfig,
 					db,
-					signatureVerifier,
 					models,
-					executorConfig: this.executorConfig
+					executorConfig: this.executorConfig,
+					signer: this.workerSigner,
+					trustPolicy: this.workerTrustPolicy
 				},
 				logger,
 				poolInstrumentation
@@ -8506,7 +8914,7 @@ var ReactorBuilder = class {
 			}
 			this.logger.info("Shutdown complete");
 			nodeProcess.exit = realExit;
-			realExit(pendingExitCode ?? 0);
+			realExit(pendingExitCode || Number(nodeProcess.exitCode ?? 0));
 		};
 		nodeProcess.prependListener("SIGINT", () => void handler("SIGINT"));
 		nodeProcess.prependListener("SIGTERM", () => void handler("SIGTERM"));
@@ -8675,30 +9083,6 @@ function createHybridProjectionCoordinatorFactory(options = {}) {
 	};
 }
 //#endregion
-//#region src/signer/passthrough-signer.ts
-/**
-* A no-op signer that returns empty values for all methods.
-* Used when signing is not required.
-*/
-var PassthroughSigner = class {
-	publicKey = {};
-	sign() {
-		return Promise.resolve(new Uint8Array(0));
-	}
-	verify() {
-		return Promise.resolve();
-	}
-	signAction() {
-		return Promise.resolve([
-			"",
-			"",
-			"",
-			"",
-			""
-		]);
-	}
-};
-//#endregion
 //#region src/core/reactor-client-builder.ts
 /**
 * Builder class for constructing ReactorClient instances with proper configuration
@@ -8711,7 +9095,10 @@ var ReactorClientBuilder = class {
 	documentIndexer;
 	documentView;
 	signer;
-	signatureVerifier;
+	workerSigner;
+	trustPolicy;
+	workerTrustPolicy;
+	createSignaturePolicy = DEFAULT_SIGNATURE_POLICY;
 	subscriptionManager;
 	jobAwaiter;
 	documentModelLoader;
@@ -8745,17 +9132,28 @@ var ReactorClientBuilder = class {
 		return this;
 	}
 	/**
-	* Sets the signer configuration for signing and verifying actions.
-	*
-	* @param config - Either an ISigner for signing only, or a SignerConfig for both signing and verification
+	* Signs submitted actions, and the operations a reactor built from
+	* `withReactorBuilder` synthesizes unless that builder has its own signer.
+	* A `trustPolicy` reaches that builder unless it has its own.
 	*/
 	withSigner(config) {
 		if ("signer" in config) {
 			this.signer = config.signer;
-			this.signatureVerifier = config.verifier;
+			this.workerSigner = config.workerSigner;
+			this.trustPolicy = config.trustPolicy;
+			this.workerTrustPolicy = config.workerTrustPolicy;
 		} else this.signer = config;
 		return this;
 	}
+	/**
+	* What the client creates new documents as when a call does not say:
+	* `v2-required` (the default) or `legacy`, for a fleet with peers that
+	* predate v2-required documents. Existing documents keep their policy.
+	*/
+	withCreateSignaturePolicy(policy) {
+		this.createSignaturePolicy = policy;
+		return this;
+	}
 	withSubscriptionManager(subscriptionManager) {
 		this.subscriptionManager = subscriptionManager;
 		return this;
@@ -8820,8 +9218,9 @@ var ReactorClientBuilder = class {
 		let documentView;
 		let reactorModule;
 		if (this.reactorBuilder) {
-			if (this.signatureVerifier) this.reactorBuilder.withSignatureVerifier(this.signatureVerifier);
 			if (this.documentModelLoader) this.reactorBuilder.withDocumentModelLoader(this.documentModelLoader);
+			if (this.signer && !this.reactorBuilder.hasSigner()) this.reactorBuilder.withSigner(this.signer, this.workerSigner);
+			if (this.trustPolicy && !this.reactorBuilder.hasTrustPolicy()) this.reactorBuilder.withTrustPolicy(this.trustPolicy, this.workerTrustPolicy);
 			reactorModule = await this.reactorBuilder.buildModule();
 			reactor = reactorModule.reactor;
 			eventBus = reactorModule.eventBus;
@@ -8839,7 +9238,7 @@ var ReactorClientBuilder = class {
 		const jobAwaiter = this.jobAwaiter ?? new JobAwaiter(eventBus, (jobId, signal) => reactor.getJobStatus(jobId, signal));
 		const decisionModel = reactorModule ? readDecisionModel(reactorModule.featureFlags, reactorModule.documentModelRegistry) : void 0;
 		return {
-			client: new ReactorClient(this.logger, reactor, signer, subscriptionManager, jobAwaiter, documentIndexer, documentView, this.readGate ?? this.resolveReadGate(reactorModule, documentView, decisionModel), this.resolveActionEvaluation(reactorModule, decisionModel)),
+			client: new ReactorClient(this.logger, reactor, signer, subscriptionManager, jobAwaiter, documentIndexer, documentView, this.readGate ?? this.resolveReadGate(reactorModule, documentView, decisionModel), this.resolveActionEvaluation(reactorModule, decisionModel), this.createSignaturePolicy),
 			reactor,
 			eventBus,
 			documentIndexer,
@@ -8877,6 +9276,21 @@ function driveIdFromUrl(url) {
 	return url.split("/").pop() ?? "";
 }
 //#endregion
+//#region src/signer/types.ts
+const SIGNATURE_REFUSAL_CODES = [
+	"UNSIGNED_REQUIRED",
+	"UNSIGNED_IDENTITY",
+	"KEY_MISMATCH",
+	"MALFORMED_TUPLE",
+	"TIMESTAMP_MISMATCH",
+	"HASH_MISMATCH",
+	"BAD_SIGNATURE",
+	"SCHEME_BELOW_POLICY",
+	"ID_MISMATCH",
+	"DUPLICATE_ACTION",
+	"SIGNER_UNAUTHORIZED"
+];
+//#endregion
 //#region src/decision/sync-scope-gate.ts
 /** What a subject may read of a document that is not there to be read. */
 const META_ONLY = (scope) => ALWAYS_READABLE_SCOPES.has(scope);
@@ -9104,6 +9518,6 @@ var DocumentIntegrityService = class {
 	}
 };
 //#endregion
-export { ALWAYS_READABLE_SCOPES, APPEND_CONDITION_FAILED_PREFIX, AppendConditionFailedError, AuthEnforcementDisabledError, BareReadGate, BaseReadModel, ChannelError, ChannelErrorSource, ChannelScheme, ConsistencyTracker, DEFAULT_COMMIT_CHUNK_SIZE, DEFAULT_DRIVE_CONTAINER_TYPES, DEFAULT_READ_MODEL_YIELD_DEADLINE_MS, DOCUMENT_INDEXER_READ_MODEL, DOCUMENT_VIEW_READ_MODEL, DRIVE_AUTH_ERROR_MESSAGES, DefaultSubscriptionErrorHandler, DeletedDocumentRead, 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, RelationshipNotFoundError, 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, defaultReadModelIndexingConfig, deleteDocumentAction, documentActions, documentDecisionModel, driveIdFromUrl, envelopesToSyncOperations, errorToInfo, firstOutOfOrderPair, getMigrationStatus, instrumentPgPool, isDriveAuthError, isRecoverableGraphQLError, makeConsistencyKey, parseDriveUrl, parsePagingOptions, quarantinesDocument, readDecisionModel, removeRelationshipAction, runMigrations, sanitizeArg, selectDecisionModel, supportsLiveReadModelRegistration, syncOperationErrorType, trimMailboxFromAckOrdinal, unchunkedReadModelIndexingConfig, updateRelationshipAction, upgradeDocumentAction, workerEntryPath };
+export { ALWAYS_READABLE_SCOPES, APPEND_CONDITION_FAILED_PREFIX, AppendConditionFailedError, AuthEnforcementDisabledError, BareReadGate, BaseReadModel, ChannelError, ChannelErrorSource, ChannelScheme, ConsistencyTracker, DEFAULT_COMMIT_CHUNK_SIZE, DEFAULT_DRIVE_CONTAINER_TYPES, DEFAULT_READ_MODEL_YIELD_DEADLINE_MS, DOCUMENT_INDEXER_READ_MODEL, DOCUMENT_VIEW_READ_MODEL, DRIVE_AUTH_ERROR_MESSAGES, DefaultSubscriptionErrorHandler, DeletedDocumentRead, 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, InvalidSignatureError, 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, RelationshipNotFoundError, RetryAccounting, RevisionMismatchError, SIGNATURE_REFUSAL_CODES, SeededStateReader, SimpleJobExecutorManager, SyncBuilder, SyncEventTypes, SyncOperation, SyncOperationAggregateError, SyncOperationStatus, SyncScopeGate, SyncStatus, SyncStatusTracker, addRelationshipAction, authDecisionModel, batchOperationsByDocument, buildDecisionModel, classifyJobFailure, consolidateSyncOperations, createDocumentAction, createForwardingLogger, createHybridProjectionCoordinatorFactory, createMutableShutdownStatus, createReactorHostModuleBase, createRelationalDb, decideAtHead, defaultReadModelIndexingConfig, deleteDocumentAction, documentActions, documentDecisionModel, driveIdFromUrl, envelopesToSyncOperations, errorToInfo, firstOutOfOrderPair, getMigrationStatus, instrumentPgPool, isDriveAuthError, isRecoverableGraphQLError, makeConsistencyKey, parseDriveUrl, parsePagingOptions, quarantinesDocument, readDecisionModel, removeRelationshipAction, runMigrations, sanitizeArg, selectDecisionModel, supportsLiveReadModelRegistration, syncOperationErrorType, trimMailboxFromAckOrdinal, unchunkedReadModelIndexingConfig, updateRelationshipAction, upgradeDocumentAction, verifyActionSignature, workerEntryPath };
 
 //# sourceMappingURL=index.js.map