@powerhousedao/reactor 6.1.0-dev.1 → 6.1.0-dev.11

package/dist/drive-container-types-BNpMlgT_.js

@@ -0,0 +1,2964 @@
+import { n as ReactorEventTypes, t as EventBusAggregateError } from "./types-CxSpmNGK.js";
+import { createPresignedHeader, defaultBaseState, deriveOperationId, isUndoRedo } from "@powerhousedao/shared/document-model";
+import { v4 } from "uuid";
+import { Migrator, sql } from "kysely";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/shared/utils.ts
+function matchesScope(view = {}, scope) {
+	if (view.scopes) return view.scopes.includes(scope);
+	return true;
+}
+function yieldToMain() {
+	const s = globalThis.scheduler;
+	if (s?.yield) return s.yield();
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
+const defaultAbortError = () => /* @__PURE__ */ new Error("Operation aborted");
+function throwIfAborted(signal, makeError = defaultAbortError) {
+	if (signal?.aborted) throw makeError();
+}
+/**
+* Validates PagingOptions and returns a normalized offset and limit.
+* Throws if the cursor is not empty and not a non-negative integer, or if
+* limit is less than 1. When `paging` is undefined, returns offset 0 and
+* the caller-supplied `defaultLimit`.
+*/
+function parsePagingOptions(paging, defaultLimit) {
+	if (paging === void 0) return {
+		offset: 0,
+		limit: defaultLimit
+	};
+	if (!Number.isInteger(paging.limit) || paging.limit < 1) throw new Error(`Invalid paging limit: ${String(paging.limit)} (must be an integer >= 1)`);
+	if (paging.cursor === "") return {
+		offset: 0,
+		limit: paging.limit
+	};
+	const parsed = Number(paging.cursor);
+	if (!Number.isInteger(parsed) || parsed < 0) throw new Error(`Invalid paging cursor: ${JSON.stringify(paging.cursor)} (must be empty or a non-negative integer)`);
+	return {
+		offset: parsed,
+		limit: paging.limit
+	};
+}
+//#endregion
+//#region src/shared/errors.ts
+/**
+* Error thrown when attempting to access a deleted document.
+*/
+var DocumentDeletedError = class DocumentDeletedError extends Error {
+	documentId;
+	deletedAtUtcIso;
+	constructor(documentId, deletedAtUtcIso = null) {
+		const message = deletedAtUtcIso ? `Document ${documentId} was deleted at ${deletedAtUtcIso}` : `Document ${documentId} has been deleted`;
+		super(message);
+		this.name = "DocumentDeletedError";
+		this.documentId = documentId;
+		this.deletedAtUtcIso = deletedAtUtcIso;
+		Error.captureStackTrace(this, DocumentDeletedError);
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "DocumentDeletedError";
+	}
+};
+/**
+* Error thrown when an operation has an invalid signature.
+*/
+var InvalidSignatureError = class InvalidSignatureError extends Error {
+	documentId;
+	reason;
+	constructor(documentId, reason) {
+		super(`Invalid signature in document ${documentId}: ${reason}`);
+		this.name = "InvalidSignatureError";
+		this.documentId = documentId;
+		this.reason = reason;
+		Error.captureStackTrace(this, InvalidSignatureError);
+	}
+};
+/**
+* Error thrown when attempting to downgrade a document version.
+*/
+var DowngradeNotSupportedError$1 = class DowngradeNotSupportedError$1 extends Error {
+	documentType;
+	fromVersion;
+	toVersion;
+	constructor(documentType, fromVersion, toVersion) {
+		super(`Downgrade not supported for ${documentType}: cannot upgrade from version ${fromVersion} to ${toVersion}`);
+		this.name = "DowngradeNotSupportedError";
+		this.documentType = documentType;
+		this.fromVersion = fromVersion;
+		this.toVersion = toVersion;
+		Error.captureStackTrace(this, DowngradeNotSupportedError$1);
+	}
+};
+/**
+* Error thrown when a document is not found (no operations exist for the document ID).
+*/
+var DocumentNotFoundError = class DocumentNotFoundError extends Error {
+	documentId;
+	constructor(documentId) {
+		super(`Document ${documentId} not found`);
+		this.name = "DocumentNotFoundError";
+		this.documentId = documentId;
+		Error.captureStackTrace(this, DocumentNotFoundError);
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "DocumentNotFoundError";
+	}
+};
+//#endregion
+//#region src/registry/errors.ts
+/**
+* Error thrown when a document model module is not found in the registry.
+*/
+var ModuleNotFoundError = class extends Error {
+	documentType;
+	requestedVersion;
+	constructor(documentType, version) {
+		const versionSuffix = version !== void 0 ? ` version ${version}` : "";
+		super(`Document model module not found for type: ${documentType}${versionSuffix}`);
+		this.name = "ModuleNotFoundError";
+		this.documentType = documentType;
+		this.requestedVersion = version;
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "ModuleNotFoundError";
+	}
+};
+/**
+* Error thrown when attempting to register a module that already exists.
+*/
+var DuplicateModuleError = class extends Error {
+	constructor(documentType, version) {
+		const versionSuffix = version !== void 0 ? ` (version ${version})` : "";
+		super(`Document model module already registered for type: ${documentType}${versionSuffix}`);
+		this.name = "DuplicateModuleError";
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "DuplicateModuleError";
+	}
+};
+/**
+* Error thrown when a module is invalid or malformed.
+*/
+var InvalidModuleError = class extends Error {
+	constructor(message) {
+		super(`Invalid document model module: ${message}`);
+		this.name = "InvalidModuleError";
+	}
+};
+/**
+* Error thrown when attempting to register an upgrade manifest that already exists.
+*/
+var DuplicateManifestError = class extends Error {
+	constructor(documentType) {
+		super(`Upgrade manifest already registered for type: ${documentType}`);
+		this.name = "DuplicateManifestError";
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "DuplicateManifestError";
+	}
+};
+/**
+* Error thrown when an upgrade manifest is not found.
+*/
+var ManifestNotFoundError = class extends Error {
+	constructor(documentType) {
+		super(`Upgrade manifest not found for type: ${documentType}`);
+		this.name = "ManifestNotFoundError";
+	}
+};
+/**
+* Error thrown when attempting a downgrade operation.
+*/
+var DowngradeNotSupportedError = class extends Error {
+	constructor(documentType, fromVersion, toVersion) {
+		super(`Downgrade not supported for ${documentType}: cannot go from version ${fromVersion} to ${toVersion}`);
+		this.name = "DowngradeNotSupportedError";
+	}
+};
+/**
+* Error thrown when a required upgrade transition is missing from the manifest.
+*/
+var MissingUpgradeTransitionError = class extends Error {
+	constructor(documentType, fromVersion, toVersion) {
+		super(`Missing upgrade transition for ${documentType}: v${fromVersion} to v${toVersion}`);
+		this.name = "MissingUpgradeTransitionError";
+	}
+};
+/**
+* Error thrown when getUpgradeReducer is called with a non-single-step version increment.
+*/
+var InvalidUpgradeStepError = class extends Error {
+	constructor(documentType, fromVersion, toVersion) {
+		super(`Invalid upgrade step for ${documentType}: must be single version increment, got v${fromVersion} to v${toVersion}`);
+		this.name = "InvalidUpgradeStepError";
+	}
+};
+//#endregion
+//#region src/cache/collection-membership-cache.ts
+var CollectionMembershipCache = class CollectionMembershipCache {
+	cache = /* @__PURE__ */ new Map();
+	constructor(operationIndex) {
+		this.operationIndex = operationIndex;
+	}
+	withScopedIndex(operationIndex) {
+		const scoped = new CollectionMembershipCache(operationIndex);
+		scoped.cache = this.cache;
+		return scoped;
+	}
+	async getCollectionsForDocuments(documentIds) {
+		const result = {};
+		const missing = [];
+		for (const docId of documentIds) {
+			const cached = this.cache.get(docId);
+			if (cached !== void 0) result[docId] = cached;
+			else missing.push(docId);
+		}
+		if (missing.length > 0) {
+			const fromDb = await this.operationIndex.getCollectionsForDocuments(missing);
+			for (const docId of missing) {
+				const collections = fromDb[docId] ?? [];
+				result[docId] = collections;
+				this.cache.set(docId, collections);
+			}
+		}
+		return result;
+	}
+	invalidate(documentId) {
+		this.cache.delete(documentId);
+	}
+};
+//#endregion
+//#region src/executor/util.ts
+/**
+* Creates a PHDocument from a CREATE_DOCUMENT action input.
+* Reconstructs the document header and initializes the base state.
+*
+* @param action - The CREATE_DOCUMENT action containing the document parameters
+* @returns A newly constructed PHDocument with initialized header and base state
+*/
+function createDocumentFromAction(action) {
+	const input = action.input;
+	const header = createPresignedHeader();
+	header.id = input.documentId;
+	header.documentType = input.model;
+	if (input.signing) {
+		header.createdAtUtcIso = input.signing.createdAtUtcIso;
+		header.lastModifiedAtUtcIso = input.signing.createdAtUtcIso;
+		header.sig = {
+			publicKey: input.signing.publicKey,
+			nonce: input.signing.nonce
+		};
+	}
+	if (input.slug !== void 0) header.slug = input.slug;
+	if (!header.slug) header.slug = input.documentId;
+	if (input.name !== void 0) header.name = input.name;
+	if (input.branch !== void 0) header.branch = input.branch;
+	if (input.meta !== void 0) header.meta = input.meta;
+	if (input.protocolVersions !== void 0) header.protocolVersions = input.protocolVersions;
+	const baseState = defaultBaseState();
+	return {
+		header,
+		operations: {},
+		state: baseState,
+		initialState: baseState,
+		clipboard: []
+	};
+}
+/**
+* Applies an UPGRADE_DOCUMENT action to a document.
+* Handles all upgrade scenarios including initial upgrades, no-ops, and multi-step upgrades.
+*
+* Behavior based on fromVersion/toVersion:
+* - fromVersion === toVersion (and fromVersion > 0): No-op - return unchanged document
+* - fromVersion > toVersion: Throw DowngradeNotSupportedError
+* - All other cases: Apply upgradePath transitions (if provided), then apply initialState, set version
+*
+* The initialState from the action is always applied (if provided) to maintain backward
+* compatibility with the original implementation.
+*
+* @param document - The document to upgrade
+* @param action - The UPGRADE_DOCUMENT action
+* @param upgradePath - Optional pre-computed upgrade path for multi-step upgrades
+* @returns The upgraded document (unchanged if no-op)
+* @throws DowngradeNotSupportedError if attempting to downgrade
+*/
+function applyUpgradeDocumentAction(document, action, upgradePath) {
+	const fromVersion = action.input.fromVersion;
+	const toVersion = action.input.toVersion;
+	if (fromVersion === toVersion && fromVersion > 0) return document;
+	if (fromVersion > toVersion) throw new DowngradeNotSupportedError$1(document.header.documentType, fromVersion, toVersion);
+	if (upgradePath) for (const transition of upgradePath) document = transition.upgradeReducer(document, action);
+	applyInitialState(document, action);
+	document.state.document = {
+		...document.state.document,
+		version: toVersion
+	};
+	return document;
+}
+function applyInitialState(document, action) {
+	const input = action.input;
+	const newState = input.initialState || input.state;
+	if (newState) {
+		document.state = {
+			...document.state,
+			...newState
+		};
+		document.initialState = document.state;
+	}
+}
+/**
+* Applies a DELETE_DOCUMENT action to a document.
+* Marks the document as deleted in the document scope state.
+*
+* @param document - The document to mark as deleted
+* @param action - The DELETE_DOCUMENT action
+* @returns The updated document (mutates in place and returns for convenience)
+*/
+function applyDeleteDocumentAction(document, action) {
+	const deletedAt = action.timestampUtcMs || (/* @__PURE__ */ new Date()).toISOString();
+	document.state = {
+		...document.state,
+		document: {
+			...document.state.document,
+			isDeleted: true,
+			deletedAtUtcIso: deletedAt
+		}
+	};
+	return document;
+}
+/**
+* Calculate the next operation index for a specific scope.
+* Each scope maintains its own independent index sequence.
+*
+* Per-scope indexing means:
+* - Each scope (document, global, local, etc.) has independent indexes
+* - Indexes start at 0 for each scope
+* - Different scopes can have operations with the same index value
+*
+* This function uses header.revision which is populated by the cache/storage layer
+* and contains the next available index for each scope. This design avoids requiring
+* the full operation history to be loaded, which is crucial for snapshot-based caching.
+*
+* @param document - The document whose header.revision to inspect
+* @param scope - The scope to calculate the next index for
+* @returns The next available index in the specified scope
+*/
+const getNextIndexForScope = (document, scope) => {
+	return document.header.revision[scope] || 0;
+};
+/**
+* Creates an empty consistency token with no coordinates.
+* Used when a job is registered or fails without writing operations.
+*
+* @returns A consistency token with an empty coordinates array
+*/
+function createEmptyConsistencyToken() {
+	return {
+		version: 1,
+		createdAtUtcIso: (/* @__PURE__ */ new Date()).toISOString(),
+		coordinates: []
+	};
+}
+/**
+* Creates a consistency token from operations written during job execution.
+* Maps each operation to a consistency coordinate tracking (documentId, scope, branch, operationIndex).
+* If no operations are provided, returns an empty token.
+*
+* @param operationsWithContext - Array of operations with their execution context
+* @returns A consistency token representing all operations written
+*/
+function createConsistencyToken(operationsWithContext) {
+	if (operationsWithContext.length === 0) return createEmptyConsistencyToken();
+	const coordinates = [];
+	for (let i = 0; i < operationsWithContext.length; i++) {
+		const opWithContext = operationsWithContext[i];
+		coordinates.push({
+			documentId: opWithContext.context.documentId,
+			scope: opWithContext.context.scope,
+			branch: opWithContext.context.branch,
+			operationIndex: opWithContext.operation.index
+		});
+	}
+	return {
+		version: 1,
+		createdAtUtcIso: (/* @__PURE__ */ new Date()).toISOString(),
+		coordinates
+	};
+}
+function createOperation(action, index, skip, context) {
+	return {
+		id: deriveOperationId(context.documentId, context.scope, context.branch, action.id),
+		index,
+		timestampUtcMs: action.timestampUtcMs || (/* @__PURE__ */ new Date()).toISOString(),
+		hash: "",
+		skip,
+		action
+	};
+}
+function updateDocumentRevision(document, scope, operationIndex) {
+	document.header.revision = {
+		...document.header.revision,
+		[scope]: operationIndex + 1
+	};
+}
+function buildSuccessResult(job, operation, documentId, documentType, resultingState, startTime) {
+	return {
+		job,
+		success: true,
+		operations: [operation],
+		operationsWithContext: [{
+			operation,
+			context: {
+				documentId,
+				scope: job.scope,
+				branch: job.branch,
+				documentType,
+				resultingState,
+				ordinal: 0
+			}
+		}],
+		duration: Date.now() - startTime
+	};
+}
+function buildErrorResult(job, error, startTime) {
+	return {
+		job,
+		success: false,
+		error,
+		duration: Date.now() - startTime
+	};
+}
+//#endregion
+//#region src/cache/lru/lru-tracker.ts
+var LRUNode = class {
+	key;
+	prev;
+	next;
+	constructor(key) {
+		this.key = key;
+		this.prev = void 0;
+		this.next = void 0;
+	}
+};
+var LRUTracker = class {
+	map;
+	head;
+	tail;
+	constructor() {
+		this.map = /* @__PURE__ */ new Map();
+		this.head = void 0;
+		this.tail = void 0;
+	}
+	get size() {
+		return this.map.size;
+	}
+	touch(key) {
+		const node = this.map.get(key);
+		if (node) this.moveToFront(node);
+		else this.addToFront(key);
+	}
+	evict() {
+		if (!this.tail) return;
+		const key = this.tail.key;
+		this.remove(key);
+		return key;
+	}
+	remove(key) {
+		const node = this.map.get(key);
+		if (!node) return;
+		this.removeNode(node);
+		this.map.delete(key);
+	}
+	clear() {
+		this.map.clear();
+		this.head = void 0;
+		this.tail = void 0;
+	}
+	addToFront(key) {
+		const node = new LRUNode(key);
+		this.map.set(key, node);
+		if (!this.head) {
+			this.head = node;
+			this.tail = node;
+		} else {
+			node.next = this.head;
+			this.head.prev = node;
+			this.head = node;
+		}
+	}
+	moveToFront(node) {
+		if (node === this.head) return;
+		this.removeNode(node);
+		node.prev = void 0;
+		node.next = this.head;
+		if (this.head) this.head.prev = node;
+		this.head = node;
+		if (!this.tail) this.tail = node;
+	}
+	removeNode(node) {
+		if (node.prev) node.prev.next = node.next;
+		else this.head = node.next;
+		if (node.next) node.next.prev = node.prev;
+		else this.tail = node.prev;
+	}
+};
+//#endregion
+//#region src/cache/document-meta-cache.ts
+/**
+* In-memory document metadata cache with LRU eviction.
+*
+* Caches PHDocumentState per (documentId, branch) key. On cache miss,
+* rebuilds from document scope operations. Provides an explicit cross-scope
+* contract for accessing document scope metadata.
+*
+* **Thread Safety:**
+* Not thread-safe. Designed for single-threaded job executor environment.
+*/
+var DocumentMetaCache = class DocumentMetaCache {
+	cache;
+	lruTracker;
+	operationStore;
+	config;
+	constructor(operationStore, config) {
+		this.operationStore = operationStore;
+		this.config = { maxDocuments: config.maxDocuments };
+		this.cache = /* @__PURE__ */ new Map();
+		this.lruTracker = new LRUTracker();
+	}
+	withScopedStore(operationStore) {
+		const scoped = new DocumentMetaCache(operationStore, this.config);
+		scoped.cache = this.cache;
+		scoped.lruTracker = this.lruTracker;
+		return scoped;
+	}
+	async startup() {
+		return Promise.resolve();
+	}
+	async shutdown() {
+		return Promise.resolve();
+	}
+	async getDocumentMeta(documentId, branch, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const key = this.makeKey(documentId, branch);
+		const cached = this.cache.get(key);
+		if (cached) {
+			this.lruTracker.touch(key);
+			return cached;
+		}
+		const meta = await this.rebuildLatest(documentId, branch, signal);
+		this.putDocumentMeta(documentId, branch, meta);
+		return meta;
+	}
+	async rebuildAtRevision(documentId, branch, targetRevision, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		return this.rebuildFromOperations(documentId, branch, targetRevision, signal);
+	}
+	putDocumentMeta(documentId, branch, meta) {
+		const key = this.makeKey(documentId, branch);
+		if (!this.cache.has(key) && this.cache.size >= this.config.maxDocuments) {
+			const evictKey = this.lruTracker.evict();
+			if (evictKey) this.cache.delete(evictKey);
+		}
+		this.cache.set(key, structuredClone(meta));
+		this.lruTracker.touch(key);
+	}
+	invalidate(documentId, branch) {
+		let evicted = 0;
+		if (branch === void 0) {
+			for (const key of this.cache.keys()) if (key.startsWith(`${documentId}:`)) {
+				this.cache.delete(key);
+				this.lruTracker.remove(key);
+				evicted++;
+			}
+		} else {
+			const key = this.makeKey(documentId, branch);
+			if (this.cache.has(key)) {
+				this.cache.delete(key);
+				this.lruTracker.remove(key);
+				evicted = 1;
+			}
+		}
+		return evicted;
+	}
+	clear() {
+		this.cache.clear();
+		this.lruTracker.clear();
+	}
+	makeKey(documentId, branch) {
+		return `${documentId}:${branch}`;
+	}
+	async rebuildLatest(documentId, branch, signal) {
+		return this.rebuildFromOperations(documentId, branch, void 0, signal);
+	}
+	async rebuildFromOperations(documentId, branch, targetRevision, signal) {
+		const docScopeOps = await this.operationStore.getSince(documentId, "document", branch, -1, void 0, void 0, signal);
+		if (docScopeOps.results.length === 0) throw new DocumentNotFoundError(documentId);
+		const createOp = docScopeOps.results[0];
+		if (createOp.action.type !== "CREATE_DOCUMENT") throw new Error(`Invalid document: first operation must be CREATE_DOCUMENT, found ${createOp.action.type}`);
+		const createAction = createOp.action;
+		const documentType = createAction.input.model;
+		let document = createDocumentFromAction(createAction);
+		let documentScopeRevision = 0;
+		for (const op of docScopeOps.results) {
+			if (targetRevision !== void 0 && op.index > targetRevision) break;
+			documentScopeRevision = op.index;
+			if (op.action.type === "UPGRADE_DOCUMENT") {
+				const upgradeAction = op.action;
+				document = applyUpgradeDocumentAction(document, upgradeAction);
+			} else if (op.action.type === "DELETE_DOCUMENT") document = applyDeleteDocumentAction(document, op.action);
+		}
+		return {
+			state: document.state.document,
+			documentType,
+			documentScopeRevision: documentScopeRevision + 1
+		};
+	}
+};
+//#endregion
+//#region src/cache/kysely-operation-index.ts
+var KyselyOperationIndexTxn = class {
+	collections = [];
+	collectionMemberships = [];
+	collectionRemovals = [];
+	operations = [];
+	createCollection(collectionId) {
+		this.collections.push(collectionId);
+	}
+	addToCollection(collectionId, documentId) {
+		const lastOpIndex = this.operations.length - 1;
+		if (lastOpIndex < 0) throw new Error("addToCollection must be called after write() - no operations in transaction");
+		this.collectionMemberships.push({
+			collectionId,
+			documentId,
+			operationIndex: lastOpIndex
+		});
+	}
+	removeFromCollection(collectionId, documentId) {
+		const lastOpIndex = this.operations.length - 1;
+		if (lastOpIndex < 0) throw new Error("removeFromCollection must be called after write() - no operations in transaction");
+		this.collectionRemovals.push({
+			collectionId,
+			documentId,
+			operationIndex: lastOpIndex
+		});
+	}
+	write(operations) {
+		this.operations.push(...operations);
+	}
+	getCollections() {
+		return this.collections;
+	}
+	getCollectionMembershipRecords() {
+		return this.collectionMemberships;
+	}
+	getCollectionRemovals() {
+		return this.collectionRemovals;
+	}
+	getOperations() {
+		return this.operations;
+	}
+};
+var KyselyOperationIndex = class KyselyOperationIndex {
+	trx;
+	constructor(db) {
+		this.db = db;
+	}
+	get queryExecutor() {
+		return this.trx ?? this.db;
+	}
+	withTransaction(trx) {
+		const instance = new KyselyOperationIndex(this.db);
+		instance.trx = trx;
+		return instance;
+	}
+	start() {
+		return new KyselyOperationIndexTxn();
+	}
+	async commit(txn, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const kyselyTxn = txn;
+		if (this.trx) return this.executeCommit(this.trx, kyselyTxn);
+		let resultOrdinals = [];
+		await this.db.transaction().execute(async (trx) => {
+			resultOrdinals = await this.executeCommit(trx, kyselyTxn);
+		});
+		return resultOrdinals;
+	}
+	async executeCommit(trx, kyselyTxn) {
+		const collections = kyselyTxn.getCollections();
+		const memberships = kyselyTxn.getCollectionMembershipRecords();
+		const removals = kyselyTxn.getCollectionRemovals();
+		const operations = kyselyTxn.getOperations();
+		if (collections.length > 0) {
+			const collectionRows = collections.map((collectionId) => ({
+				documentId: collectionId,
+				collectionId,
+				joinedOrdinal: BigInt(0),
+				leftOrdinal: null
+			}));
+			await trx.insertInto("document_collections").values(collectionRows).onConflict((oc) => oc.doNothing()).execute();
+		}
+		let operationOrdinals = [];
+		if (operations.length > 0) {
+			const operationRows = operations.map((op) => ({
+				opId: op.id || "",
+				documentId: op.documentId,
+				documentType: op.documentType,
+				scope: op.scope,
+				branch: op.branch,
+				timestampUtcMs: op.timestampUtcMs,
+				index: op.index,
+				skip: op.skip,
+				hash: op.hash,
+				action: op.action,
+				sourceRemote: op.sourceRemote
+			}));
+			operationOrdinals = (await trx.insertInto("operation_index_operations").values(operationRows).returning("ordinal").execute()).map((row) => row.ordinal);
+		}
+		if (memberships.length > 0) for (const m of memberships) {
+			const ordinal = operationOrdinals[m.operationIndex];
+			await trx.insertInto("document_collections").values({
+				documentId: m.documentId,
+				collectionId: m.collectionId,
+				joinedOrdinal: BigInt(ordinal),
+				leftOrdinal: null
+			}).onConflict((oc) => oc.columns(["documentId", "collectionId"]).doUpdateSet({
+				joinedOrdinal: BigInt(ordinal),
+				leftOrdinal: null
+			})).execute();
+		}
+		if (removals.length > 0) for (const r of removals) {
+			const ordinal = operationOrdinals[r.operationIndex];
+			await trx.updateTable("document_collections").set({ leftOrdinal: BigInt(ordinal) }).where("collectionId", "=", r.collectionId).where("documentId", "=", r.documentId).where("leftOrdinal", "is", null).execute();
+		}
+		return operationOrdinals;
+	}
+	async find(collectionId, cursor, view, paging, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const outerCursor = cursor ?? -1;
+		const pagingCursorOrdinal = paging?.cursor !== void 0 ? Number.parseInt(paging.cursor, 10) : -1;
+		const buildBranch = (kind) => {
+			let qb = this.queryExecutor.selectFrom("operation_index_operations as oi").innerJoin("document_collections as dc", "oi.documentId", "dc.documentId").selectAll("oi").select(["dc.documentId", "dc.collectionId"]).where("dc.collectionId", "=", collectionId).where(sql`(dc."leftOrdinal" IS NULL OR oi.ordinal < dc."leftOrdinal")`);
+			if (kind === "joiner") qb = qb.where("dc.joinedOrdinal", ">", BigInt(outerCursor)).where("oi.ordinal", "<=", outerCursor);
+			else qb = qb.where("oi.ordinal", ">", outerCursor);
+			qb = qb.where("oi.ordinal", ">", pagingCursorOrdinal);
+			if (view?.branch) qb = qb.where("oi.branch", "=", view.branch);
+			if (view?.scopes && view.scopes.length > 0) qb = qb.where("oi.scope", "in", view.scopes);
+			if (view?.excludeSourceRemote) qb = qb.where("oi.sourceRemote", "!=", view.excludeSourceRemote);
+			return qb;
+		};
+		let unionQuery = buildBranch("joiner").unionAll(buildBranch("newOps")).orderBy("ordinal", "asc");
+		if (paging?.limit) unionQuery = unionQuery.limit(paging.limit + 1);
+		const rows = await unionQuery.execute();
+		let hasMore = false;
+		let items = rows;
+		if (paging?.limit && rows.length > paging.limit) {
+			hasMore = true;
+			items = rows.slice(0, paging.limit);
+		}
+		const nextCursor = hasMore && items.length > 0 ? items[items.length - 1].ordinal.toString() : void 0;
+		const cursorValue = paging?.cursor || "0";
+		const limit = paging?.limit || 100;
+		return {
+			results: items.map((row) => this.rowToOperationIndexEntry(row)),
+			options: {
+				cursor: cursorValue,
+				limit
+			},
+			nextCursor,
+			next: hasMore ? () => this.find(collectionId, cursor, view, {
+				cursor: nextCursor,
+				limit
+			}, signal) : void 0
+		};
+	}
+	async get(documentId, view, paging, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		let query = this.queryExecutor.selectFrom("operation_index_operations").selectAll().where("documentId", "=", documentId).orderBy("ordinal", "asc");
+		if (view?.branch) query = query.where("branch", "=", view.branch);
+		if (view?.scopes && view.scopes.length > 0) query = query.where("scope", "in", view.scopes);
+		if (paging?.cursor) {
+			const cursorOrdinal = Number.parseInt(paging.cursor, 10);
+			query = query.where("ordinal", ">", cursorOrdinal);
+		}
+		if (paging?.limit) query = query.limit(paging.limit + 1);
+		const rows = await query.execute();
+		let hasMore = false;
+		let items = rows;
+		if (paging?.limit && rows.length > paging.limit) {
+			hasMore = true;
+			items = rows.slice(0, paging.limit);
+		}
+		const nextCursor = hasMore && items.length > 0 ? items[items.length - 1].ordinal.toString() : void 0;
+		const cursorValue = paging?.cursor || "0";
+		const limit = paging?.limit || 100;
+		return {
+			results: items.map((row) => this.rowToOperationIndexEntry(row)),
+			options: {
+				cursor: cursorValue,
+				limit
+			},
+			nextCursor,
+			next: hasMore ? () => this.get(documentId, view, {
+				cursor: nextCursor,
+				limit
+			}, signal) : void 0
+		};
+	}
+	async getSinceOrdinal(ordinal, paging, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		let query = this.queryExecutor.selectFrom("operation_index_operations").selectAll().where("ordinal", ">", ordinal).orderBy("ordinal", "asc");
+		if (paging?.cursor) {
+			const cursorOrdinal = Number.parseInt(paging.cursor, 10);
+			query = query.where("ordinal", ">", cursorOrdinal);
+		}
+		if (paging?.limit) query = query.limit(paging.limit + 1);
+		const rows = await query.execute();
+		let hasMore = false;
+		let items = rows;
+		if (paging?.limit && rows.length > paging.limit) {
+			hasMore = true;
+			items = rows.slice(0, paging.limit);
+		}
+		const nextCursor = hasMore && items.length > 0 ? items[items.length - 1].ordinal.toString() : void 0;
+		const cursorValue = paging?.cursor || "0";
+		const limit = paging?.limit || 100;
+		return {
+			results: items.map((row) => this.rowToOperationWithContext(row)),
+			options: {
+				cursor: cursorValue,
+				limit
+			},
+			nextCursor,
+			next: hasMore ? () => this.getSinceOrdinal(ordinal, {
+				cursor: nextCursor,
+				limit
+			}, signal) : void 0
+		};
+	}
+	rowToOperationWithContext(row) {
+		return {
+			operation: {
+				index: row.index,
+				timestampUtcMs: row.timestampUtcMs,
+				hash: row.hash,
+				skip: row.skip,
+				action: row.action,
+				id: row.opId
+			},
+			context: {
+				documentId: row.documentId,
+				documentType: row.documentType,
+				scope: row.scope,
+				branch: row.branch,
+				ordinal: row.ordinal
+			}
+		};
+	}
+	rowToOperationIndexEntry(row) {
+		return {
+			ordinal: row.ordinal,
+			documentId: row.documentId,
+			documentType: row.documentType,
+			branch: row.branch,
+			scope: row.scope,
+			index: row.index,
+			timestampUtcMs: row.timestampUtcMs,
+			hash: row.hash,
+			skip: row.skip,
+			action: row.action,
+			id: row.opId,
+			sourceRemote: row.sourceRemote
+		};
+	}
+	async getLatestTimestampForCollection(collectionId, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		return (await this.queryExecutor.selectFrom("operation_index_operations as oi").innerJoin("document_collections as dc", "oi.documentId", "dc.documentId").select("oi.timestampUtcMs").where("dc.collectionId", "=", collectionId).where(sql`(dc."leftOrdinal" IS NULL OR oi.ordinal < dc."leftOrdinal")`).orderBy("oi.ordinal", "desc").limit(1).executeTakeFirst())?.timestampUtcMs ?? null;
+	}
+	async getCollectionsForDocuments(documentIds) {
+		if (documentIds.length === 0) return {};
+		const rows = await this.queryExecutor.selectFrom("document_collections").select(["documentId", "collectionId"]).where("documentId", "in", documentIds).where("leftOrdinal", "is", null).execute();
+		const result = {};
+		for (const row of rows) {
+			if (!(row.documentId in result)) result[row.documentId] = [];
+			result[row.documentId].push(row.collectionId);
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/cache/buffer/ring-buffer.ts
+/**
+* RingBuffer is a generic circular buffer implementation that stores a fixed number
+* of items. When the buffer is full, new items overwrite the oldest items.
+*
+* This implementation maintains O(1) time complexity for push operations and provides
+* items in chronological order (oldest to newest) via getAll().
+*
+* @template T - The type of items stored in the buffer
+*/
+var RingBuffer = class {
+	buffer;
+	head = 0;
+	size = 0;
+	capacity;
+	constructor(capacity) {
+		if (capacity <= 0) throw new Error("Ring buffer capacity must be greater than 0");
+		this.capacity = capacity;
+		this.buffer = new Array(capacity);
+	}
+	/**
+	* Adds an item to the buffer. If the buffer is full, overwrites the oldest item.
+	*
+	* @param item - The item to add
+	*/
+	push(item) {
+		const index = (this.head + this.size) % this.capacity;
+		if (this.size < this.capacity) {
+			this.buffer[index] = item;
+			this.size++;
+		} else {
+			this.buffer[this.head] = item;
+			this.head = (this.head + 1) % this.capacity;
+		}
+	}
+	/**
+	* Returns all items in the buffer in chronological order (oldest to newest).
+	*
+	* @returns Array of items in insertion order
+	*/
+	getAll() {
+		if (this.size === 0) return [];
+		const result = [];
+		for (let i = 0; i < this.size; i++) {
+			const index = (this.head + i) % this.capacity;
+			result.push(this.buffer[index]);
+		}
+		return result;
+	}
+	/**
+	* Clears all items from the buffer.
+	*/
+	clear() {
+		this.buffer = new Array(this.capacity);
+		this.head = 0;
+		this.size = 0;
+	}
+	/**
+	* Gets the current number of items in the buffer.
+	*/
+	get length() {
+		return this.size;
+	}
+};
+//#endregion
+//#region src/cache/kysely-write-cache.ts
+function extractModuleVersion(doc) {
+	const v = doc.state.document.version;
+	return v === 0 ? void 0 : v;
+}
+/**
+* In-memory write cache with keyframe persistence for PHDocuments.
+*
+* Caches document snapshots in ring buffers with LRU eviction. On cache miss,
+* rebuilds documents from nearest keyframe or full operation history.
+*
+* **Performance Characteristics:**
+* - Cache hit: O(1) lookup in ring buffer
+* - Cold miss: O(n) where n is total operation count, or O(k) where k is operations since keyframe
+* - Warm miss: O(m) where m is operations since cached revision
+* - Eviction: O(1) for LRU tracking and removal
+*
+* **Thread Safety:**
+* Not thread-safe. Designed for single-threaded job executor environment.
+* External synchronization required for concurrent access across multiple executors.
+*
+* **Example:**
+* ```typescript
+* const cache = new KyselyWriteCache(
+*   keyframeStore,
+*   operationStore,
+*   registry,
+*   { maxDocuments: 1000, ringBufferSize: 10, keyframeInterval: 10 }
+* );
+*
+* await cache.startup();
+*
+* // Retrieve or rebuild document
+* const doc = await cache.getState(docId, docType, scope, branch, revision);
+*
+* // Cache result after job execution
+* cache.putState(docId, docType, scope, branch, newRevision, updatedDoc);
+*
+* await cache.shutdown();
+* ```
+*/
+var KyselyWriteCache = class KyselyWriteCache {
+	streams;
+	lruTracker;
+	keyframeStore;
+	operationStore;
+	registry;
+	config;
+	constructor(keyframeStore, operationStore, registry, config) {
+		this.keyframeStore = keyframeStore;
+		this.operationStore = operationStore;
+		this.registry = registry;
+		this.config = {
+			maxDocuments: config.maxDocuments,
+			ringBufferSize: config.ringBufferSize,
+			keyframeInterval: config.keyframeInterval
+		};
+		this.streams = /* @__PURE__ */ new Map();
+		this.lruTracker = new LRUTracker();
+	}
+	withScopedStores(operationStore, keyframeStore) {
+		const scoped = new KyselyWriteCache(keyframeStore, operationStore, this.registry, this.config);
+		scoped.streams = this.streams;
+		scoped.lruTracker = this.lruTracker;
+		return scoped;
+	}
+	/**
+	* Initializes the write cache.
+	* Currently a no-op as keyframe store lifecycle is managed externally.
+	*/
+	async startup() {
+		return Promise.resolve();
+	}
+	/**
+	* Shuts down the write cache.
+	* Currently a no-op as keyframe store lifecycle is managed externally.
+	*/
+	async shutdown() {
+		return Promise.resolve();
+	}
+	/**
+	* Retrieves document state at a specific revision from cache or rebuilds it.
+	*
+	* Cache hit path: Returns cached snapshot if available (O(1))
+	* Warm miss path: Rebuilds from cached base revision + incremental ops
+	* Cold miss path: Rebuilds from keyframe or from scratch using all operations
+	*
+	* @param documentId - The document identifier
+	* @param scope - The operation scope
+	* @param branch - The operation branch
+	* @param targetRevision - The target revision, or undefined for newest
+	* @param signal - Optional abort signal to cancel the operation
+	* @returns The document at the target revision
+	* @throws {Error} "Operation aborted" if signal is aborted
+	* @throws {ModuleNotFoundError} If document type not registered in registry
+	* @throws {Error} "Failed to rebuild document" if operation store fails
+	* @throws {Error} If reducer throws during operation application
+	* @throws {Error} If document serialization fails
+	*/
+	async getState(documentId, scope, branch, targetRevision, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const streamKey = this.makeStreamKey(documentId, scope, branch);
+		const stream = this.streams.get(streamKey);
+		if (stream) {
+			const snapshots = stream.ringBuffer.getAll();
+			if (targetRevision === void 0) {
+				if (snapshots.length > 0) {
+					const newest = snapshots[snapshots.length - 1];
+					this.lruTracker.touch(streamKey);
+					return newest.document;
+				}
+			} else {
+				const exactMatch = snapshots.find((s) => s.revision === targetRevision);
+				if (exactMatch) {
+					this.lruTracker.touch(streamKey);
+					return exactMatch.document;
+				}
+				const newestOlder = this.findNearestOlderSnapshot(snapshots, targetRevision);
+				if (newestOlder) {
+					const document = await this.warmMissRebuild(newestOlder.document, newestOlder.revision, documentId, scope, branch, targetRevision, signal);
+					this.putState(documentId, scope, branch, targetRevision, document);
+					this.lruTracker.touch(streamKey);
+					return document;
+				}
+			}
+		}
+		const document = await this.coldMissRebuild(documentId, scope, branch, targetRevision, signal);
+		let revision = targetRevision;
+		if (revision === void 0) revision = document.header.revision[scope] || 0;
+		this.putState(documentId, scope, branch, revision, document);
+		return document;
+	}
+	/**
+	* Stores a document snapshot in the cache at a specific revision.
+	*
+	* The cached document is a shallow copy of the input with its operation history
+	* truncated to the last operation per scope and its clipboard cleared. This keeps
+	* memory use and copy costs constant regardless of operation count. Consumers of
+	* getState() must not rely on the full operation history being present; the only
+	* guaranteed invariant is that operations[scope].at(-1) reflects the latest
+	* operation index for each scope.
+	*
+	* Updates LRU tracker and may evict least recently used stream if at capacity.
+	* Asynchronously persists keyframes at configured intervals (fire-and-forget).
+	*
+	* @param documentId - The document identifier
+	* @param scope - The operation scope
+	* @param branch - The operation branch
+	* @param revision - The revision number
+	* @param document - The document to cache
+	* @throws {Error} If document serialization fails
+	*/
+	putState(documentId, scope, branch, revision, document) {
+		const streamKey = this.makeStreamKey(documentId, scope, branch);
+		const stream = this.getOrCreateStream(streamKey);
+		const snapshot = {
+			revision,
+			document: {
+				...document,
+				operations: Object.fromEntries(Object.entries(document.operations).map(([k, ops]) => [k, ops.length ? [ops.at(-1)] : []])),
+				clipboard: []
+			}
+		};
+		stream.ringBuffer.push(snapshot);
+		if (this.isKeyframeRevision(revision)) this.keyframeStore.putKeyframe(documentId, scope, branch, revision, {
+			...document,
+			operations: {},
+			clipboard: []
+		}).catch((err) => {
+			console.error(`Failed to persist keyframe ${documentId}@${revision}:`, err);
+		});
+	}
+	/**
+	* Invalidates cached document streams.
+	*
+	* Supports three invalidation scopes:
+	* - Document-level: invalidate(documentId) - removes all streams for document
+	* - Scope-level: invalidate(documentId, scope) - removes all branches for scope
+	* - Stream-level: invalidate(documentId, scope, branch) - removes specific stream
+	*
+	* @param documentId - The document identifier
+	* @param scope - Optional scope to narrow invalidation
+	* @param branch - Optional branch to narrow invalidation (requires scope)
+	* @returns The number of streams evicted
+	*/
+	invalidate(documentId, scope, branch) {
+		let evicted = 0;
+		if (scope === void 0 && branch === void 0) {
+			for (const [key] of this.streams.entries()) if (key.startsWith(`${documentId}:`)) {
+				this.streams.delete(key);
+				this.lruTracker.remove(key);
+				evicted++;
+			}
+		} else if (scope !== void 0 && branch === void 0) {
+			for (const [key] of this.streams.entries()) if (key.startsWith(`${documentId}:${scope}:`)) {
+				this.streams.delete(key);
+				this.lruTracker.remove(key);
+				evicted++;
+			}
+		} else if (scope !== void 0 && branch !== void 0) {
+			const key = this.makeStreamKey(documentId, scope, branch);
+			if (this.streams.has(key)) {
+				this.streams.delete(key);
+				this.lruTracker.remove(key);
+				evicted = 1;
+			}
+		}
+		return evicted;
+	}
+	/**
+	* Clears the entire cache, removing all cached document streams.
+	* Resets LRU tracking state. This operation always succeeds.
+	*/
+	clear() {
+		this.streams.clear();
+		this.lruTracker.clear();
+	}
+	/**
+	* Retrieves a specific stream for a document. Exposed on the implementation
+	* for testing, but not on the interface.
+	*
+	* @internal
+	*/
+	getStream(documentId, scope, branch) {
+		const key = this.makeStreamKey(documentId, scope, branch);
+		return this.streams.get(key);
+	}
+	async findNearestKeyframe(documentId, scope, branch, targetRevision, signal) {
+		if (targetRevision === Number.MAX_SAFE_INTEGER || targetRevision <= 0) return;
+		return this.keyframeStore.findNearestKeyframe(documentId, scope, branch, targetRevision, signal);
+	}
+	async coldMissRebuild(documentId, scope, branch, targetRevision, signal) {
+		const effectiveTargetRevision = targetRevision || Number.MAX_SAFE_INTEGER;
+		const keyframe = await this.findNearestKeyframe(documentId, scope, branch, effectiveTargetRevision, signal);
+		let document;
+		let startRevision;
+		let documentType;
+		if (keyframe) {
+			document = keyframe.document;
+			startRevision = keyframe.revision;
+			documentType = keyframe.document.header.documentType;
+		} else {
+			startRevision = -1;
+			const createOpResult = await this.operationStore.getSince(documentId, "document", branch, -1, void 0, {
+				cursor: "0",
+				limit: 1
+			}, signal);
+			if (createOpResult.results.length === 0) throw new Error(`Failed to rebuild document ${documentId}: no CREATE_DOCUMENT operation found in document scope`);
+			const createOp = createOpResult.results[0];
+			if (createOp.action.type !== "CREATE_DOCUMENT") throw new Error(`Failed to rebuild document ${documentId}: first operation in document scope must be CREATE_DOCUMENT, found ${createOp.action.type}`);
+			const documentCreateAction = createOp.action;
+			documentType = documentCreateAction.input.model;
+			if (!documentType) throw new Error(`Failed to rebuild document ${documentId}: CREATE_DOCUMENT action missing model in input`);
+			document = createDocumentFromAction(documentCreateAction);
+			let docModule = this.registry.getModule(documentType, extractModuleVersion(document));
+			const docScopeOps = await this.operationStore.getSince(documentId, "document", branch, 0, void 0, void 0, signal);
+			for (const operation of docScopeOps.results) {
+				if (operation.index === 0) continue;
+				if (operation.action.type === "UPGRADE_DOCUMENT") {
+					const upgradeAction = operation.action;
+					document = applyUpgradeDocumentAction(document, upgradeAction);
+					docModule = this.registry.getModule(documentType, extractModuleVersion(document));
+				} else if (operation.action.type === "DELETE_DOCUMENT") applyDeleteDocumentAction(document, operation.action);
+				else {
+					const protocolVersion = document.header.protocolVersions?.["base-reducer"] ?? 1;
+					document = docModule.reducer(document, operation.action, void 0, {
+						skip: operation.skip,
+						protocolVersion
+					});
+				}
+			}
+		}
+		const module = this.registry.getModule(documentType, extractModuleVersion(document));
+		let cursor = void 0;
+		const pageSize = 100;
+		let hasMorePages;
+		do {
+			if (signal?.aborted) throw new Error("Operation aborted");
+			const paging = {
+				cursor: cursor || "0",
+				limit: pageSize
+			};
+			try {
+				const result = await this.operationStore.getSince(documentId, scope, branch, startRevision, void 0, paging, signal);
+				for (const operation of result.results) {
+					if (targetRevision !== void 0 && operation.index > targetRevision) break;
+					const protocolVersion = document.header.protocolVersions?.["base-reducer"] ?? 1;
+					document = module.reducer(document, operation.action, void 0, {
+						skip: operation.skip,
+						protocolVersion
+					});
+				}
+				const reachedTarget = targetRevision !== void 0 && result.results.some((op) => op.index >= targetRevision);
+				hasMorePages = Boolean(result.nextCursor) && !reachedTarget;
+				if (hasMorePages) cursor = result.nextCursor;
+			} catch (err) {
+				throw new Error(`Failed to rebuild document ${documentId}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+			}
+		} while (hasMorePages);
+		const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
+		document.header.revision = revisions.revision;
+		document.header.lastModifiedAtUtcIso = revisions.latestTimestamp;
+		return document;
+	}
+	async warmMissRebuild(baseDocument, baseRevision, documentId, scope, branch, targetRevision, signal) {
+		const documentType = baseDocument.header.documentType;
+		const module = this.registry.getModule(documentType);
+		let document = baseDocument;
+		try {
+			const pagedResults = await this.operationStore.getSince(documentId, scope, branch, baseRevision, void 0, void 0, signal);
+			for (const operation of pagedResults.results) {
+				if (signal?.aborted) throw new Error("Operation aborted");
+				if (targetRevision !== void 0 && operation.index > targetRevision) break;
+				const protocolVersion = document.header.protocolVersions?.["base-reducer"] ?? 1;
+				document = module.reducer(document, operation.action, void 0, {
+					skip: operation.skip,
+					protocolVersion
+				});
+				if (targetRevision !== void 0 && operation.index === targetRevision) break;
+			}
+		} catch (err) {
+			throw new Error(`Failed to rebuild document ${documentId}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		}
+		const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
+		document.header.revision = revisions.revision;
+		document.header.lastModifiedAtUtcIso = revisions.latestTimestamp;
+		return document;
+	}
+	findNearestOlderSnapshot(snapshots, targetRevision) {
+		let nearest = void 0;
+		for (const snapshot of snapshots) if (snapshot.revision < targetRevision) {
+			if (!nearest || snapshot.revision > nearest.revision) nearest = snapshot;
+		}
+		return nearest;
+	}
+	makeStreamKey(documentId, scope, branch) {
+		return `${documentId}:${scope}:${branch}`;
+	}
+	getOrCreateStream(key) {
+		let stream = this.streams.get(key);
+		if (!stream) {
+			if (this.streams.size >= this.config.maxDocuments) {
+				const evictKey = this.lruTracker.evict();
+				if (evictKey) this.streams.delete(evictKey);
+			}
+			stream = {
+				key,
+				ringBuffer: new RingBuffer(this.config.ringBufferSize)
+			};
+			this.streams.set(key, stream);
+		}
+		this.lruTracker.touch(key);
+		return stream;
+	}
+	isKeyframeRevision(revision) {
+		return revision > 0 && revision % this.config.keyframeInterval === 0;
+	}
+};
+//#endregion
+//#region src/events/event-bus.ts
+var EventBus = class {
+	eventTypeToSubscribers = /* @__PURE__ */ new Map();
+	subscribe(type, subscriber) {
+		let list = this.eventTypeToSubscribers.get(type);
+		if (!list) {
+			list = [];
+			this.eventTypeToSubscribers.set(type, list);
+		}
+		list.push(subscriber);
+		let done = false;
+		return () => {
+			if (done) return;
+			done = true;
+			const arr = this.eventTypeToSubscribers.get(type);
+			if (!arr) return;
+			const idx = arr.indexOf(subscriber);
+			if (idx !== -1) arr.splice(idx, 1);
+			if (arr.length === 0) this.eventTypeToSubscribers.delete(type);
+		};
+	}
+	async emit(type, data) {
+		const list = this.eventTypeToSubscribers.get(type);
+		if (!list || list.length === 0) return;
+		const snapshot = list.slice();
+		const errors = [];
+		for (const fn of snapshot) try {
+			await Promise.resolve(fn(type, data));
+		} catch (err) {
+			errors.push(err);
+		}
+		if (errors.length > 0) throw new EventBusAggregateError(errors);
+	}
+};
+//#endregion
+//#region src/executor/execution-scope.ts
+var DefaultExecutionScope = class {
+	constructor(operationStore, operationIndex, writeCache, documentMetaCache, collectionMembershipCache) {
+		this.operationStore = operationStore;
+		this.operationIndex = operationIndex;
+		this.writeCache = writeCache;
+		this.documentMetaCache = documentMetaCache;
+		this.collectionMembershipCache = collectionMembershipCache;
+	}
+	async run(fn, signal) {
+		signal?.throwIfAborted();
+		return fn({
+			operationStore: this.operationStore,
+			operationIndex: this.operationIndex,
+			writeCache: this.writeCache,
+			documentMetaCache: this.documentMetaCache,
+			collectionMembershipCache: this.collectionMembershipCache
+		});
+	}
+};
+var KyselyExecutionScope = class {
+	constructor(db, operationStore, operationIndex, keyframeStore, writeCache, documentMetaCache, collectionMembershipCache) {
+		this.db = db;
+		this.operationStore = operationStore;
+		this.operationIndex = operationIndex;
+		this.keyframeStore = keyframeStore;
+		this.writeCache = writeCache;
+		this.documentMetaCache = documentMetaCache;
+		this.collectionMembershipCache = collectionMembershipCache;
+	}
+	async run(fn, signal) {
+		signal?.throwIfAborted();
+		return this.db.transaction().execute(async (trx) => {
+			const scopedOperationStore = this.operationStore.withTransaction(trx);
+			const scopedOperationIndex = this.operationIndex.withTransaction(trx);
+			const scopedKeyframeStore = this.keyframeStore.withTransaction(trx);
+			return fn({
+				operationStore: scopedOperationStore,
+				operationIndex: scopedOperationIndex,
+				writeCache: this.writeCache.withScopedStores(scopedOperationStore, scopedKeyframeStore),
+				documentMetaCache: this.documentMetaCache.withScopedStore(scopedOperationStore),
+				collectionMembershipCache: this.collectionMembershipCache.withScopedIndex(scopedOperationIndex)
+			});
+		});
+	}
+};
+//#endregion
+//#region src/utils/reshuffle.ts
+const STRICT_ORDER_ACTION_TYPES = new Set([
+	"CREATE_DOCUMENT",
+	"DELETE_DOCUMENT",
+	"UPGRADE_DOCUMENT",
+	"ADD_RELATIONSHIP",
+	"REMOVE_RELATIONSHIP",
+	"UPDATE_RELATIONSHIP",
+	"ADD_FOLDER",
+	"UPDATE_FOLDER",
+	"REMOVE_FOLDER"
+]);
+/**
+* Reshuffles operations by timestamp, then applies deterministic tie-breaking.
+* Used for merging concurrent operations from different branches.
+*
+* For strict document-structure actions (e.g., CREATE_DOCUMENT/UPGRADE_DOCUMENT),
+* logical index (index - skip) is prioritized to preserve causal replay order.
+*
+* For other actions, action ID is prioritized to ensure a canonical cross-reactor order
+* for concurrent operations that may have diverged local indices due to prior reshuffles.
+* Logical index and operation ID are then used as deterministic tie-breakers.
+*
+* Example:
+* [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, 2:0, B3:0, B4:2, B5:0]
+* GC               => [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, B4:2, B5:0]
+* Split            => [0:0, 1:0] + [2:0, A3:0, A4:0, A5:0] + [B4:2, B5:0]
+* Reshuffle(6:4)   => [6:4, 7:0, 8:0, 9:0, 10:0, 11:0]
+* merge            => [0:0, 1:0, 6:4, 7:0, 8:0, 9:0, 10:0, 11:0]
+*/
+function reshuffleByTimestamp(startIndex, opsA, opsB) {
+	return [...opsA, ...opsB].sort((a, b) => {
+		const timestampDiff = new Date(a.timestampUtcMs).getTime() - new Date(b.timestampUtcMs).getTime();
+		if (timestampDiff !== 0) return timestampDiff;
+		const shouldPrioritizeLogicalIndex = STRICT_ORDER_ACTION_TYPES.has(a.action?.type ?? "") || STRICT_ORDER_ACTION_TYPES.has(b.action?.type ?? "");
+		const logicalIndexDiff = a.index - a.skip - (b.index - b.skip);
+		if (shouldPrioritizeLogicalIndex) {
+			if (logicalIndexDiff !== 0) return logicalIndexDiff;
+		}
+		const actionIdDiff = (a.action?.id ?? "").localeCompare(b.action?.id ?? "");
+		if (actionIdDiff !== 0) return actionIdDiff;
+		if (!shouldPrioritizeLogicalIndex && logicalIndexDiff !== 0) return logicalIndexDiff;
+		return a.id.localeCompare(b.id);
+	}).map((op, i) => ({
+		...op,
+		index: startIndex.index + i,
+		skip: i === 0 ? startIndex.skip : 0
+	}));
+}
+//#endregion
+//#region src/cache/operation-index-types.ts
+function driveCollectionId(branch, driveId) {
+	return `drive.${branch}.${driveId}`;
+}
+//#endregion
+//#region src/executor/document-action-handler.ts
+var DocumentActionHandler = class {
+	constructor(registry, logger, driveContainerTypes) {
+		this.registry = registry;
+		this.logger = logger;
+		this.driveContainerTypes = driveContainerTypes;
+	}
+	async execute(job, action, startTime, indexTxn, stores, skip = 0, sourceRemote = "", signal) {
+		switch (action.type) {
+			case "CREATE_DOCUMENT": return this.executeCreate(job, action, startTime, indexTxn, stores, skip, sourceRemote, signal);
+			case "DELETE_DOCUMENT": return this.executeDelete(job, action, startTime, indexTxn, stores, sourceRemote, signal);
+			case "UPGRADE_DOCUMENT": return this.executeUpgrade(job, action, startTime, indexTxn, stores, skip, sourceRemote, signal);
+			case "ADD_RELATIONSHIP": return this.executeAddRelationship(job, action, startTime, indexTxn, stores, sourceRemote, signal);
+			case "REMOVE_RELATIONSHIP": return this.executeRemoveRelationship(job, action, startTime, indexTxn, stores, sourceRemote, signal);
+			case "UPDATE_RELATIONSHIP": return this.executeUpdateRelationship(job, action, startTime, indexTxn, stores, sourceRemote, signal);
+			default: return buildErrorResult(job, /* @__PURE__ */ new Error(`Unknown document action type: ${action.type}`), startTime);
+		}
+	}
+	async executeCreate(job, action, startTime, indexTxn, stores, skip = 0, sourceRemote = "", signal) {
+		if (job.scope !== "document") return {
+			job,
+			success: false,
+			error: /* @__PURE__ */ new Error(`CREATE_DOCUMENT must be in "document" scope, got "${job.scope}"`),
+			duration: Date.now() - startTime
+		};
+		const document = createDocumentFromAction(action);
+		let operation = createOperation(action, 0, skip, {
+			documentId: document.header.id,
+			scope: job.scope,
+			branch: job.branch
+		});
+		const resultingStateObj = {
+			header: document.header,
+			...document.state
+		};
+		const resultingState = JSON.stringify(resultingStateObj);
+		const writeResult = await this.writeOperationToStore(document.header.id, document.header.documentType, job.scope, job.branch, operation, job, startTime, stores, signal);
+		if (!Array.isArray(writeResult)) return writeResult;
+		operation = writeResult[0];
+		updateDocumentRevision(document, job.scope, operation.index);
+		document.operations = {
+			...document.operations,
+			[job.scope]: [...document.operations[job.scope] ?? [], operation]
+		};
+		stores.writeCache.putState(document.header.id, job.scope, job.branch, operation.index, document);
+		indexTxn.write([{
+			...operation,
+			documentId: document.header.id,
+			documentType: document.header.documentType,
+			branch: job.branch,
+			scope: job.scope,
+			sourceRemote
+		}]);
+		if (this.driveContainerTypes.has(document.header.documentType)) {
+			const collectionId = driveCollectionId(job.branch, document.header.id);
+			indexTxn.createCollection(collectionId);
+			indexTxn.addToCollection(collectionId, document.header.id);
+		}
+		stores.documentMetaCache.putDocumentMeta(document.header.id, job.branch, {
+			state: document.state.document,
+			documentType: document.header.documentType,
+			documentScopeRevision: 1
+		});
+		return buildSuccessResult(job, operation, document.header.id, document.header.documentType, resultingState, startTime);
+	}
+	async executeDelete(job, action, startTime, indexTxn, stores, sourceRemote = "", signal) {
+		const input = action.input;
+		if (!input.documentId) return buildErrorResult(job, /* @__PURE__ */ new Error("DELETE_DOCUMENT action requires a documentId in input"), startTime);
+		const documentId = input.documentId;
+		let document;
+		try {
+			document = await stores.writeCache.getState(documentId, job.scope, job.branch, void 0, signal);
+		} catch (error) {
+			return buildErrorResult(job, /* @__PURE__ */ new Error(`Failed to fetch document before deletion: ${error instanceof Error ? error.message : String(error)}`), startTime);
+		}
+		const documentState = document.state.document;
+		if (documentState.isDeleted) return buildErrorResult(job, new DocumentDeletedError(documentId, documentState.deletedAtUtcIso), startTime);
+		let operation = createOperation(action, getNextIndexForScope(document, job.scope), 0, {
+			documentId,
+			scope: job.scope,
+			branch: job.branch
+		});
+		applyDeleteDocumentAction(document, action);
+		const resultingStateObj = {
+			header: document.header,
+			document: document.state.document
+		};
+		const resultingState = JSON.stringify(resultingStateObj);
+		const writeResult = await this.writeOperationToStore(documentId, document.header.documentType, job.scope, job.branch, operation, job, startTime, stores, signal);
+		if (!Array.isArray(writeResult)) return writeResult;
+		operation = writeResult[0];
+		updateDocumentRevision(document, job.scope, operation.index);
+		document.operations = {
+			...document.operations,
+			[job.scope]: [...document.operations[job.scope] ?? [], operation]
+		};
+		stores.writeCache.putState(documentId, job.scope, job.branch, operation.index, document);
+		indexTxn.write([{
+			...operation,
+			documentId,
+			documentType: document.header.documentType,
+			branch: job.branch,
+			scope: job.scope,
+			sourceRemote
+		}]);
+		stores.documentMetaCache.putDocumentMeta(documentId, job.branch, {
+			state: document.state.document,
+			documentType: document.header.documentType,
+			documentScopeRevision: operation.index + 1
+		});
+		return buildSuccessResult(job, operation, documentId, document.header.documentType, resultingState, startTime);
+	}
+	async executeUpgrade(job, action, startTime, indexTxn, stores, skip = 0, sourceRemote = "", signal) {
+		const input = action.input;
+		if (!input.documentId) return buildErrorResult(job, /* @__PURE__ */ new Error("UPGRADE_DOCUMENT action requires a documentId in input"), startTime);
+		const documentId = input.documentId;
+		const fromVersion = input.fromVersion;
+		const toVersion = input.toVersion;
+		let document;
+		try {
+			document = await stores.writeCache.getState(documentId, job.scope, job.branch, void 0, signal);
+		} catch (error) {
+			return buildErrorResult(job, /* @__PURE__ */ new Error(`Failed to fetch document for upgrade: ${error instanceof Error ? error.message : String(error)}`), startTime);
+		}
+		const documentState = document.state.document;
+		if (documentState.isDeleted) return buildErrorResult(job, new DocumentDeletedError(documentId, documentState.deletedAtUtcIso), startTime);
+		const nextIndex = getNextIndexForScope(document, job.scope);
+		let upgradePath;
+		if (fromVersion > 0 && fromVersion < toVersion) try {
+			upgradePath = this.registry.computeUpgradePath(document.header.documentType, fromVersion, toVersion);
+		} catch (error) {
+			return buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
+		}
+		if (fromVersion === toVersion && fromVersion > 0) return {
+			job,
+			success: true,
+			operations: [],
+			operationsWithContext: [],
+			duration: Date.now() - startTime
+		};
+		try {
+			document = applyUpgradeDocumentAction(document, action, upgradePath);
+		} catch (error) {
+			return buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
+		}
+		let operation = createOperation(action, nextIndex, skip, {
+			documentId,
+			scope: job.scope,
+			branch: job.branch
+		});
+		const resultingStateObj = {
+			header: document.header,
+			...document.state
+		};
+		const resultingState = JSON.stringify(resultingStateObj);
+		const writeResult = await this.writeOperationToStore(documentId, document.header.documentType, job.scope, job.branch, operation, job, startTime, stores, signal);
+		if (!Array.isArray(writeResult)) return writeResult;
+		operation = writeResult[0];
+		updateDocumentRevision(document, job.scope, operation.index);
+		document.operations = {
+			...document.operations,
+			[job.scope]: [...document.operations[job.scope] ?? [], operation]
+		};
+		stores.writeCache.putState(documentId, job.scope, job.branch, operation.index, document);
+		indexTxn.write([{
+			...operation,
+			documentId,
+			documentType: document.header.documentType,
+			branch: job.branch,
+			scope: job.scope,
+			sourceRemote
+		}]);
+		stores.documentMetaCache.putDocumentMeta(documentId, job.branch, {
+			state: document.state.document,
+			documentType: document.header.documentType,
+			documentScopeRevision: operation.index + 1
+		});
+		return buildSuccessResult(job, operation, documentId, document.header.documentType, resultingState, startTime);
+	}
+	executeAddRelationship(job, action, startTime, indexTxn, stores, sourceRemote = "", signal) {
+		return this.withRelationshipAction("ADD_RELATIONSHIP", job, action, startTime, indexTxn, stores, sourceRemote, signal, (input) => input.sourceId === input.targetId ? /* @__PURE__ */ new Error("ADD_RELATIONSHIP: sourceId and targetId cannot be the same (self-relationships not allowed)") : null, ({ indexTxn: txn, stores: s, sourceDoc, input, job: j }) => {
+			if (this.driveContainerTypes.has(sourceDoc.header.documentType)) {
+				const collectionId = driveCollectionId(j.branch, input.sourceId);
+				txn.addToCollection(collectionId, input.targetId);
+				s.collectionMembershipCache.invalidate(input.targetId);
+			}
+		});
+	}
+	executeRemoveRelationship(job, action, startTime, indexTxn, stores, sourceRemote = "", signal) {
+		return this.withRelationshipAction("REMOVE_RELATIONSHIP", job, action, startTime, indexTxn, stores, sourceRemote, signal, null, ({ indexTxn: txn, stores: s, sourceDoc, input, job: j }) => {
+			if (this.driveContainerTypes.has(sourceDoc.header.documentType)) {
+				const collectionId = driveCollectionId(j.branch, input.sourceId);
+				txn.removeFromCollection(collectionId, input.targetId);
+				s.collectionMembershipCache.invalidate(input.targetId);
+			}
+		});
+	}
+	executeUpdateRelationship(job, action, startTime, indexTxn, stores, sourceRemote = "", signal) {
+		return this.withRelationshipAction("UPDATE_RELATIONSHIP", job, action, startTime, indexTxn, stores, sourceRemote, signal, null, null);
+	}
+	async withRelationshipAction(actionTypeName, job, action, startTime, indexTxn, stores, sourceRemote, signal, preValidate, postWrite) {
+		if (job.scope !== "document") return buildErrorResult(job, /* @__PURE__ */ new Error(`${actionTypeName} must be in "document" scope, got "${job.scope}"`), startTime);
+		const input = action.input;
+		if (!input.sourceId || !input.targetId || !input.relationshipType) return buildErrorResult(job, /* @__PURE__ */ new Error(`${actionTypeName} action requires sourceId, targetId, and relationshipType in input`), startTime);
+		if (preValidate !== null) {
+			const validationError = preValidate(input);
+			if (validationError !== null) return buildErrorResult(job, validationError, startTime);
+		}
+		let sourceDoc;
+		try {
+			sourceDoc = await stores.writeCache.getState(input.sourceId, "document", job.branch, void 0, signal);
+		} catch (error) {
+			return buildErrorResult(job, /* @__PURE__ */ new Error(`${actionTypeName}: source document ${input.sourceId} not found: ${error instanceof Error ? error.message : String(error)}`), startTime);
+		}
+		let operation = createOperation(action, getNextIndexForScope(sourceDoc, job.scope), 0, {
+			documentId: input.sourceId,
+			scope: job.scope,
+			branch: job.branch
+		});
+		const writeResult = await this.writeOperationToStore(input.sourceId, sourceDoc.header.documentType, job.scope, job.branch, operation, job, startTime, stores, signal);
+		if (!Array.isArray(writeResult)) return writeResult;
+		operation = writeResult[0];
+		sourceDoc.header.lastModifiedAtUtcIso = operation.timestampUtcMs || (/* @__PURE__ */ new Date()).toISOString();
+		updateDocumentRevision(sourceDoc, job.scope, operation.index);
+		sourceDoc.operations = {
+			...sourceDoc.operations,
+			[job.scope]: [...sourceDoc.operations[job.scope] ?? [], operation]
+		};
+		const scopeState = sourceDoc.state[job.scope];
+		const resultingStateObj = {
+			header: structuredClone(sourceDoc.header),
+			[job.scope]: scopeState === void 0 ? {} : structuredClone(scopeState)
+		};
+		const resultingState = JSON.stringify(resultingStateObj);
+		stores.writeCache.putState(input.sourceId, job.scope, job.branch, operation.index, sourceDoc);
+		indexTxn.write([{
+			...operation,
+			documentId: input.sourceId,
+			documentType: sourceDoc.header.documentType,
+			branch: job.branch,
+			scope: job.scope,
+			sourceRemote
+		}]);
+		if (postWrite !== null) postWrite({
+			indexTxn,
+			stores,
+			sourceDoc,
+			input,
+			job
+		});
+		stores.documentMetaCache.putDocumentMeta(input.sourceId, job.branch, {
+			state: sourceDoc.state.document,
+			documentType: sourceDoc.header.documentType,
+			documentScopeRevision: operation.index + 1
+		});
+		return buildSuccessResult(job, operation, input.sourceId, sourceDoc.header.documentType, resultingState, startTime);
+	}
+	async writeOperationToStore(documentId, documentType, scope, branch, operation, job, startTime, stores, signal) {
+		let storedOperations;
+		try {
+			storedOperations = await stores.operationStore.apply(documentId, documentType, scope, branch, operation.index, (txn) => {
+				txn.addOperations(operation);
+			}, signal);
+		} catch (error) {
+			this.logger.error("Error writing @Operation to IOperationStore: @Error", operation, error);
+			stores.writeCache.invalidate(documentId, scope, branch);
+			return {
+				job,
+				success: false,
+				error: /* @__PURE__ */ new Error(`Failed to write operation to IOperationStore: ${error instanceof Error ? error.message : String(error)}`),
+				duration: Date.now() - startTime
+			};
+		}
+		return storedOperations;
+	}
+};
+//#endregion
+//#region src/executor/signature-verifier.ts
+var SignatureVerifier = class {
+	constructor(verifier) {
+		this.verifier = verifier;
+	}
+	async verifyActions(documentId, branch, actions) {
+		if (!this.verifier) return;
+		for (const action of actions) {
+			const signer = action.context?.signer;
+			if (!signer) continue;
+			if (signer.signatures.length === 0) throw new InvalidSignatureError(documentId, `Action ${action.id} has signer but no signatures`);
+			const publicKey = signer.app.key;
+			let isValid;
+			try {
+				const tempOperation = {
+					id: deriveOperationId(documentId, action.scope, branch, action.id),
+					index: 0,
+					timestampUtcMs: action.timestampUtcMs || (/* @__PURE__ */ new Date()).toISOString(),
+					hash: "",
+					skip: 0,
+					action
+				};
+				isValid = await this.verifier(tempOperation, publicKey);
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				throw new InvalidSignatureError(documentId, `Action ${action.id} verification failed: ${errorMessage}`);
+			}
+			if (!isValid) throw new InvalidSignatureError(documentId, `Action ${action.id} signature verification returned false`);
+		}
+	}
+	async verifyOperations(documentId, operations) {
+		if (!this.verifier) return;
+		for (let i = 0; i < operations.length; i++) {
+			const operation = operations[i];
+			const signer = operation.action.context?.signer;
+			if (!signer) continue;
+			if (signer.signatures.length === 0) throw new InvalidSignatureError(documentId, `Operation ${operation.id} at index ${operation.index} has signer but no signatures`);
+			const publicKey = signer.app.key;
+			let isValid;
+			try {
+				isValid = await this.verifier(operation, publicKey);
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				throw new InvalidSignatureError(documentId, `Operation ${operation.id} at index ${operation.index} verification failed: ${errorMessage}`);
+			}
+			if (!isValid) throw new InvalidSignatureError(documentId, `Operation ${operation.id} at index ${operation.index} signature verification returned false`);
+		}
+	}
+};
+//#endregion
+//#region src/executor/simple-job-executor.ts
+const MAX_SKIP_THRESHOLD = 1e3;
+const ISO_TIMESTAMP_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
+function isValidISOTimestamp(value) {
+	if (!ISO_TIMESTAMP_REGEX.test(value)) return false;
+	return !isNaN(new Date(value).getTime());
+}
+const documentScopeActions = [
+	"CREATE_DOCUMENT",
+	"DELETE_DOCUMENT",
+	"UPGRADE_DOCUMENT",
+	"ADD_RELATIONSHIP",
+	"REMOVE_RELATIONSHIP",
+	"UPDATE_RELATIONSHIP"
+];
+/**
+* Simple job executor that processes a job by applying actions through document model reducers.
+*/
+var SimpleJobExecutor = class {
+	config;
+	signatureVerifierModule;
+	documentActionHandler;
+	executionScope;
+	constructor(logger, registry, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, collectionMembershipCache, driveContainerTypes, config, signatureVerifier, executionScope) {
+		this.logger = logger;
+		this.registry = registry;
+		this.operationStore = operationStore;
+		this.eventBus = eventBus;
+		this.writeCache = writeCache;
+		this.operationIndex = operationIndex;
+		this.documentMetaCache = documentMetaCache;
+		this.collectionMembershipCache = collectionMembershipCache;
+		this.driveContainerTypes = driveContainerTypes;
+		this.config = {
+			maxSkipThreshold: config.maxSkipThreshold ?? MAX_SKIP_THRESHOLD,
+			maxConcurrency: config.maxConcurrency ?? 1,
+			jobTimeoutMs: config.jobTimeoutMs ?? 3e4,
+			retryBaseDelayMs: config.retryBaseDelayMs ?? 100,
+			retryMaxDelayMs: config.retryMaxDelayMs ?? 5e3,
+			yieldDeadlineMs: config.yieldDeadlineMs ?? 50
+		};
+		this.signatureVerifierModule = new SignatureVerifier(signatureVerifier);
+		this.documentActionHandler = new DocumentActionHandler(registry, logger, driveContainerTypes);
+		this.executionScope = executionScope ?? new DefaultExecutionScope(operationStore, operationIndex, writeCache, documentMetaCache, collectionMembershipCache);
+	}
+	/**
+	* Execute a single job by applying all its actions through the appropriate reducers.
+	* Actions are processed sequentially in order.
+	*/
+	async executeJob(job, signal) {
+		const startTime = Date.now();
+		const touchedCacheEntries = [];
+		let pendingEvent;
+		let result;
+		try {
+			result = await this.executionScope.run(async (stores) => {
+				const indexTxn = stores.operationIndex.start();
+				if (job.kind === "load") {
+					const loadResult = await this.executeLoadJob(job, startTime, indexTxn, stores, signal);
+					if (loadResult.success && loadResult.operationsWithContext) {
+						for (const owc of loadResult.operationsWithContext) touchedCacheEntries.push({
+							documentId: owc.context.documentId,
+							scope: owc.context.scope,
+							branch: owc.context.branch
+						});
+						const ordinals = await stores.operationIndex.commit(indexTxn, signal);
+						for (let i = 0; i < loadResult.operationsWithContext.length; i++) loadResult.operationsWithContext[i].context.ordinal = ordinals[i];
+						const collectionMemberships = loadResult.operationsWithContext.length > 0 ? await this.getCollectionMembershipsForOperations(loadResult.operationsWithContext, stores) : {};
+						pendingEvent = {
+							jobId: job.id,
+							operations: loadResult.operationsWithContext,
+							jobMeta: job.meta,
+							collectionMemberships
+						};
+					}
+					return loadResult;
+				}
+				const actionResult = await this.processActions(job, job.actions, startTime, indexTxn, stores, void 0, void 0, "", signal);
+				if (!actionResult.success) return {
+					job,
+					success: false,
+					error: actionResult.error,
+					duration: Date.now() - startTime
+				};
+				if (actionResult.operationsWithContext.length > 0) for (const owc of actionResult.operationsWithContext) touchedCacheEntries.push({
+					documentId: owc.context.documentId,
+					scope: owc.context.scope,
+					branch: owc.context.branch
+				});
+				const ordinals = await stores.operationIndex.commit(indexTxn, signal);
+				if (actionResult.operationsWithContext.length > 0) {
+					for (let i = 0; i < actionResult.operationsWithContext.length; i++) actionResult.operationsWithContext[i].context.ordinal = ordinals[i];
+					const collectionMemberships = await this.getCollectionMembershipsForOperations(actionResult.operationsWithContext, stores);
+					pendingEvent = {
+						jobId: job.id,
+						operations: actionResult.operationsWithContext,
+						jobMeta: job.meta,
+						collectionMemberships
+					};
+				}
+				return {
+					job,
+					success: true,
+					operations: actionResult.generatedOperations,
+					operationsWithContext: actionResult.operationsWithContext,
+					duration: Date.now() - startTime
+				};
+			}, signal);
+		} catch (error) {
+			for (const entry of touchedCacheEntries) {
+				this.writeCache.invalidate(entry.documentId, entry.scope, entry.branch);
+				this.documentMetaCache.invalidate(entry.documentId, entry.branch);
+			}
+			throw error;
+		}
+		if (pendingEvent) this.eventBus.emit(ReactorEventTypes.JOB_WRITE_READY, pendingEvent).catch((error) => {
+			this.logger.error("Failed to emit JOB_WRITE_READY event: @Event : @Error", pendingEvent, error);
+		});
+		return result;
+	}
+	async getCollectionMembershipsForOperations(operations, stores) {
+		const documentIds = [...new Set(operations.map((op) => op.context.documentId))];
+		return stores.collectionMembershipCache.getCollectionsForDocuments(documentIds);
+	}
+	async processActions(job, actions, startTime, indexTxn, stores, skipValues, sourceOperations, sourceRemote = "", signal) {
+		const generatedOperations = [];
+		const operationsWithContext = [];
+		try {
+			await this.signatureVerifierModule.verifyActions(job.documentId, job.branch, actions);
+		} catch (error) {
+			return {
+				success: false,
+				generatedOperations,
+				operationsWithContext,
+				error: error instanceof Error ? error : new Error(String(error))
+			};
+		}
+		for (const action of actions) if (action.timestampUtcMs && !isValidISOTimestamp(action.timestampUtcMs)) return {
+			success: false,
+			generatedOperations,
+			operationsWithContext,
+			error: /* @__PURE__ */ new Error(`Invalid timestamp "${action.timestampUtcMs}" on action ${action.type} (id: ${action.id})`)
+		};
+		let lastYield = performance.now();
+		for (let actionIndex = 0; actionIndex < actions.length; actionIndex++) {
+			const action = actions[actionIndex];
+			const skip = skipValues?.[actionIndex] ?? 0;
+			const sourceOperation = sourceOperations?.[actionIndex];
+			const result = documentScopeActions.includes(action.type) ? await this.documentActionHandler.execute(job, action, startTime, indexTxn, stores, skip, sourceRemote, signal) : await this.executeRegularAction(job, action, startTime, indexTxn, stores, skip, sourceOperation, sourceRemote, signal);
+			const error = this.accumulateResultOrReturnError(result, generatedOperations, operationsWithContext);
+			if (error !== null) return {
+				success: false,
+				generatedOperations,
+				operationsWithContext,
+				error: error.error
+			};
+			if (performance.now() - lastYield > this.config.yieldDeadlineMs) {
+				await yieldToMain();
+				lastYield = performance.now();
+				if (signal?.aborted) return {
+					success: false,
+					generatedOperations,
+					operationsWithContext,
+					error: /* @__PURE__ */ new Error("Aborted")
+				};
+			}
+		}
+		return {
+			success: true,
+			generatedOperations,
+			operationsWithContext
+		};
+	}
+	async executeRegularAction(job, action, startTime, indexTxn, stores, skip = 0, sourceOperation, sourceRemote = "", signal) {
+		let docMeta;
+		try {
+			docMeta = await stores.documentMetaCache.getDocumentMeta(job.documentId, job.branch, signal);
+		} catch (error) {
+			return buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
+		}
+		if (docMeta.state.isDeleted) return buildErrorResult(job, new DocumentDeletedError(job.documentId, docMeta.state.deletedAtUtcIso), startTime);
+		if (isUndoRedo(action) || action.type === "PRUNE" || action.type === "NOOP" && skip > 0) stores.writeCache.invalidate(job.documentId, job.scope, job.branch);
+		let document;
+		try {
+			document = await stores.writeCache.getState(job.documentId, job.scope, job.branch, void 0, signal);
+		} catch (error) {
+			return buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
+		}
+		let module;
+		try {
+			const moduleVersion = docMeta.state.version === 0 ? void 0 : docMeta.state.version;
+			module = this.registry.getModule(document.header.documentType, moduleVersion);
+		} catch (error) {
+			return buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
+		}
+		let updatedDocument;
+		try {
+			const protocolVersion = document.header.protocolVersions?.["base-reducer"] ?? 1;
+			const reducerOptions = sourceOperation ? {
+				skip,
+				branch: job.branch,
+				replayOptions: { operation: sourceOperation },
+				protocolVersion
+			} : {
+				skip,
+				branch: job.branch,
+				protocolVersion
+			};
+			updatedDocument = module.reducer(document, action, void 0, reducerOptions);
+		} catch (error) {
+			const contextMessage = `Failed to apply action to document:\n  Action type: ${action.type}\n  Document ID: ${job.documentId}\n  Document type: ${document.header.documentType}\n  Scope: ${job.scope}\n  Original error: ${error instanceof Error ? error.message : String(error)}`;
+			const enhancedError = new Error(contextMessage);
+			if (error instanceof Error && error.stack) enhancedError.stack = `${contextMessage}\n\nOriginal stack trace:\n${error.stack}`;
+			return buildErrorResult(job, enhancedError, startTime);
+		}
+		const scope = job.scope;
+		const operations = updatedDocument.operations[scope];
+		if (operations.length === 0) return buildErrorResult(job, /* @__PURE__ */ new Error("No operation generated from action"), startTime);
+		const newOperation = operations[operations.length - 1];
+		if (!isUndoRedo(action)) newOperation.skip = skip;
+		const resultingState = JSON.stringify({
+			...updatedDocument.state,
+			header: updatedDocument.header
+		});
+		let storedOperations;
+		try {
+			storedOperations = await stores.operationStore.apply(job.documentId, document.header.documentType, scope, job.branch, newOperation.index, (txn) => {
+				txn.addOperations(newOperation);
+			}, signal);
+		} catch (error) {
+			this.logger.error("Error writing @Operation to IOperationStore: @Error", newOperation, error);
+			stores.writeCache.invalidate(job.documentId, scope, job.branch);
+			return {
+				job,
+				success: false,
+				error: /* @__PURE__ */ new Error(`Failed to write operation to IOperationStore: ${error instanceof Error ? error.message : String(error)}`),
+				duration: Date.now() - startTime
+			};
+		}
+		const storedOperation = storedOperations[0];
+		updatedDocument.header.revision = {
+			...updatedDocument.header.revision,
+			[scope]: storedOperation.index + 1
+		};
+		stores.writeCache.putState(job.documentId, scope, job.branch, storedOperation.index, updatedDocument);
+		indexTxn.write([{
+			...storedOperation,
+			documentId: job.documentId,
+			documentType: document.header.documentType,
+			branch: job.branch,
+			scope,
+			sourceRemote
+		}]);
+		return {
+			job,
+			success: true,
+			operations: [storedOperation],
+			operationsWithContext: [{
+				operation: storedOperation,
+				context: {
+					documentId: job.documentId,
+					scope,
+					branch: job.branch,
+					documentType: document.header.documentType,
+					resultingState,
+					ordinal: 0
+				}
+			}],
+			duration: Date.now() - startTime
+		};
+	}
+	async executeLoadJob(job, startTime, indexTxn, stores, signal) {
+		if (job.operations.length === 0) return buildErrorResult(job, /* @__PURE__ */ new Error("Load job must include at least one operation"), startTime);
+		let docMeta;
+		try {
+			docMeta = await stores.documentMetaCache.getDocumentMeta(job.documentId, job.branch, signal);
+		} catch {}
+		if (docMeta?.state.isDeleted) return buildErrorResult(job, new DocumentDeletedError(job.documentId, docMeta.state.deletedAtUtcIso), startTime);
+		const scope = job.scope;
+		let latestRevision;
+		try {
+			latestRevision = (await stores.operationStore.getRevisions(job.documentId, job.branch, signal)).revision[scope] ?? 0;
+		} catch {
+			latestRevision = 0;
+		}
+		for (const operation of job.operations) if (operation.timestampUtcMs && !isValidISOTimestamp(operation.timestampUtcMs)) return {
+			job,
+			success: false,
+			error: /* @__PURE__ */ new Error(`Invalid timestamp "${operation.timestampUtcMs}" on operation (index: ${operation.index})`),
+			duration: Date.now() - startTime
+		};
+		let minIncomingIndex = Number.POSITIVE_INFINITY;
+		let minIncomingTimestamp = job.operations[0]?.timestampUtcMs || "";
+		for (const operation of job.operations) {
+			minIncomingIndex = Math.min(minIncomingIndex, operation.index);
+			const ts = operation.timestampUtcMs || "";
+			if (ts < minIncomingTimestamp) minIncomingTimestamp = ts;
+		}
+		let conflictingOps;
+		try {
+			conflictingOps = (await stores.operationStore.getConflicting(job.documentId, scope, job.branch, minIncomingTimestamp, void 0, signal)).results;
+		} catch {
+			conflictingOps = [];
+		}
+		let allOpsFromMinConflictingIndex = conflictingOps;
+		if (conflictingOps.length > 0) {
+			const minConflictingIndex = Math.min(...conflictingOps.map((op) => op.index));
+			try {
+				allOpsFromMinConflictingIndex = (await stores.operationStore.getSince(job.documentId, scope, job.branch, minConflictingIndex - 1, void 0, void 0, signal)).results;
+			} catch {
+				allOpsFromMinConflictingIndex = conflictingOps;
+			}
+		}
+		const incomingActionIds = new Set(job.operations.map((op) => op.action.id));
+		const nonSupersededOps = conflictingOps.filter((op) => {
+			if (op.index < minIncomingIndex && !incomingActionIds.has(op.action.id)) return false;
+			for (const laterOp of allOpsFromMinConflictingIndex) if (laterOp.index > op.index && laterOp.skip > 0) {
+				if (laterOp.index - laterOp.skip <= op.index) return false;
+			}
+			return true;
+		});
+		const existingOpsToReshuffle = nonSupersededOps;
+		if (existingOpsToReshuffle.length > this.config.maxSkipThreshold) return {
+			job,
+			success: false,
+			error: /* @__PURE__ */ new Error(`Excessive reshuffle detected: existing op count of ${existingOpsToReshuffle.length} exceeds threshold of ${this.config.maxSkipThreshold}. This indicates a significant divergence between local and incoming operations.`),
+			duration: Date.now() - startTime
+		};
+		let skipCount = existingOpsToReshuffle.length;
+		if (existingOpsToReshuffle.length > 0) {
+			let minLogicalIndex = Number.POSITIVE_INFINITY;
+			for (const op of existingOpsToReshuffle) {
+				const logical = op.index - op.skip;
+				if (logical < minLogicalIndex) minLogicalIndex = logical;
+			}
+			const logicalSkip = latestRevision - minLogicalIndex;
+			if (logicalSkip > skipCount) skipCount = logicalSkip;
+		}
+		const existingActionIds = new Set(nonSupersededOps.map((op) => op.action.id));
+		const seenIncomingActionIds = /* @__PURE__ */ new Set();
+		const incomingOpsToApply = job.operations.filter((op) => {
+			if (existingActionIds.has(op.action.id)) return false;
+			if (seenIncomingActionIds.has(op.action.id)) return false;
+			seenIncomingActionIds.add(op.action.id);
+			return true;
+		});
+		if (incomingOpsToApply.length === 0) return {
+			job,
+			success: true,
+			operations: [],
+			operationsWithContext: [],
+			duration: Date.now() - startTime
+		};
+		const reshuffledOperations = existingOpsToReshuffle.length === 0 && skipCount === 0 ? incomingOpsToApply.slice().sort((a, b) => a.index - b.index).map((operation, i) => ({
+			...operation,
+			index: latestRevision + i
+		})) : reshuffleByTimestamp({
+			index: latestRevision,
+			skip: skipCount
+		}, existingOpsToReshuffle, incomingOpsToApply.map((operation) => ({
+			...operation,
+			id: operation.id
+		})));
+		for (const operation of reshuffledOperations) if (operation.action.type === "NOOP") operation.skip = 1;
+		const actions = reshuffledOperations.map((operation) => operation.action);
+		const skipValues = reshuffledOperations.map((operation) => operation.skip);
+		const effectiveSourceRemote = skipCount > 0 ? "" : job.meta.sourceRemote || "";
+		const result = await this.processActions(job, actions, startTime, indexTxn, stores, skipValues, reshuffledOperations, effectiveSourceRemote, signal);
+		if (!result.success) return {
+			job,
+			success: false,
+			error: result.error,
+			duration: Date.now() - startTime
+		};
+		stores.writeCache.invalidate(job.documentId, scope, job.branch);
+		if (scope === "document") stores.documentMetaCache.invalidate(job.documentId, job.branch);
+		return {
+			job,
+			success: true,
+			operations: result.generatedOperations,
+			operationsWithContext: result.operationsWithContext,
+			duration: Date.now() - startTime
+		};
+	}
+	accumulateResultOrReturnError(result, generatedOperations, operationsWithContext) {
+		if (!result.success) return result;
+		if (result.operations && result.operations.length > 0) generatedOperations.push(...result.operations);
+		if (result.operationsWithContext) operationsWithContext.push(...result.operationsWithContext);
+		return null;
+	}
+};
+//#endregion
+//#region src/registry/implementation.ts
+/**
+* In-memory implementation of the IDocumentModelRegistry interface.
+* Manages document model modules with version-aware storage and upgrade manifest support.
+*/
+var DocumentModelRegistry = class {
+	modules = [];
+	manifests = [];
+	registerModules(...modules) {
+		return modules.map((module) => {
+			try {
+				const documentType = module.documentModel.global.id;
+				const version = module.version ?? 1;
+				for (let i = 0; i < this.modules.length; i++) {
+					const existing = this.modules[i];
+					const existingType = existing.documentModel.global.id;
+					const existingVersion = existing.version ?? 1;
+					if (existingType === documentType && existingVersion === version) throw new DuplicateModuleError(documentType, version);
+				}
+				this.modules.push(module);
+				return {
+					status: "success",
+					item: module
+				};
+			} catch (error) {
+				return {
+					status: "error",
+					item: module,
+					error: error instanceof Error ? error : new Error(String(error))
+				};
+			}
+		});
+	}
+	unregisterModules(...documentTypes) {
+		let allFound = true;
+		for (const documentType of documentTypes) {
+			if (!this.modules.some((m) => m.documentModel.global.id === documentType)) allFound = false;
+			this.modules = this.modules.filter((m) => m.documentModel.global.id !== documentType);
+		}
+		return allFound;
+	}
+	getModule(documentType, version) {
+		let latestModule;
+		let latestVersion = -1;
+		for (let i = 0; i < this.modules.length; i++) {
+			const module = this.modules[i];
+			const moduleType = module.documentModel.global.id;
+			const moduleVersion = module.version ?? 1;
+			if (moduleType === documentType) {
+				if (version !== void 0 && moduleVersion === version) return module;
+				if (moduleVersion > latestVersion) {
+					latestModule = module;
+					latestVersion = moduleVersion;
+				}
+			}
+		}
+		if (version === void 0 && latestModule !== void 0) return latestModule;
+		throw new ModuleNotFoundError(documentType, version);
+	}
+	getAllModules() {
+		return [...this.modules];
+	}
+	clear() {
+		this.modules = [];
+		this.manifests = [];
+	}
+	getSupportedVersions(documentType) {
+		const versions = [];
+		for (const module of this.modules) if (module.documentModel.global.id === documentType) versions.push(module.version ?? 1);
+		if (versions.length === 0) throw new ModuleNotFoundError(documentType);
+		return versions.sort((a, b) => a - b);
+	}
+	getLatestVersion(documentType) {
+		let latest = -1;
+		let found = false;
+		for (const module of this.modules) if (module.documentModel.global.id === documentType) {
+			found = true;
+			const version = module.version ?? 1;
+			if (version > latest) latest = version;
+		}
+		if (!found) throw new ModuleNotFoundError(documentType);
+		return latest;
+	}
+	registerUpgradeManifests(...manifestsToRegister) {
+		return manifestsToRegister.map((manifestToRegister) => {
+			try {
+				if (!manifestToRegister.documentType) throw new Error("Upgrade manifest is missing a documentType");
+				for (const registeredManifest of this.manifests) if (registeredManifest.documentType === manifestToRegister.documentType) throw new DuplicateManifestError(manifestToRegister.documentType);
+				this.manifests.push(manifestToRegister);
+				return {
+					status: "success",
+					item: manifestToRegister
+				};
+			} catch (error) {
+				return {
+					status: "error",
+					item: manifestToRegister,
+					error: error instanceof Error ? error : new Error(String(error))
+				};
+			}
+		});
+	}
+	unregisterUpgradeManifests(...documentTypes) {
+		let allFound = true;
+		for (const documentType of documentTypes) {
+			if (!this.manifests.some((m) => m.documentType === documentType)) allFound = false;
+			this.manifests = this.manifests.filter((m) => m.documentType !== documentType);
+		}
+		return allFound;
+	}
+	getUpgradeManifest(documentType) {
+		for (let i = 0; i < this.manifests.length; i++) if (this.manifests[i].documentType === documentType) return this.manifests[i];
+		throw new ManifestNotFoundError(documentType);
+	}
+	computeUpgradePath(documentType, fromVersion, toVersion) {
+		if (fromVersion === toVersion) return [];
+		if (toVersion < fromVersion) throw new DowngradeNotSupportedError(documentType, fromVersion, toVersion);
+		const manifest = this.getUpgradeManifest(documentType);
+		const path = [];
+		for (let v = fromVersion + 1; v <= toVersion; v++) {
+			const key = `v${v}`;
+			if (!(key in manifest.upgrades)) throw new MissingUpgradeTransitionError(documentType, v - 1, v);
+			const transition = manifest.upgrades[key];
+			path.push(transition);
+		}
+		return path;
+	}
+	getUpgradeReducer(documentType, fromVersion, toVersion) {
+		if (toVersion !== fromVersion + 1) throw new InvalidUpgradeStepError(documentType, fromVersion, toVersion);
+		const manifest = this.getUpgradeManifest(documentType);
+		const key = `v${toVersion}`;
+		if (!(key in manifest.upgrades)) throw new MissingUpgradeTransitionError(documentType, fromVersion, toVersion);
+		return manifest.upgrades[key].upgradeReducer;
+	}
+};
+//#endregion
+//#region src/storage/kysely/keyframe-store.ts
+var KyselyKeyframeStore = class KyselyKeyframeStore {
+	trx;
+	constructor(db) {
+		this.db = db;
+	}
+	get queryExecutor() {
+		return this.trx ?? this.db;
+	}
+	withTransaction(trx) {
+		const instance = new KyselyKeyframeStore(this.db);
+		instance.trx = trx;
+		return instance;
+	}
+	async putKeyframe(documentId, scope, branch, revision, document, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		await this.queryExecutor.insertInto("Keyframe").values({
+			documentId,
+			documentType: document.header.documentType,
+			scope,
+			branch,
+			revision,
+			document
+		}).onConflict((oc) => oc.columns([
+			"documentId",
+			"scope",
+			"branch",
+			"revision"
+		]).doUpdateSet({ document })).execute();
+	}
+	async findNearestKeyframe(documentId, scope, branch, targetRevision, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const row = await this.queryExecutor.selectFrom("Keyframe").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("revision", "<=", targetRevision).orderBy("revision", "desc").limit(1).executeTakeFirst();
+		if (!row) return;
+		return {
+			revision: row.revision,
+			document: row.document
+		};
+	}
+	async listKeyframes(documentId, scope, branch, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		let query = this.queryExecutor.selectFrom("Keyframe").selectAll().where("documentId", "=", documentId).orderBy("revision", "asc");
+		if (scope !== void 0) query = query.where("scope", "=", scope);
+		if (branch !== void 0) query = query.where("branch", "=", branch);
+		return (await query.execute()).map((row) => ({
+			scope: row.scope,
+			branch: row.branch,
+			revision: row.revision,
+			document: row.document
+		}));
+	}
+	async deleteKeyframes(documentId, scope, branch, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		let query = this.queryExecutor.deleteFrom("Keyframe").where("documentId", "=", documentId);
+		if (scope !== void 0 && branch !== void 0) query = query.where("scope", "=", scope).where("branch", "=", branch);
+		else if (scope !== void 0) query = query.where("scope", "=", scope);
+		const result = await query.executeTakeFirst();
+		return Number(result.numDeletedRows || 0n);
+	}
+};
+//#endregion
+//#region src/storage/kysely/pagination.ts
+const DEFAULT_LIMIT = 100;
+function paginateRows(rows, paging, cursorOf, toItem, refetch) {
+	let hasMore = false;
+	let items = rows;
+	if (paging?.limit && rows.length > paging.limit) {
+		hasMore = true;
+		items = rows.slice(0, paging.limit);
+	}
+	const nextCursor = hasMore && items.length > 0 ? cursorOf(items[items.length - 1]).toString() : void 0;
+	const cursor = paging?.cursor || "0";
+	const limit = paging?.limit || DEFAULT_LIMIT;
+	return {
+		results: items.map(toItem),
+		options: {
+			cursor,
+			limit
+		},
+		nextCursor,
+		next: hasMore ? () => refetch(nextCursor, limit) : void 0
+	};
+}
+//#endregion
+//#region src/storage/interfaces.ts
+/**
+* Thrown when an operation with the same identity already exists in the store.
+*/
+var DuplicateOperationError = class extends Error {
+	constructor(description) {
+		super(`Duplicate operation: ${description}`);
+		this.name = "DuplicateOperationError";
+	}
+};
+/**
+* Thrown when a concurrent write conflict is detected during an atomic apply.
+*/
+var OptimisticLockError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OptimisticLockError";
+	}
+};
+/**
+* Thrown when the caller-provided revision does not match the current
+* stored revision, indicating a stale read.
+*/
+var RevisionMismatchError = class extends Error {
+	constructor(expected, actual) {
+		super(`Revision mismatch: expected ${expected}, got ${actual}`);
+		this.name = "RevisionMismatchError";
+	}
+};
+//#endregion
+//#region src/storage/txn.ts
+var AtomicTransaction = class {
+	operations = [];
+	constructor(documentId, documentType, scope, branch, baseRevision) {
+		this.documentId = documentId;
+		this.documentType = documentType;
+		this.scope = scope;
+		this.branch = branch;
+		this.baseRevision = baseRevision;
+	}
+	addOperations(...operations) {
+		for (const op of operations) this.operations.push({
+			jobId: v4(),
+			opId: op.id,
+			prevOpId: "",
+			documentId: this.documentId,
+			documentType: this.documentType,
+			scope: this.scope,
+			branch: this.branch,
+			timestampUtcMs: new Date(op.timestampUtcMs),
+			index: op.index,
+			action: JSON.stringify(op.action),
+			skip: op.skip,
+			error: op.error || null,
+			hash: op.hash
+		});
+	}
+	getOperations() {
+		return this.operations;
+	}
+};
+//#endregion
+//#region src/storage/kysely/store.ts
+var _UniqueConstraintContext = class extends Error {
+	constructor(documentId, scope, branch, revision, stagedOps) {
+		super("unique constraint");
+		this.documentId = documentId;
+		this.scope = scope;
+		this.branch = branch;
+		this.revision = revision;
+		this.stagedOps = stagedOps;
+		this.name = "UniqueConstraintContext";
+	}
+};
+var KyselyOperationStore = class KyselyOperationStore {
+	trx;
+	constructor(db) {
+		this.db = db;
+	}
+	get queryExecutor() {
+		return this.trx ?? this.db;
+	}
+	withTransaction(trx) {
+		const instance = new KyselyOperationStore(this.db);
+		instance.trx = trx;
+		return instance;
+	}
+	async apply(documentId, documentType, scope, branch, revision, fn, signal) {
+		if (this.trx) {
+			let executeResult = null;
+			let uniqueCtx = null;
+			try {
+				executeResult = await this.executeApply(this.trx, documentId, documentType, scope, branch, revision, fn, signal);
+			} catch (error) {
+				if (error instanceof _UniqueConstraintContext) uniqueCtx = error;
+				else throw error;
+			}
+			if (uniqueCtx !== null) return this.resolveUniqueConstraint(uniqueCtx);
+			return executeResult;
+		} else {
+			let transactionResult = null;
+			let uniqueCtx = null;
+			try {
+				transactionResult = await this.db.transaction().execute(async (trx) => {
+					return this.executeApply(trx, documentId, documentType, scope, branch, revision, fn, signal);
+				});
+			} catch (error) {
+				if (error instanceof _UniqueConstraintContext) uniqueCtx = error;
+				else throw error;
+			}
+			if (uniqueCtx !== null) return this.resolveUniqueConstraint(uniqueCtx);
+			return transactionResult;
+		}
+	}
+	async resolveUniqueConstraint(ctx) {
+		let replayOps = null;
+		try {
+			replayOps = await this.findIdempotentReplay(this.db, ctx.documentId, ctx.scope, ctx.branch, ctx.revision, ctx.stagedOps);
+		} catch {}
+		if (replayOps !== null) return replayOps;
+		const op = ctx.stagedOps[0];
+		throw new DuplicateOperationError(`${op.opId} at index ${op.index} with skip ${op.skip}`);
+	}
+	async executeApply(trx, documentId, documentType, scope, branch, revision, fn, signal) {
+		throwIfAborted(signal);
+		const atomicTxn = new AtomicTransaction(documentId, documentType, scope, branch, revision);
+		await fn(atomicTxn);
+		const operations = atomicTxn.getOperations();
+		if (operations.length === 0) return [];
+		const latestOp = await trx.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).orderBy("index", "desc").limit(1).executeTakeFirst();
+		const currentRevision = latestOp ? latestOp.index : -1;
+		if (currentRevision !== revision - 1) {
+			let replayOps = null;
+			try {
+				replayOps = await this.findIdempotentReplay(trx, documentId, scope, branch, revision, operations);
+			} catch {}
+			if (replayOps !== null) return replayOps;
+			throw new RevisionMismatchError(currentRevision + 1, revision);
+		}
+		let prevOpId = latestOp?.opId || "";
+		for (const op of operations) {
+			op.prevOpId = prevOpId;
+			prevOpId = op.opId;
+		}
+		try {
+			await trx.insertInto("Operation").values(operations).execute();
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("unique constraint")) throw new _UniqueConstraintContext(documentId, scope, branch, revision, operations);
+			throw error;
+		}
+		return operations.map((op) => ({
+			index: op.index,
+			timestampUtcMs: op.timestampUtcMs.toISOString(),
+			hash: op.hash,
+			skip: op.skip,
+			error: op.error || void 0,
+			id: op.opId,
+			action: JSON.parse(op.action)
+		}));
+	}
+	async findIdempotentReplay(executor, documentId, scope, branch, revision, stagedOps) {
+		const minIndex = revision;
+		const maxIndex = revision + stagedOps.length - 1;
+		const storedRows = await executor.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("index", ">=", minIndex).where("index", "<=", maxIndex).orderBy("index", "asc").execute();
+		if (storedRows.length !== stagedOps.length) return null;
+		for (let i = 0; i < stagedOps.length; i++) {
+			const staged = stagedOps[i];
+			const stored = storedRows[i];
+			if (stored.opId !== staged.opId || stored.index !== staged.index || stored.skip !== staged.skip) return null;
+		}
+		return storedRows.map((row) => this.rowToOperation(row));
+	}
+	async getSince(documentId, scope, branch, revision, filter, paging, signal) {
+		throwIfAborted(signal);
+		let query = this.queryExecutor.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("index", ">", revision).orderBy("index", "asc");
+		if (filter) {
+			if (filter.actionTypes && filter.actionTypes.length > 0) {
+				const actionTypesArray = filter.actionTypes.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
+				query = query.where(sql`action->>'type' = ANY(ARRAY[${sql.raw(actionTypesArray)}]::text[])`);
+			}
+			if (filter.timestampFrom) query = query.where("timestampUtcMs", ">=", new Date(filter.timestampFrom));
+			if (filter.timestampTo) query = query.where("timestampUtcMs", "<=", new Date(filter.timestampTo));
+			if (filter.sinceRevision !== void 0) query = query.where("index", ">=", filter.sinceRevision);
+		}
+		if (paging) {
+			const cursorValue = Number.parseInt(paging.cursor, 10);
+			if (cursorValue > 0) query = query.where("index", ">", cursorValue);
+			if (paging.limit) query = query.limit(paging.limit + 1);
+		}
+		return paginateRows(await query.execute(), paging, (row) => row.index, (row) => this.rowToOperation(row), (cursor, limit) => this.getSince(documentId, scope, branch, revision, filter, {
+			cursor,
+			limit
+		}, signal));
+	}
+	async getSinceId(id, paging, signal) {
+		throwIfAborted(signal);
+		let query = this.queryExecutor.selectFrom("Operation").selectAll().where("id", ">", id).orderBy("id", "asc");
+		if (paging) {
+			const cursorValue = Number.parseInt(paging.cursor, 10);
+			if (cursorValue > 0) query = query.where("id", ">", cursorValue);
+			if (paging.limit) query = query.limit(paging.limit + 1);
+		}
+		return paginateRows(await query.execute(), paging, (row) => row.id, (row) => this.rowToOperationWithContext(row), (cursor, limit) => this.getSinceId(id, {
+			cursor,
+			limit
+		}, signal));
+	}
+	async getConflicting(documentId, scope, branch, minTimestamp, paging, signal) {
+		throwIfAborted(signal);
+		let query = this.queryExecutor.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("timestampUtcMs", ">=", new Date(minTimestamp)).orderBy("index", "asc");
+		if (paging) {
+			const cursorValue = Number.parseInt(paging.cursor, 10);
+			if (cursorValue > 0) query = query.where("index", ">", cursorValue);
+			if (paging.limit) query = query.limit(paging.limit + 1);
+		}
+		return paginateRows(await query.execute(), paging, (row) => row.index, (row) => this.rowToOperation(row), (cursor, limit) => this.getConflicting(documentId, scope, branch, minTimestamp, {
+			cursor,
+			limit
+		}, signal));
+	}
+	async getRevisions(documentId, branch, signal) {
+		throwIfAborted(signal);
+		const scopeRevisions = await this.queryExecutor.selectFrom("Operation as o1").select([
+			"o1.scope",
+			"o1.index",
+			"o1.timestampUtcMs"
+		]).where("o1.documentId", "=", documentId).where("o1.branch", "=", branch).where((eb) => eb("o1.index", "=", eb.selectFrom("Operation as o2").select((eb2) => eb2.fn.max("o2.index").as("maxIndex")).where("o2.documentId", "=", eb.ref("o1.documentId")).where("o2.branch", "=", eb.ref("o1.branch")).where("o2.scope", "=", eb.ref("o1.scope")))).execute();
+		const revision = {};
+		let latestTimestamp = (/* @__PURE__ */ new Date(0)).toISOString();
+		for (const row of scopeRevisions) {
+			revision[row.scope] = row.index + 1;
+			const timestamp = row.timestampUtcMs.toISOString();
+			if (timestamp > latestTimestamp) latestTimestamp = timestamp;
+		}
+		return {
+			revision,
+			latestTimestamp
+		};
+	}
+	rowToOperation(row) {
+		return {
+			index: row.index,
+			timestampUtcMs: row.timestampUtcMs.toISOString(),
+			hash: row.hash,
+			skip: row.skip,
+			error: row.error || void 0,
+			id: row.opId,
+			action: row.action
+		};
+	}
+	rowToOperationWithContext(row) {
+		return {
+			operation: this.rowToOperation(row),
+			context: {
+				documentId: row.documentId,
+				documentType: row.documentType,
+				scope: row.scope,
+				branch: row.branch,
+				ordinal: row.id
+			}
+		};
+	}
+};
+//#endregion
+//#region src/storage/pool-instrumentation.ts
+/**
+* Wraps an existing pg.Pool with acquire-wait timing and an event
+* subscription surface. The pool is mutated in place: pool.connect()
+* is replaced with a timing wrapper so all callers (Kysely included)
+* pick up the instrumentation transparently.
+*/
+function instrumentPgPool(pool, name) {
+	const listeners = /* @__PURE__ */ new Set();
+	const originalConnect = pool.connect.bind(pool);
+	const wrappedConnect = async () => {
+		const start = performance.now();
+		const client = await originalConnect();
+		const durationMs = performance.now() - start;
+		for (const listener of listeners) try {
+			listener(durationMs);
+		} catch {}
+		return client;
+	};
+	pool.connect = wrappedConnect;
+	return {
+		name,
+		getStats() {
+			return {
+				size: pool.totalCount,
+				idle: pool.idleCount,
+				waiting: pool.waitingCount
+			};
+		},
+		onAcquire(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+function createForwardingPoolInstrumentation(name) {
+	const listeners = /* @__PURE__ */ new Set();
+	let stats = {
+		size: 0,
+		idle: 0,
+		waiting: 0
+	};
+	return {
+		name,
+		getStats() {
+			return stats;
+		},
+		onAcquire(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		pushSamples(durations) {
+			for (const durationMs of durations) for (const listener of listeners) try {
+				listener(durationMs);
+			} catch {}
+		},
+		updateStats(next) {
+			stats = next;
+		}
+	};
+}
+//#endregion
+//#region src/storage/migrations/001_create_operation_table.ts
+var _001_create_operation_table_exports = /* @__PURE__ */ __exportAll({ up: () => up$13 });
+async function up$13(db) {
+	await db.schema.createTable("Operation").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("jobId", "text", (col) => col.notNull()).addColumn("opId", "text", (col) => col.notNull()).addColumn("prevOpId", "text", (col) => col.notNull()).addColumn("writeTimestampUtcMs", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("documentId", "text", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("timestampUtcMs", "timestamptz", (col) => col.notNull()).addColumn("index", "integer", (col) => col.notNull()).addColumn("action", "jsonb", (col) => col.notNull()).addColumn("skip", "integer", (col) => col.notNull()).addColumn("error", "text").addColumn("hash", "text", (col) => col.notNull()).addUniqueConstraint("unique_revision", [
+		"documentId",
+		"scope",
+		"branch",
+		"index"
+	]).addUniqueConstraint("unique_operation_instance", [
+		"opId",
+		"index",
+		"skip"
+	]).execute();
+	await db.schema.createIndex("streamOperations").on("Operation").columns([
+		"documentId",
+		"scope",
+		"branch",
+		"id"
+	]).execute();
+	await db.schema.createIndex("branchlessStreamOperations").on("Operation").columns([
+		"documentId",
+		"scope",
+		"id"
+	]).execute();
+}
+//#endregion
+//#region src/storage/migrations/002_create_keyframe_table.ts
+var _002_create_keyframe_table_exports = /* @__PURE__ */ __exportAll({ up: () => up$12 });
+async function up$12(db) {
+	await db.schema.createTable("Keyframe").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("revision", "integer", (col) => col.notNull()).addColumn("document", "jsonb", (col) => col.notNull()).addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addUniqueConstraint("unique_keyframe", [
+		"documentId",
+		"scope",
+		"branch",
+		"revision"
+	]).execute();
+	await db.schema.createIndex("keyframe_lookup").on("Keyframe").columns([
+		"documentId",
+		"scope",
+		"branch",
+		"revision"
+	]).execute();
+}
+//#endregion
+//#region src/storage/migrations/003_create_document_table.ts
+var _003_create_document_table_exports = /* @__PURE__ */ __exportAll({ up: () => up$11 });
+async function up$11(db) {
+	await db.schema.createTable("Document").addColumn("id", "text", (col) => col.primaryKey()).addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+}
+//#endregion
+//#region src/storage/migrations/004_create_document_relationship_table.ts
+var _004_create_document_relationship_table_exports = /* @__PURE__ */ __exportAll({ up: () => up$10 });
+async function up$10(db) {
+	await db.schema.createTable("DocumentRelationship").addColumn("id", "text", (col) => col.primaryKey()).addColumn("sourceId", "text", (col) => col.notNull().references("Document.id").onDelete("cascade")).addColumn("targetId", "text", (col) => col.notNull().references("Document.id").onDelete("cascade")).addColumn("relationshipType", "text", (col) => col.notNull()).addColumn("metadata", "jsonb").addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addUniqueConstraint("unique_source_target_type", [
+		"sourceId",
+		"targetId",
+		"relationshipType"
+	]).execute();
+	await db.schema.createIndex("idx_relationship_source").on("DocumentRelationship").column("sourceId").execute();
+	await db.schema.createIndex("idx_relationship_target").on("DocumentRelationship").column("targetId").execute();
+	await db.schema.createIndex("idx_relationship_type").on("DocumentRelationship").column("relationshipType").execute();
+}
+//#endregion
+//#region src/storage/migrations/005_create_indexer_state_table.ts
+var _005_create_indexer_state_table_exports = /* @__PURE__ */ __exportAll({ up: () => up$9 });
+async function up$9(db) {
+	await db.schema.createTable("IndexerState").addColumn("id", "integer", (col) => col.primaryKey().generatedAlwaysAsIdentity()).addColumn("lastOperationId", "integer", (col) => col.notNull()).addColumn("lastOperationTimestamp", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+}
+//#endregion
+//#region src/storage/migrations/006_create_document_snapshot_table.ts
+var _006_create_document_snapshot_table_exports = /* @__PURE__ */ __exportAll({ up: () => up$8 });
+async function up$8(db) {
+	await db.schema.createTable("DocumentSnapshot").addColumn("id", "text", (col) => col.primaryKey()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("slug", "text").addColumn("name", "text").addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("content", "jsonb", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("lastOperationIndex", "integer", (col) => col.notNull()).addColumn("lastOperationHash", "text", (col) => col.notNull()).addColumn("lastUpdatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("snapshotVersion", "integer", (col) => col.notNull().defaultTo(1)).addColumn("identifiers", "jsonb").addColumn("metadata", "jsonb").addColumn("isDeleted", "boolean", (col) => col.notNull().defaultTo(false)).addColumn("deletedAt", "timestamptz").addUniqueConstraint("unique_doc_scope_branch", [
+		"documentId",
+		"scope",
+		"branch"
+	]).execute();
+	await db.schema.createIndex("idx_slug_scope_branch").on("DocumentSnapshot").columns([
+		"slug",
+		"scope",
+		"branch"
+	]).execute();
+	await db.schema.createIndex("idx_doctype_scope_branch").on("DocumentSnapshot").columns([
+		"documentType",
+		"scope",
+		"branch"
+	]).execute();
+	await db.schema.createIndex("idx_last_updated").on("DocumentSnapshot").column("lastUpdatedAt").execute();
+	await db.schema.createIndex("idx_is_deleted").on("DocumentSnapshot").column("isDeleted").execute();
+}
+//#endregion
+//#region src/storage/migrations/007_create_slug_mapping_table.ts
+var _007_create_slug_mapping_table_exports = /* @__PURE__ */ __exportAll({ up: () => up$7 });
+async function up$7(db) {
+	await db.schema.createTable("SlugMapping").addColumn("slug", "text", (col) => col.primaryKey()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addUniqueConstraint("unique_docid_scope_branch", [
+		"documentId",
+		"scope",
+		"branch"
+	]).execute();
+	await db.schema.createIndex("idx_slug_documentid").on("SlugMapping").column("documentId").execute();
+}
+//#endregion
+//#region src/storage/migrations/008_create_view_state_table.ts
+var _008_create_view_state_table_exports = /* @__PURE__ */ __exportAll({ up: () => up$6 });
+async function up$6(db) {
+	await db.schema.createTable("ViewState").addColumn("readModelId", "text", (col) => col.primaryKey()).addColumn("lastOrdinal", "integer", (col) => col.notNull().defaultTo(0)).addColumn("lastOperationTimestamp", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+}
+//#endregion
+//#region src/storage/migrations/009_create_operation_index_tables.ts
+var _009_create_operation_index_tables_exports = /* @__PURE__ */ __exportAll({ up: () => up$5 });
+async function up$5(db) {
+	await db.schema.createTable("document_collections").addColumn("documentId", "text", (col) => col.notNull()).addColumn("collectionId", "text", (col) => col.notNull()).addColumn("joinedOrdinal", "bigint", (col) => col.notNull().defaultTo(0)).addColumn("leftOrdinal", "bigint").addPrimaryKeyConstraint("document_collections_pkey", ["documentId", "collectionId"]).execute();
+	await db.schema.createIndex("idx_document_collections_collectionId").on("document_collections").column("collectionId").execute();
+	await db.schema.createIndex("idx_doc_collections_collection_range").on("document_collections").columns(["collectionId", "joinedOrdinal"]).execute();
+	await db.schema.createTable("operation_index_operations").addColumn("ordinal", "serial", (col) => col.primaryKey()).addColumn("opId", "text", (col) => col.notNull()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("timestampUtcMs", "text", (col) => col.notNull()).addColumn("writeTimestampUtcMs", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("index", "integer", (col) => col.notNull()).addColumn("skip", "integer", (col) => col.notNull()).addColumn("hash", "text", (col) => col.notNull()).addColumn("action", "jsonb", (col) => col.notNull()).execute();
+	await db.schema.createIndex("idx_operation_index_operations_document").on("operation_index_operations").columns([
+		"documentId",
+		"branch",
+		"scope"
+	]).execute();
+	await db.schema.createIndex("idx_operation_index_operations_ordinal").on("operation_index_operations").column("ordinal").execute();
+}
+//#endregion
+//#region src/storage/migrations/010_create_sync_tables.ts
+var _010_create_sync_tables_exports = /* @__PURE__ */ __exportAll({ up: () => up$4 });
+async function up$4(db) {
+	await db.schema.createTable("sync_remotes").addColumn("name", "text", (col) => col.primaryKey()).addColumn("collection_id", "text", (col) => col.notNull()).addColumn("channel_type", "text", (col) => col.notNull()).addColumn("channel_id", "text", (col) => col.notNull().defaultTo("")).addColumn("remote_name", "text", (col) => col.notNull().defaultTo("")).addColumn("channel_parameters", "jsonb", (col) => col.notNull().defaultTo(sql`'{}'::jsonb`)).addColumn("filter_document_ids", "jsonb").addColumn("filter_scopes", "jsonb").addColumn("filter_branch", "text", (col) => col.notNull().defaultTo("main")).addColumn("push_state", "text", (col) => col.notNull().defaultTo("idle")).addColumn("push_last_success_utc_ms", "text").addColumn("push_last_failure_utc_ms", "text").addColumn("push_failure_count", "integer", (col) => col.notNull().defaultTo(0)).addColumn("pull_state", "text", (col) => col.notNull().defaultTo("idle")).addColumn("pull_last_success_utc_ms", "text").addColumn("pull_last_failure_utc_ms", "text").addColumn("pull_failure_count", "integer", (col) => col.notNull().defaultTo(0)).addColumn("created_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updated_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+	await db.schema.createIndex("idx_sync_remotes_collection").on("sync_remotes").column("collection_id").execute();
+	await db.schema.createTable("sync_cursors").addColumn("remote_name", "text", (col) => col.primaryKey().references("sync_remotes.name").onDelete("cascade")).addColumn("cursor_ordinal", "bigint", (col) => col.notNull().defaultTo(0)).addColumn("last_synced_at_utc_ms", "text").addColumn("updated_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+	await db.schema.createIndex("idx_sync_cursors_ordinal").on("sync_cursors").column("cursor_ordinal").execute();
+}
+//#endregion
+//#region src/storage/migrations/011_add_cursor_type_column.ts
+var _011_add_cursor_type_column_exports = /* @__PURE__ */ __exportAll({ up: () => up$3 });
+async function up$3(db) {
+	await db.deleteFrom("sync_cursors").where("remote_name", "like", "outbox::%").execute();
+	await db.deleteFrom("sync_remotes").where("name", "like", "outbox::%").execute();
+	await db.schema.dropTable("sync_cursors").execute();
+	await db.schema.createTable("sync_cursors").addColumn("remote_name", "text", (col) => col.notNull()).addColumn("cursor_type", "text", (col) => col.notNull().defaultTo("inbox")).addColumn("cursor_ordinal", "bigint", (col) => col.notNull().defaultTo(0)).addColumn("last_synced_at_utc_ms", "text").addColumn("updated_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addPrimaryKeyConstraint("sync_cursors_pk", ["remote_name", "cursor_type"]).execute();
+	await db.schema.createIndex("idx_sync_cursors_ordinal").on("sync_cursors").column("cursor_ordinal").execute();
+}
+//#endregion
+//#region src/storage/migrations/012_add_source_remote_column.ts
+var _012_add_source_remote_column_exports = /* @__PURE__ */ __exportAll({ up: () => up$2 });
+async function up$2(db) {
+	await db.schema.alterTable("operation_index_operations").addColumn("sourceRemote", "text", (col) => col.notNull().defaultTo("")).execute();
+}
+//#endregion
+//#region src/storage/migrations/013_create_sync_dead_letters_table.ts
+var _013_create_sync_dead_letters_table_exports = /* @__PURE__ */ __exportAll({ up: () => up$1 });
+async function up$1(db) {
+	await db.schema.createTable("sync_dead_letters").addColumn("ordinal", "serial", (col) => col.primaryKey()).addColumn("id", "text", (col) => col.unique().notNull()).addColumn("job_id", "text", (col) => col.notNull()).addColumn("job_dependencies", "jsonb", (col) => col.notNull().defaultTo(sql`'[]'::jsonb`)).addColumn("remote_name", "text", (col) => col.notNull().references("sync_remotes.name").onDelete("cascade")).addColumn("document_id", "text", (col) => col.notNull()).addColumn("scopes", "jsonb", (col) => col.notNull().defaultTo(sql`'[]'::jsonb`)).addColumn("branch", "text", (col) => col.notNull()).addColumn("operations", "jsonb", (col) => col.notNull().defaultTo(sql`'[]'::jsonb`)).addColumn("error_source", "text", (col) => col.notNull()).addColumn("error_message", "text", (col) => col.notNull()).addColumn("created_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+	await db.schema.createIndex("idx_sync_dead_letters_remote").on("sync_dead_letters").column("remote_name").execute();
+}
+//#endregion
+//#region src/storage/migrations/014_create_processor_cursor_table.ts
+var _014_create_processor_cursor_table_exports = /* @__PURE__ */ __exportAll({ up: () => up });
+async function up(db) {
+	await db.schema.createTable("ProcessorCursor").addColumn("processorId", "text", (col) => col.primaryKey()).addColumn("factoryId", "text", (col) => col.notNull()).addColumn("driveId", "text", (col) => col.notNull()).addColumn("processorIndex", "integer", (col) => col.notNull()).addColumn("lastOrdinal", "integer", (col) => col.notNull().defaultTo(sql`0`)).addColumn("status", "text", (col) => col.notNull().defaultTo(sql`'active'`)).addColumn("lastError", "text").addColumn("lastErrorTimestamp", "timestamptz").addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+}
+//#endregion
+//#region src/storage/migrations/migrator.ts
+const REACTOR_SCHEMA = "reactor";
+const migrations = {
+	"001_create_operation_table": _001_create_operation_table_exports,
+	"002_create_keyframe_table": _002_create_keyframe_table_exports,
+	"003_create_document_table": _003_create_document_table_exports,
+	"004_create_document_relationship_table": _004_create_document_relationship_table_exports,
+	"005_create_indexer_state_table": _005_create_indexer_state_table_exports,
+	"006_create_document_snapshot_table": _006_create_document_snapshot_table_exports,
+	"007_create_slug_mapping_table": _007_create_slug_mapping_table_exports,
+	"008_create_view_state_table": _008_create_view_state_table_exports,
+	"009_create_operation_index_tables": _009_create_operation_index_tables_exports,
+	"010_create_sync_tables": _010_create_sync_tables_exports,
+	"011_add_cursor_type_column": _011_add_cursor_type_column_exports,
+	"012_add_source_remote_column": _012_add_source_remote_column_exports,
+	"013_create_sync_dead_letters_table": _013_create_sync_dead_letters_table_exports,
+	"014_create_processor_cursor_table": _014_create_processor_cursor_table_exports
+};
+var ProgrammaticMigrationProvider = class {
+	getMigrations() {
+		return Promise.resolve(migrations);
+	}
+};
+async function runMigrations(db, schema = REACTOR_SCHEMA) {
+	try {
+		await sql`CREATE SCHEMA IF NOT EXISTS ${sql.id(schema)}`.execute(db);
+	} catch (error) {
+		return {
+			success: false,
+			migrationsExecuted: [],
+			error: error instanceof Error ? error : /* @__PURE__ */ new Error("Failed to create schema")
+		};
+	}
+	const migrator = new Migrator({
+		db: db.withSchema(schema),
+		provider: new ProgrammaticMigrationProvider(),
+		migrationTableSchema: schema
+	});
+	let error;
+	let results;
+	try {
+		const result = await migrator.migrateToLatest();
+		error = result.error;
+		results = result.results;
+	} catch (e) {
+		error = e;
+		results = [];
+	}
+	const migrationsExecuted = results?.map((result) => result.migrationName) ?? [];
+	if (error) return {
+		success: false,
+		migrationsExecuted,
+		error: error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown migration error")
+	};
+	return {
+		success: true,
+		migrationsExecuted
+	};
+}
+async function getMigrationStatus(db, schema = REACTOR_SCHEMA) {
+	return await new Migrator({
+		db: db.withSchema(schema),
+		provider: new ProgrammaticMigrationProvider(),
+		migrationTableSchema: schema
+	}).getMigrations();
+}
+//#endregion
+//#region src/core/drive-container-types.ts
+const DEFAULT_DRIVE_CONTAINER_TYPES = new Set(["powerhouse/document-drive", "powerhouse/reactor-drive"]);
+//#endregion
+export { parsePagingOptions as A, DuplicateManifestError as C, DocumentDeletedError as D, ModuleNotFoundError as E, __exportAll as M, DocumentNotFoundError as O, CollectionMembershipCache as S, InvalidModuleError as T, KyselyWriteCache as _, createForwardingPoolInstrumentation as a, createConsistencyToken as b, DuplicateOperationError as c, KyselyKeyframeStore as d, DocumentModelRegistry as f, EventBus as g, KyselyExecutionScope as h, runMigrations as i, throwIfAborted as j, matchesScope as k, OptimisticLockError as l, driveCollectionId as m, REACTOR_SCHEMA as n, instrumentPgPool as o, SimpleJobExecutor as p, getMigrationStatus as r, KyselyOperationStore as s, DEFAULT_DRIVE_CONTAINER_TYPES as t, RevisionMismatchError as u, KyselyOperationIndex as v, DuplicateModuleError as w, createEmptyConsistencyToken as x, DocumentMetaCache as y };
+
+//# sourceMappingURL=drive-container-types-BNpMlgT_.js.map