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

package/dist/document-indexer-B2iLRB0o.js

@@ -0,0 +1,917 @@
+import { n as ReactorEventTypes } from "./types-CxSpmNGK.js";
+import { v4 } from "uuid";
+import { childLogger } from "document-model";
+//#region src/read-models/base-read-model.ts
+/**
+* Base class for read models that provides catch-up/rewind functionality.
+* Handles initialization, state tracking via ViewState table, and consistency tracking.
+* Subclasses override commitOperations() with their specific domain logic.
+*/
+var BaseReadModel = class {
+	lastOrdinal = 0;
+	name;
+	constructor(db, operationIndex, writeCache, consistencyTracker, config) {
+		this.db = db;
+		this.operationIndex = operationIndex;
+		this.writeCache = writeCache;
+		this.consistencyTracker = consistencyTracker;
+		this.config = config;
+		this.name = config.readModelId;
+	}
+	/**
+	* Initializes the read model by loading state and catching up on missed operations.
+	*/
+	async init() {
+		const viewState = await this.loadState();
+		if (viewState !== void 0) {
+			this.lastOrdinal = viewState;
+			const missedOperations = await this.operationIndex.getSinceOrdinal(this.lastOrdinal);
+			if (missedOperations.results.length > 0) {
+				const ops = this.config.rebuildStateOnInit ? await this.rebuildStateForOperations(missedOperations.results) : missedOperations.results;
+				await this.indexOperations(ops);
+			}
+		} else {
+			await this.initializeState();
+			const allOperations = await this.operationIndex.getSinceOrdinal(0);
+			if (allOperations.results.length > 0) {
+				const ops = this.config.rebuildStateOnInit ? await this.rebuildStateForOperations(allOperations.results) : allOperations.results;
+				await this.indexOperations(ops);
+			}
+		}
+	}
+	/**
+	* Template method: runs domain-specific commitOperations, then persists
+	* state and updates consistency tracking.
+	*/
+	async indexOperations(items) {
+		if (items.length === 0) return;
+		await this.commitOperations(items);
+		await this.db.transaction().execute(async (trx) => {
+			await this.saveState(trx, items);
+		});
+		this.updateConsistencyTracker(items);
+	}
+	/**
+	* Waits for the read model to reach the specified consistency level.
+	*/
+	async waitForConsistency(token, timeoutMs, signal) {
+		if (token.coordinates.length === 0) return;
+		await this.consistencyTracker.waitFor(token.coordinates, timeoutMs, signal);
+	}
+	async commitOperations(items) {}
+	/**
+	* Rebuilds document state for each operation using the write cache.
+	*/
+	async rebuildStateForOperations(operations) {
+		const result = [];
+		for (const op of operations) {
+			const { documentId, scope, branch } = op.context;
+			const targetRevision = op.operation.index;
+			const document = await this.writeCache.getState(documentId, scope, branch, targetRevision);
+			result.push({
+				operation: op.operation,
+				context: {
+					...op.context,
+					resultingState: JSON.stringify(document)
+				}
+			});
+		}
+		return result;
+	}
+	/**
+	* Loads the last processed ordinal from the ViewState table.
+	* Returns undefined if no state exists for this read model.
+	*/
+	async loadState() {
+		return (await this.db.selectFrom("ViewState").select("lastOrdinal").where("readModelId", "=", this.config.readModelId).executeTakeFirst())?.lastOrdinal;
+	}
+	/**
+	* Initializes the ViewState row for this read model.
+	*/
+	async initializeState() {
+		await this.db.insertInto("ViewState").values({
+			readModelId: this.config.readModelId,
+			lastOrdinal: 0
+		}).execute();
+	}
+	/**
+	* Saves the last processed ordinal to the ViewState table.
+	*/
+	async saveState(trx, items) {
+		const maxOrdinal = Math.max(...items.map((item) => item.context.ordinal));
+		this.lastOrdinal = maxOrdinal;
+		await trx.updateTable("ViewState").set({
+			lastOrdinal: maxOrdinal,
+			lastOperationTimestamp: /* @__PURE__ */ new Date()
+		}).where("readModelId", "=", this.config.readModelId).execute();
+	}
+	/**
+	* Updates the consistency tracker with the processed operations.
+	*/
+	updateConsistencyTracker(items) {
+		const coordinates = [];
+		for (let i = 0; i < items.length; i++) {
+			const item = items[i];
+			coordinates.push({
+				documentId: item.context.documentId,
+				scope: item.context.scope,
+				branch: item.context.branch,
+				operationIndex: item.operation.index
+			});
+		}
+		this.consistencyTracker.update(coordinates);
+	}
+};
+//#endregion
+//#region src/read-models/coordinator.ts
+/**
+* Coordinates read model synchronization by listening to operation write events
+* and updating all registered read models on per-`documentId:scope:branch`
+* serial chains. Cross-key projection runs in parallel; same-key projection is
+* serialized so the executor can return to dispatch without holding ordering
+* implicitly.
+*/
+var ReadModelCoordinator = class {
+	unsubscribe;
+	isRunning = false;
+	chains = /* @__PURE__ */ new Map();
+	logger;
+	readModels;
+	constructor(eventBus, preReady, postReady) {
+		this.eventBus = eventBus;
+		this.preReady = preReady;
+		this.postReady = postReady;
+		this.readModels = [...preReady, ...postReady];
+		this.logger = childLogger(["reactor", "read-model-coordinator"]);
+	}
+	start() {
+		if (this.isRunning) return;
+		this.unsubscribe = this.eventBus.subscribe(ReactorEventTypes.JOB_WRITE_READY, (type, event) => {
+			return this.handleWriteReady(event);
+		});
+		this.isRunning = true;
+	}
+	stop() {
+		if (!this.isRunning) return;
+		if (this.unsubscribe) {
+			this.unsubscribe();
+			this.unsubscribe = void 0;
+		}
+		this.isRunning = false;
+	}
+	/**
+	* Resolves when every per-queueKey projection chain has flushed. Intended
+	* for test fixtures and explicit shutdown; production callers use
+	* consistency tokens instead.
+	*/
+	async drain() {
+		while (this.chains.size > 0) {
+			const pending = Array.from(this.chains.values());
+			await Promise.allSettled(pending);
+		}
+	}
+	getChainDepth() {
+		return this.chains.size;
+	}
+	handleWriteReady(event) {
+		if (event.operations.length === 0) {
+			this.emitEmptyReadReady(event);
+			return;
+		}
+		const enqueuedAt = performance.now();
+		const key = this.queueKeyFor(event);
+		const current = (this.chains.get(key) ?? Promise.resolve()).then(() => this.runChain(event, enqueuedAt));
+		this.chains.set(key, current);
+		current.finally(() => {
+			if (this.chains.get(key) === current) this.chains.delete(key);
+		});
+	}
+	async emitEmptyReadReady(event) {
+		const readyEvent = {
+			jobId: event.jobId,
+			operations: event.operations
+		};
+		try {
+			await this.eventBus.emit(ReactorEventTypes.JOB_READ_READY, readyEvent);
+		} catch (error) {
+			this.logger.error("JOB_READ_READY emit failed for job @jobId: @Error", { jobId: event.jobId }, error);
+		}
+		this.emitBatchCompleted({
+			jobId: event.jobId,
+			batchSize: 0,
+			chainWaitDurationMs: 0,
+			preReadyDurationMs: 0,
+			emitDurationMs: 0,
+			postReadyDurationMs: 0
+		});
+	}
+	async runChain(event, enqueuedAt) {
+		const chainWaitDurationMs = performance.now() - enqueuedAt;
+		const preReadyStart = performance.now();
+		try {
+			await Promise.all(this.preReady.map((readModel) => this.indexWithTiming(readModel, "pre_ready", event)));
+		} catch (error) {
+			this.logger.error("Pre-ready read model indexing failed for job @jobId: @Error", { jobId: event.jobId }, error);
+		}
+		const preReadyDurationMs = performance.now() - preReadyStart;
+		const readyEvent = {
+			jobId: event.jobId,
+			operations: event.operations
+		};
+		const emitStart = performance.now();
+		try {
+			await this.eventBus.emit(ReactorEventTypes.JOB_READ_READY, readyEvent);
+		} catch (error) {
+			this.logger.error("JOB_READ_READY emit failed for job @jobId: @Error", { jobId: event.jobId }, error);
+		}
+		const emitDurationMs = performance.now() - emitStart;
+		const postReadyStart = performance.now();
+		try {
+			await Promise.all(this.postReady.map((readModel) => this.indexWithTiming(readModel, "post_ready", event)));
+		} catch (error) {
+			this.logger.error("Post-ready read model indexing failed for job @jobId: @Error", { jobId: event.jobId }, error);
+		}
+		const postReadyDurationMs = performance.now() - postReadyStart;
+		this.emitBatchCompleted({
+			jobId: event.jobId,
+			batchSize: event.operations.length,
+			chainWaitDurationMs,
+			preReadyDurationMs,
+			emitDurationMs,
+			postReadyDurationMs
+		});
+	}
+	async indexWithTiming(readModel, stage, event) {
+		const start = performance.now();
+		let success = false;
+		try {
+			await readModel.indexOperations(event.operations);
+			success = true;
+		} finally {
+			this.emitReadModelIndexed({
+				jobId: event.jobId,
+				readModelName: readModel.name,
+				stage,
+				durationMs: performance.now() - start,
+				operationCount: event.operations.length,
+				success
+			});
+		}
+	}
+	emitReadModelIndexed(payload) {
+		this.eventBus.emit(ReactorEventTypes.READMODEL_INDEXED, payload).catch((err) => this.logger.error("READMODEL_INDEXED emit failed for job @jobId: @Error", { jobId: payload.jobId }, err));
+	}
+	emitBatchCompleted(payload) {
+		this.eventBus.emit(ReactorEventTypes.READMODEL_BATCH_COMPLETED, payload).catch((err) => this.logger.error("READMODEL_BATCH_COMPLETED emit failed for job @jobId: @Error", { jobId: payload.jobId }, err));
+	}
+	queueKeyFor(event) {
+		const ctx = event.operations[0].context;
+		return `${ctx.documentId}:${ctx.scope}:${ctx.branch}`;
+	}
+};
+//#endregion
+//#region src/read-models/document-view.ts
+var KyselyDocumentView = class extends BaseReadModel {
+	_db;
+	constructor(db, operationStore, operationIndex, writeCache, consistencyTracker) {
+		super(db, operationIndex, writeCache, consistencyTracker, {
+			readModelId: "document-view",
+			rebuildStateOnInit: true
+		});
+		this.operationStore = operationStore;
+		this._db = db;
+	}
+	async commitOperations(items) {
+		await this._db.transaction().execute(async (trx) => {
+			for (const item of items) {
+				const { operation, context } = item;
+				const { documentId, scope, branch, documentType, resultingState } = context;
+				const { index, hash } = operation;
+				if (!resultingState) throw new Error(`Missing resultingState in context for operation ${operation.id || "unknown"}. IDocumentView requires resultingState from upstream - it does not rebuild documents.`);
+				let fullState;
+				try {
+					fullState = JSON.parse(resultingState);
+				} catch (error) {
+					throw new Error(`Failed to parse resultingState for operation ${operation.id || "unknown"}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+				}
+				const operationType = operation.action.type;
+				if (operationType === "DELETE_DOCUMENT") {
+					const now = /* @__PURE__ */ new Date();
+					await trx.updateTable("DocumentSnapshot").set({
+						isDeleted: true,
+						deletedAt: now,
+						lastOperationIndex: index,
+						lastOperationHash: hash,
+						lastUpdatedAt: now
+					}).where("documentId", "=", documentId).where("branch", "=", branch).execute();
+					await trx.deleteFrom("SlugMapping").where("documentId", "=", documentId).where("branch", "=", branch).execute();
+					continue;
+				}
+				let scopesToIndex;
+				if (operationType === "CREATE_DOCUMENT") scopesToIndex = Object.entries(fullState).filter(([key]) => key === "header" || key === "document" || key === "auth");
+				else if (operationType === "UPGRADE_DOCUMENT") {
+					const scopeStatesToIndex = [];
+					for (const [scopeName, scopeState] of Object.entries(fullState)) {
+						if (scopeName === "header") {
+							scopeStatesToIndex.push([scopeName, scopeState]);
+							continue;
+						}
+						if (scopeName === scope) {
+							scopeStatesToIndex.push([scopeName, scopeState]);
+							continue;
+						}
+						if (!await trx.selectFrom("DocumentSnapshot").select("scope").where("documentId", "=", documentId).where("scope", "=", scopeName).where("branch", "=", branch).executeTakeFirst()) scopeStatesToIndex.push([scopeName, scopeState]);
+					}
+					scopesToIndex = scopeStatesToIndex;
+				} else {
+					scopesToIndex = [];
+					if (fullState.header !== void 0) scopesToIndex.push(["header", fullState.header]);
+					if (fullState[scope] !== void 0) scopesToIndex.push([scope, fullState[scope]]);
+					else scopesToIndex.push([scope, {}]);
+				}
+				for (const [scopeName, scopeState] of scopesToIndex) {
+					const existingSnapshot = await trx.selectFrom("DocumentSnapshot").selectAll().where("documentId", "=", documentId).where("scope", "=", scopeName).where("branch", "=", branch).executeTakeFirst();
+					const newState = typeof scopeState === "object" && scopeState !== null ? scopeState : {};
+					let slug = existingSnapshot?.slug ?? null;
+					let name = existingSnapshot?.name ?? null;
+					if (scopeName === "header") {
+						const headerSlug = newState.slug;
+						const headerName = newState.name;
+						if (typeof headerSlug === "string") slug = headerSlug;
+						if (typeof headerName === "string") name = headerName;
+						if (slug && slug !== documentId) await trx.insertInto("SlugMapping").values({
+							slug,
+							documentId,
+							scope: scopeName,
+							branch
+						}).onConflict((oc) => oc.column("slug").doUpdateSet({
+							documentId,
+							scope: scopeName,
+							branch
+						})).execute();
+					}
+					if (existingSnapshot) await trx.updateTable("DocumentSnapshot").set({
+						lastOperationIndex: index,
+						lastOperationHash: hash,
+						lastUpdatedAt: /* @__PURE__ */ new Date(),
+						snapshotVersion: existingSnapshot.snapshotVersion + 1,
+						content: newState,
+						slug,
+						name
+					}).where("documentId", "=", documentId).where("scope", "=", scopeName).where("branch", "=", branch).execute();
+					else {
+						const snapshot = {
+							id: v4(),
+							documentId,
+							slug,
+							name,
+							scope: scopeName,
+							branch,
+							content: newState,
+							documentType,
+							lastOperationIndex: index,
+							lastOperationHash: hash,
+							identifiers: null,
+							metadata: null,
+							deletedAt: null
+						};
+						await trx.insertInto("DocumentSnapshot").values(snapshot).execute();
+					}
+				}
+			}
+		});
+	}
+	async exists(documentIds, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		if (documentIds.length === 0) return [];
+		const snapshots = await this._db.selectFrom("DocumentSnapshot").select(["documentId"]).where("documentId", "in", documentIds).where("isDeleted", "=", false).distinct().execute();
+		const existingIds = new Set(snapshots.map((s) => s.documentId));
+		return documentIds.map((id) => existingIds.has(id));
+	}
+	async get(documentId, view, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const branch = view?.branch || "main";
+		let scopesToQuery;
+		if (view?.scopes && view.scopes.length > 0) scopesToQuery = [...new Set([
+			"header",
+			"document",
+			...view.scopes
+		])];
+		else scopesToQuery = [];
+		let query = this._db.selectFrom("DocumentSnapshot").selectAll().where("documentId", "=", documentId).where("branch", "=", branch).where("isDeleted", "=", false);
+		if (scopesToQuery.length > 0) query = query.where("scope", "in", scopesToQuery);
+		const snapshots = await query.execute();
+		if (snapshots.length === 0) throw new Error(`Document not found: ${documentId}`);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const headerSnapshot = snapshots.find((s) => s.scope === "header");
+		if (!headerSnapshot) throw new Error(`Document header not found: ${documentId}`);
+		const header = headerSnapshot.content;
+		const revisions = await this.operationStore.getRevisions(documentId, branch, signal);
+		header.revision = revisions.revision;
+		header.lastModifiedAtUtcIso = revisions.latestTimestamp;
+		const state = {};
+		for (const snapshot of snapshots) {
+			if (snapshot.scope === "header") continue;
+			state[snapshot.scope] = snapshot.content;
+		}
+		return {
+			header,
+			state,
+			operations: {},
+			initialState: state,
+			clipboard: []
+		};
+	}
+	async getMany(documentIds, view, consistencyToken, signal) {
+		if (documentIds.length === 0) return [];
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const branch = view?.branch || "main";
+		let scopesToQuery;
+		if (view?.scopes && view.scopes.length > 0) scopesToQuery = [...new Set([
+			"header",
+			"document",
+			...view.scopes
+		])];
+		else scopesToQuery = [];
+		let query = this._db.selectFrom("DocumentSnapshot").selectAll().where("documentId", "in", documentIds).where("branch", "=", branch).where("isDeleted", "=", false);
+		if (scopesToQuery.length > 0) query = query.where("scope", "in", scopesToQuery);
+		const allSnapshots = await query.execute();
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const snapshotsByDocId = /* @__PURE__ */ new Map();
+		for (const snapshot of allSnapshots) {
+			const existing = snapshotsByDocId.get(snapshot.documentId) || [];
+			existing.push(snapshot);
+			snapshotsByDocId.set(snapshot.documentId, existing);
+		}
+		const foundDocumentIds = [...snapshotsByDocId.keys()];
+		const revisionResults = await Promise.all(foundDocumentIds.map((docId) => this.operationStore.getRevisions(docId, branch, signal)));
+		const revisionsByDocId = /* @__PURE__ */ new Map();
+		for (let i = 0; i < foundDocumentIds.length; i++) revisionsByDocId.set(foundDocumentIds[i], revisionResults[i]);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const documents = [];
+		for (const documentId of documentIds) {
+			const snapshots = snapshotsByDocId.get(documentId);
+			if (!snapshots || snapshots.length === 0) continue;
+			const headerSnapshot = snapshots.find((s) => s.scope === "header");
+			if (!headerSnapshot) continue;
+			const header = headerSnapshot.content;
+			const revisions = revisionsByDocId.get(documentId);
+			if (revisions) {
+				header.revision = revisions.revision;
+				header.lastModifiedAtUtcIso = revisions.latestTimestamp;
+			}
+			const state = {};
+			for (const snapshot of snapshots) {
+				if (snapshot.scope === "header") continue;
+				state[snapshot.scope] = snapshot.content;
+			}
+			const document = {
+				header,
+				state,
+				operations: {},
+				initialState: state,
+				clipboard: []
+			};
+			documents.push(document);
+		}
+		return documents;
+	}
+	async getByIdOrSlug(identifier, view, consistencyToken, signal) {
+		const documentId = await this.resolveIdOrSlug(identifier, view, consistencyToken, signal);
+		return this.get(documentId, view, void 0, signal);
+	}
+	async findByType(type, view, paging, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const branch = view?.branch || "main";
+		const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
+		const limit = paging?.limit || 100;
+		const documents = [];
+		const processedDocumentIds = /* @__PURE__ */ new Set();
+		const allDocumentIds = [];
+		const snapshots = await this._db.selectFrom("DocumentSnapshot").selectAll().where("documentType", "=", type).where("branch", "=", branch).where("isDeleted", "=", false).orderBy("lastUpdatedAt", "desc").execute();
+		if (signal?.aborted) throw new Error("Operation aborted");
+		for (const snapshot of snapshots) {
+			if (processedDocumentIds.has(snapshot.documentId)) continue;
+			processedDocumentIds.add(snapshot.documentId);
+			allDocumentIds.push(snapshot.documentId);
+		}
+		const docsToFetch = allDocumentIds.slice(startIndex, startIndex + limit);
+		for (const documentId of docsToFetch) {
+			if (signal?.aborted) throw new Error("Operation aborted");
+			try {
+				const document = await this.get(documentId, view, void 0, signal);
+				documents.push(document);
+			} catch {
+				continue;
+			}
+		}
+		const hasMore = allDocumentIds.length > startIndex + limit;
+		const nextCursor = hasMore ? String(startIndex + limit) : void 0;
+		return {
+			results: documents,
+			options: paging || {
+				cursor: "0",
+				limit: 100
+			},
+			nextCursor,
+			totalCount: allDocumentIds.length,
+			next: hasMore ? () => this.findByType(type, view, {
+				cursor: nextCursor,
+				limit
+			}, consistencyToken, signal) : void 0
+		};
+	}
+	async resolveSlug(slug, view, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const branch = view?.branch || "main";
+		const mapping = await this._db.selectFrom("SlugMapping").select("documentId").where("slug", "=", slug).where("branch", "=", branch).executeTakeFirst();
+		if (!mapping) return;
+		if (signal?.aborted) throw new Error("Operation aborted");
+		if (view?.scopes && view.scopes.length > 0) {
+			if (!await this._db.selectFrom("DocumentSnapshot").select("scope").where("documentId", "=", mapping.documentId).where("branch", "=", branch).where("scope", "in", view.scopes).where("isDeleted", "=", false).executeTakeFirst()) return;
+		}
+		return mapping.documentId;
+	}
+	async resolveSlugs(slugs, view, consistencyToken, signal) {
+		return (await Promise.all(slugs.map((slug) => this.resolveSlug(slug, view, consistencyToken, signal)))).filter((id) => id !== void 0);
+	}
+	async resolveIdOrSlug(identifier, view, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const branch = view?.branch || "main";
+		const idCheckPromise = this._db.selectFrom("DocumentSnapshot").select("documentId").where("documentId", "=", identifier).where("branch", "=", branch).where("isDeleted", "=", false).executeTakeFirst();
+		const slugCheckPromise = this._db.selectFrom("SlugMapping").select("documentId").where("slug", "=", identifier).where("branch", "=", branch).executeTakeFirst();
+		const [idMatch, slugMatch] = await Promise.all([idCheckPromise, slugCheckPromise]);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const idMatchDocId = idMatch?.documentId;
+		const slugMatchDocId = slugMatch?.documentId;
+		if (idMatchDocId && slugMatchDocId && idMatchDocId !== slugMatchDocId) throw new Error(`Ambiguous identifier "${identifier}": matches both document ID "${idMatchDocId}" and slug for document ID "${slugMatchDocId}". Please use get() for ID or resolveSlug() + get() for slug to be explicit.`);
+		const resolvedDocumentId = idMatchDocId || slugMatchDocId;
+		if (!resolvedDocumentId) throw new Error(`Document not found: ${identifier}`);
+		return resolvedDocumentId;
+	}
+};
+//#endregion
+//#region src/shared/consistency-tracker.ts
+/**
+* Creates a consistency key from documentId, scope, and branch.
+*/
+function makeConsistencyKey(documentId, scope, branch) {
+	return `${documentId}:${scope}:${branch}`;
+}
+/**
+* Tracks operation indexes for documents and provides read-after-write consistency guarantees.
+* Maintains an in-memory map of the latest operation index for each (documentId, scope, branch) tuple.
+*/
+var ConsistencyTracker = class {
+	state = /* @__PURE__ */ new Map();
+	waiters = [];
+	update(coordinates) {
+		const deduplicated = this.deduplicateCoordinates(coordinates);
+		for (let i = 0; i < deduplicated.length; i++) {
+			const coord = deduplicated[i];
+			const key = makeConsistencyKey(coord.documentId, coord.scope, coord.branch);
+			const current = this.state.get(key);
+			if (current === void 0 || coord.operationIndex > current) this.state.set(key, coord.operationIndex);
+		}
+		this.checkWaiters();
+	}
+	getLatest(key) {
+		return this.state.get(key);
+	}
+	waitFor(coordinates, timeoutMs, signal) {
+		if (signal?.aborted) return Promise.reject(/* @__PURE__ */ new Error("Operation aborted"));
+		if (this.areCoordinatesSatisfied(coordinates)) return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			const waiter = {
+				coordinates,
+				resolve,
+				reject,
+				signal
+			};
+			if (timeoutMs !== void 0) waiter.timeoutId = setTimeout(() => {
+				this.removeWaiter(waiter);
+				reject(/* @__PURE__ */ new Error(`Consistency wait timed out after ${timeoutMs}ms`));
+			}, timeoutMs);
+			if (signal) {
+				const abortHandler = () => {
+					this.removeWaiter(waiter);
+					reject(/* @__PURE__ */ new Error("Operation aborted"));
+				};
+				signal.addEventListener("abort", abortHandler, { once: true });
+			}
+			this.waiters.push(waiter);
+		});
+	}
+	serialize() {
+		return Array.from(this.state.entries());
+	}
+	hydrate(entries) {
+		this.state.clear();
+		for (const [key, index] of entries) this.state.set(key, index);
+	}
+	deduplicateCoordinates(coordinates) {
+		const map = /* @__PURE__ */ new Map();
+		for (let i = 0; i < coordinates.length; i++) {
+			const coord = coordinates[i];
+			const key = makeConsistencyKey(coord.documentId, coord.scope, coord.branch);
+			const existing = map.get(key);
+			if (!existing || coord.operationIndex > existing.operationIndex) map.set(key, coord);
+		}
+		return Array.from(map.values());
+	}
+	areCoordinatesSatisfied(coordinates) {
+		for (let i = 0; i < coordinates.length; i++) {
+			const coord = coordinates[i];
+			const key = makeConsistencyKey(coord.documentId, coord.scope, coord.branch);
+			const latest = this.state.get(key);
+			if (latest === void 0 || latest < coord.operationIndex) return false;
+		}
+		return true;
+	}
+	checkWaiters() {
+		const satisfiedWaiters = [];
+		const unsatisfiedWaiters = [];
+		for (const waiter of this.waiters) {
+			if (waiter.signal?.aborted) continue;
+			if (this.areCoordinatesSatisfied(waiter.coordinates)) satisfiedWaiters.push(waiter);
+			else unsatisfiedWaiters.push(waiter);
+		}
+		this.waiters = unsatisfiedWaiters;
+		for (const waiter of satisfiedWaiters) {
+			if (waiter.timeoutId !== void 0) clearTimeout(waiter.timeoutId);
+			waiter.resolve();
+		}
+	}
+	removeWaiter(waiter) {
+		const index = this.waiters.indexOf(waiter);
+		if (index !== -1) this.waiters.splice(index, 1);
+		if (waiter.timeoutId !== void 0) clearTimeout(waiter.timeoutId);
+	}
+};
+//#endregion
+//#region src/shared/collect-all-pages.ts
+/**
+* Collects all results from a paged result set by following the next() function
+* until all pages have been fetched.
+*/
+async function collectAllPages(firstPage, signal) {
+	const allResults = [...firstPage.results];
+	let currentPage = firstPage;
+	while (currentPage.next) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		currentPage = await currentPage.next();
+		allResults.push(...currentPage.results);
+	}
+	return allResults;
+}
+//#endregion
+//#region src/storage/kysely/document-indexer.ts
+var KyselyDocumentIndexer = class extends BaseReadModel {
+	_db;
+	constructor(db, operationIndex, writeCache, consistencyTracker) {
+		super(db, operationIndex, writeCache, consistencyTracker, {
+			readModelId: "document-indexer",
+			rebuildStateOnInit: false
+		});
+		this._db = db;
+	}
+	async commitOperations(items) {
+		await this._db.transaction().execute(async (trx) => {
+			for (const item of items) {
+				const { operation } = item;
+				const actionType = operation.action.type;
+				if (actionType === "ADD_RELATIONSHIP") await this.handleAddRelationship(trx, operation);
+				else if (actionType === "REMOVE_RELATIONSHIP") await this.handleRemoveRelationship(trx, operation);
+				else if (actionType === "UPDATE_RELATIONSHIP") await this.handleUpdateRelationship(trx, operation);
+			}
+		});
+	}
+	async getOutgoing(documentId, types, paging, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
+		const limit = paging?.limit || 100;
+		let query = this._db.selectFrom("DocumentRelationship").selectAll().where("sourceId", "=", documentId);
+		if (types && types.length > 0) query = query.where("relationshipType", "in", types);
+		const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
+		const hasMore = rows.length > limit;
+		const results = hasMore ? rows.slice(0, limit) : rows;
+		const nextCursor = hasMore ? String(startIndex + limit) : void 0;
+		return {
+			results: results.map((row) => ({
+				sourceId: row.sourceId,
+				targetId: row.targetId,
+				relationshipType: row.relationshipType,
+				metadata: row.metadata ? row.metadata : void 0,
+				createdAt: row.createdAt,
+				updatedAt: row.updatedAt
+			})),
+			options: paging || {
+				cursor: "0",
+				limit: 100
+			},
+			nextCursor,
+			next: hasMore ? () => this.getOutgoing(documentId, types, {
+				cursor: nextCursor,
+				limit
+			}, consistencyToken, signal) : void 0
+		};
+	}
+	async getIncoming(documentId, types, paging, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
+		const limit = paging?.limit || 100;
+		let query = this._db.selectFrom("DocumentRelationship").selectAll().where("targetId", "=", documentId);
+		if (types && types.length > 0) query = query.where("relationshipType", "in", types);
+		const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
+		const hasMore = rows.length > limit;
+		const results = hasMore ? rows.slice(0, limit) : rows;
+		const nextCursor = hasMore ? String(startIndex + limit) : void 0;
+		return {
+			results: results.map((row) => ({
+				sourceId: row.sourceId,
+				targetId: row.targetId,
+				relationshipType: row.relationshipType,
+				metadata: row.metadata ? row.metadata : void 0,
+				createdAt: row.createdAt,
+				updatedAt: row.updatedAt
+			})),
+			options: paging || {
+				cursor: "0",
+				limit: 100
+			},
+			nextCursor,
+			next: hasMore ? () => this.getIncoming(documentId, types, {
+				cursor: nextCursor,
+				limit
+			}, consistencyToken, signal) : void 0
+		};
+	}
+	async getOrphanedChildren(parentIds, types, signal) {
+		if (parentIds.length === 0) return [];
+		if (signal?.aborted) throw new Error("Operation aborted");
+		let query = this._db.selectFrom("DocumentRelationship as r").select("r.targetId").distinct().where("r.sourceId", "in", parentIds).where((eb) => eb.not(eb.exists(eb.selectFrom("DocumentRelationship as other").select("other.id").whereRef("other.targetId", "=", "r.targetId").where("other.sourceId", "not in", parentIds))));
+		if (types && types.length > 0) query = query.where("r.relationshipType", "in", types);
+		return (await query.execute()).map((row) => row.targetId);
+	}
+	async hasRelationship(sourceId, targetId, types, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		let query = this._db.selectFrom("DocumentRelationship").select("id").where("sourceId", "=", sourceId).where("targetId", "=", targetId);
+		if (types && types.length > 0) query = query.where("relationshipType", "in", types);
+		return await query.executeTakeFirst() !== void 0;
+	}
+	async getUndirectedRelationships(a, b, types, paging, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
+		const limit = paging?.limit || 100;
+		let query = this._db.selectFrom("DocumentRelationship").selectAll().where((eb) => eb.or([eb.and([eb("sourceId", "=", a), eb("targetId", "=", b)]), eb.and([eb("sourceId", "=", b), eb("targetId", "=", a)])]));
+		if (types && types.length > 0) query = query.where("relationshipType", "in", types);
+		const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
+		const hasMore = rows.length > limit;
+		const results = hasMore ? rows.slice(0, limit) : rows;
+		const nextCursor = hasMore ? String(startIndex + limit) : void 0;
+		return {
+			results: results.map((row) => ({
+				sourceId: row.sourceId,
+				targetId: row.targetId,
+				relationshipType: row.relationshipType,
+				metadata: row.metadata ? row.metadata : void 0,
+				createdAt: row.createdAt,
+				updatedAt: row.updatedAt
+			})),
+			options: paging || {
+				cursor: "0",
+				limit: 100
+			},
+			nextCursor,
+			next: hasMore ? () => this.getUndirectedRelationships(a, b, types, {
+				cursor: nextCursor,
+				limit
+			}, consistencyToken, signal) : void 0
+		};
+	}
+	async getDirectedRelationships(sourceId, targetId, types, paging, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
+		const limit = paging?.limit || 100;
+		let query = this._db.selectFrom("DocumentRelationship").selectAll().where("sourceId", "=", sourceId).where("targetId", "=", targetId);
+		if (types && types.length > 0) query = query.where("relationshipType", "in", types);
+		const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
+		const hasMore = rows.length > limit;
+		const results = hasMore ? rows.slice(0, limit) : rows;
+		const nextCursor = hasMore ? String(startIndex + limit) : void 0;
+		return {
+			results: results.map((row) => ({
+				sourceId: row.sourceId,
+				targetId: row.targetId,
+				relationshipType: row.relationshipType,
+				metadata: row.metadata ? row.metadata : void 0,
+				createdAt: row.createdAt,
+				updatedAt: row.updatedAt
+			})),
+			options: paging || {
+				cursor: "0",
+				limit: 100
+			},
+			nextCursor,
+			next: hasMore ? () => this.getDirectedRelationships(sourceId, targetId, types, {
+				cursor: nextCursor,
+				limit
+			}, consistencyToken, signal) : void 0
+		};
+	}
+	async findPath(sourceId, targetId, types, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		if (sourceId === targetId) return [sourceId];
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [{
+			id: sourceId,
+			path: [sourceId]
+		}];
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (current.id === targetId) return current.path;
+			if (visited.has(current.id)) continue;
+			visited.add(current.id);
+			const outgoingRelationships = await collectAllPages(await this.getOutgoing(current.id, types, void 0, consistencyToken, signal), signal);
+			for (const rel of outgoingRelationships) if (!visited.has(rel.targetId)) queue.push({
+				id: rel.targetId,
+				path: [...current.path, rel.targetId]
+			});
+		}
+		return null;
+	}
+	async findAncestors(documentId, types, consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const nodes = new Set([documentId]);
+		const edges = [];
+		const queue = [documentId];
+		const visited = /* @__PURE__ */ new Set();
+		while (queue.length > 0) {
+			const currentId = queue.shift();
+			if (visited.has(currentId)) continue;
+			visited.add(currentId);
+			const incomingRelationships = await collectAllPages(await this.getIncoming(currentId, types, void 0, consistencyToken, signal), signal);
+			for (const rel of incomingRelationships) {
+				nodes.add(rel.sourceId);
+				edges.push({
+					from: rel.sourceId,
+					to: rel.targetId,
+					type: rel.relationshipType
+				});
+				if (!visited.has(rel.sourceId)) queue.push(rel.sourceId);
+			}
+		}
+		return {
+			nodes: Array.from(nodes),
+			edges
+		};
+	}
+	async getRelationshipTypes(consistencyToken, signal) {
+		if (consistencyToken) await this.waitForConsistency(consistencyToken, void 0, signal);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		return (await this._db.selectFrom("DocumentRelationship").select("relationshipType").distinct().execute()).map((row) => row.relationshipType);
+	}
+	async handleAddRelationship(trx, operation) {
+		const input = operation.action.input;
+		if (!await trx.selectFrom("Document").select("id").where("id", "=", input.sourceId).executeTakeFirst()) await trx.insertInto("Document").values({ id: input.sourceId }).execute();
+		if (!await trx.selectFrom("Document").select("id").where("id", "=", input.targetId).executeTakeFirst()) await trx.insertInto("Document").values({ id: input.targetId }).execute();
+		if (!await trx.selectFrom("DocumentRelationship").select("id").where("sourceId", "=", input.sourceId).where("targetId", "=", input.targetId).where("relationshipType", "=", input.relationshipType).executeTakeFirst()) {
+			const relationship = {
+				id: v4(),
+				sourceId: input.sourceId,
+				targetId: input.targetId,
+				relationshipType: input.relationshipType,
+				metadata: input.metadata || null
+			};
+			await trx.insertInto("DocumentRelationship").values(relationship).execute();
+		}
+	}
+	async handleRemoveRelationship(trx, operation) {
+		const input = operation.action.input;
+		await trx.deleteFrom("DocumentRelationship").where("sourceId", "=", input.sourceId).where("targetId", "=", input.targetId).where("relationshipType", "=", input.relationshipType).execute();
+	}
+	async handleUpdateRelationship(trx, operation) {
+		const input = operation.action.input;
+		await trx.updateTable("DocumentRelationship").set({
+			metadata: input.metadata,
+			updatedAt: /* @__PURE__ */ new Date()
+		}).where("sourceId", "=", input.sourceId).where("targetId", "=", input.targetId).where("relationshipType", "=", input.relationshipType).execute();
+	}
+};
+//#endregion
+export { ReadModelCoordinator as a, KyselyDocumentView as i, ConsistencyTracker as n, BaseReadModel as o, makeConsistencyKey as r, KyselyDocumentIndexer as t };
+
+//# sourceMappingURL=document-indexer-B2iLRB0o.js.map