@powerhousedao/reactor 6.2.3-dev.5 → 6.2.3-dev.50

package/dist/document-indexer-C5Gsa1B3.js

@@ -1,958 +0,0 @@
-import { L as DocumentExistence } from "./drive-container-types-yZrksiJR.js";
-import { n as ReactorEventTypes } from "./types-DMKLa0Ok.js";
-import { createAuthState, isDenied } from "@powerhousedao/shared/document-model";
-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;
-		else await this.initializeState();
-		let page = await this.operationIndex.getSinceOrdinal(this.lastOrdinal);
-		while (page.results.length > 0) {
-			const ops = this.config.rebuildStateOnInit ? await this.rebuildStateForOperations(page.results) : page.results;
-			await this.indexOperations(ops);
-			if (!page.next) break;
-			page = await page.next();
-		}
-	}
-	/**
-	* 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) {
-		let maxOrdinal = 0;
-		for (const item of items) maxOrdinal = Math.max(maxOrdinal, 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;
-	}
-	addReadModel(readModel, stage) {
-		if (this.readModels.some(({ name }) => name === readModel.name)) throw new Error(`Read model "${readModel.name}" is already registered`);
-		if (stage === "pre_ready") this.preReady.push(readModel);
-		else this.postReady.push(readModel);
-		this.readModels.push(readModel);
-	}
-	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/names.ts
-/** `getReadModel` name of the document view; see {@link ReactorReadModels}. */
-const DOCUMENT_VIEW_READ_MODEL = "document-view";
-/** `getReadModel` name of the document indexer; see {@link ReactorReadModels}. */
-const DOCUMENT_INDEXER_READ_MODEL = "document-indexer";
-//#endregion
-//#region src/read-models/document-view.ts
-var KyselyDocumentView = class extends BaseReadModel {
-	_db;
-	constructor(db, operationStore, operationIndex, writeCache, consistencyTracker, servesDeletionBoundary) {
-		super(db, operationIndex, writeCache, consistencyTracker, {
-			readModelId: DOCUMENT_VIEW_READ_MODEL,
-			rebuildStateOnInit: true
-		});
-		this.operationStore = operationStore;
-		this.servesDeletionBoundary = servesDeletionBoundary;
-		this._db = db;
-	}
-	/**
-	* Indexes committed operations into DocumentSnapshot rows. CREATE_DOCUMENT
-	* only seeds header/document/auth. UPGRADE_DOCUMENT reindexes every scope
-	* present in resultingState when the operation vouches for them — a seed
-	* carrying initialState or a migration stamped with the __migrated marker
-	* — since the upgrade reducer may have reshaped any of them; upgrades
-	* without either fall back to header/document/auth, because their sibling
-	* echoes may be stale. All other action types index only header and their
-	* own scope.
-	*/
-	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;
-				const denied = isDenied(operation);
-				const preserveHeaderMeta = denied || operationType !== "CREATE_DOCUMENT" && operationType !== "UPGRADE_DOCUMENT" && operationType !== "DELETE_DOCUMENT" && scope !== "header";
-				if (operationType === "DELETE_DOCUMENT" && !denied) {
-					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();
-					const deletedDocumentScope = fullState?.document;
-					if (deletedDocumentScope !== void 0) await trx.updateTable("DocumentSnapshot").set({ content: deletedDocumentScope }).where("documentId", "=", documentId).where("branch", "=", branch).where("scope", "=", "document").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 upgradeInput = operation.action.input;
-					const scopesVouchedFor = fullState.__migrated === true || upgradeInput.initialState !== void 0;
-					delete fullState.__migrated;
-					scopesToIndex = scopesVouchedFor ? Object.entries(fullState) : Object.entries(fullState).filter(([key]) => key === "header" || key === "document" || key === "auth");
-				} 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 (preserveHeaderMeta && existingSnapshot) {
-							const existingHeader = existingSnapshot.content;
-							if (existingHeader && "meta" in existingHeader) newState.meta = existingHeader.meta;
-						}
-						if (slug && slug !== documentId && !existingSnapshot?.isDeleted) 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, existence, 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 existingIds = existence === DocumentExistence.IncludingDeleted ? await this.idsWithStreams(documentIds, signal) : await this.liveIds(documentIds);
-		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);
-		if (!this.servesDeletionBoundary) query = query.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.scope === "auth" ? createAuthState(snapshot.content) : 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.scope === "auth" ? createAuthState(snapshot.content) : 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";
-		let idCheckQuery = this._db.selectFrom("DocumentSnapshot").select("documentId").where("documentId", "=", identifier).where("branch", "=", branch);
-		if (!this.servesDeletionBoundary) idCheckQuery = idCheckQuery.where("isDeleted", "=", false);
-		const idCheckPromise = idCheckQuery.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;
-	}
-	/**
-	* Ids that have at least one stream, asked of the operation store rather than
-	* of a table, so the answer holds for any store implementation. A deleted
-	* document keeps its stream, so this is the id-is-taken answer, and it does
-	* not drift when a snapshot row is missing.
-	*
-	* Asked on main because that is the branch a create writes: the store this
-	* question exists to agree with validates the create against main's head.
-	*/
-	async idsWithStreams(documentIds, signal) {
-		const unique = [...new Set(documentIds)];
-		const revisions = await Promise.all(unique.map((documentId) => this.operationStore.getRevisions(documentId, "main", signal)));
-		const taken = /* @__PURE__ */ new Set();
-		for (let i = 0; i < unique.length; i++) if (Object.keys(revisions[i].revision).length > 0) taken.add(unique[i]);
-		return taken;
-	}
-	async liveIds(documentIds) {
-		const rows = await this._db.selectFrom("DocumentSnapshot").select(["documentId"]).where("documentId", "in", documentIds).where("isDeleted", "=", false).distinct().execute();
-		return new Set(rows.map((row) => row.documentId));
-	}
-};
-//#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_READ_MODEL,
-			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 { DOCUMENT_INDEXER_READ_MODEL as a, BaseReadModel as c, KyselyDocumentView as i, ConsistencyTracker as n, DOCUMENT_VIEW_READ_MODEL as o, makeConsistencyKey as r, ReadModelCoordinator as s, KyselyDocumentIndexer as t };
-
-//# sourceMappingURL=document-indexer-C5Gsa1B3.js.map