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

package/dist/document-indexer-3fkVWCaN.js

@@ -0,0 +1,1856 @@
+import { At as yieldToMain, Ct as ReactorEventTypes, S as createKyselyWatermarkProbe, _ as acquirePurgeLocks, lt as DocumentNotFoundError, v as findPurged, x as SettledWatermark } from "./forwarding-logger-B9LLXItm.js";
+import { createAuthState, isDenied, isPurgeMarker } from "@powerhousedao/shared/document-model";
+import { v4 } from "uuid";
+import { childLogger } from "document-model";
+//#region src/catch-up/scheduler.ts
+const noHooks = {
+	onSwept: () => {},
+	describeSessions: () => Promise.resolve([])
+};
+function isCatchUpConsumer(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.sweep === "function" && typeof candidate.consumerId === "string" && typeof candidate.appliedThrough === "number";
+}
+/** Periodically sweeps every consumer up to the settled watermark. */
+var CatchUpScheduler = class {
+	watermark;
+	operationIndex;
+	config;
+	logger;
+	hooks;
+	fixed = [];
+	sources = [];
+	sourced = /* @__PURE__ */ new WeakMap();
+	timer;
+	running;
+	started = false;
+	stopped = false;
+	warnedStallSince;
+	statusSources = [];
+	constructor(watermark, operationIndex, config, logger, hooks = noHooks) {
+		this.watermark = watermark;
+		this.operationIndex = operationIndex;
+		this.config = config;
+		this.logger = logger;
+		this.hooks = hooks;
+	}
+	get settledWatermark() {
+		return this.watermark;
+	}
+	addConsumer(consumer, thread) {
+		if (this.fixed.some((entry) => entry.consumer === consumer)) return;
+		this.fixed.push({
+			consumer,
+			thread,
+			lastAdvanceUtcMs: Date.now(),
+			warnedHeld: false
+		});
+		this.ensureTimer();
+	}
+	/** Consumers read on every tick, so models registered later are swept too. */
+	addSource(consumers, thread) {
+		this.sources.push({
+			consumers,
+			thread
+		});
+		this.ensureTimer();
+	}
+	/** Consumers another thread sweeps, reported in status(). */
+	addStatusSource(source) {
+		this.statusSources.push(source);
+	}
+	start() {
+		this.started = true;
+		this.ensureTimer();
+	}
+	async stop() {
+		this.stopped = true;
+		if (this.timer !== void 0) {
+			clearInterval(this.timer);
+			this.timer = void 0;
+		}
+		if (this.running !== void 0) await this.running.catch(() => []);
+	}
+	async sweepNow() {
+		if (this.running !== void 0) await this.running.catch(() => []);
+		return this.run();
+	}
+	status() {
+		return {
+			watermark: this.watermark.status(),
+			consumers: this.entries().map((entry) => ({
+				consumerId: entry.consumer.consumerId,
+				thread: entry.thread,
+				appliedThrough: entry.consumer.appliedThrough,
+				trackedAbove: entry.consumer.trackedAbove,
+				...entry.blockedAt !== void 0 ? { blockedAt: entry.blockedAt } : {},
+				lastAdvanceUtcMs: entry.lastAdvanceUtcMs
+			})).concat(this.statusSources.flatMap((source) => source()))
+		};
+	}
+	ensureTimer() {
+		if (!this.started || this.stopped || this.timer !== void 0) return;
+		if (this.fixed.length === 0 && this.sources.length === 0) return;
+		const timer = setInterval(() => {
+			if (this.running !== void 0) return;
+			this.run().catch((error) => {
+				this.logger.error("catch-up tick failed: @error", error);
+			});
+		}, this.config.intervalMs);
+		if (typeof timer === "object" && "unref" in timer) timer.unref();
+		this.timer = timer;
+	}
+	run() {
+		const run = this.tick().finally(() => {
+			if (this.running === run) this.running = void 0;
+		});
+		this.running = run;
+		return run;
+	}
+	async tick() {
+		const settled = await this.watermark.refresh();
+		await this.warnIfWatermarkHeld();
+		const entries = this.entries();
+		if (entries.length === 0) return [];
+		let lowest = Number.POSITIVE_INFINITY;
+		for (const entry of entries) lowest = Math.min(lowest, entry.consumer.appliedThrough);
+		const shared = await this.readPage(lowest, settled);
+		const results = [];
+		for (const entry of entries) {
+			if (this.stopped) break;
+			const result = await this.sweepOne(entry, shared, settled);
+			if (result !== void 0) results.push(result);
+		}
+		return results;
+	}
+	entries() {
+		const entries = [...this.fixed];
+		const seen = new Set(entries.map((entry) => entry.consumer));
+		for (const source of this.sources) for (const consumer of source.consumers()) {
+			if (seen.has(consumer)) continue;
+			seen.add(consumer);
+			let entry = this.sourced.get(consumer);
+			if (entry === void 0) {
+				entry = {
+					consumer,
+					thread: source.thread,
+					lastAdvanceUtcMs: Date.now(),
+					warnedHeld: false
+				};
+				this.sourced.set(consumer, entry);
+			}
+			entries.push(entry);
+		}
+		return entries;
+	}
+	async sweepOne(entry, shared, settled) {
+		const applied = entry.consumer.appliedThrough;
+		let page = shared;
+		if (applied >= shared.bound && shared.bound < settled) try {
+			page = await this.readPage(applied, settled);
+		} catch (error) {
+			this.logger.error("@consumer catch-up could not read present ordinals: @error", entry.consumer.consumerId, error);
+			return;
+		}
+		let result;
+		try {
+			result = await entry.consumer.sweep(page.bound, page.present);
+		} catch (error) {
+			this.logger.error("@consumer catch-up sweep failed: @error", entry.consumer.consumerId, error);
+			return;
+		}
+		if (result.to > result.from) {
+			entry.lastAdvanceUtcMs = Date.now();
+			entry.warnedHeld = false;
+		}
+		entry.blockedAt = result.blockedAt;
+		this.warnIfConsumerHeld(entry, settled);
+		if (result.to > result.from || result.replayed > 0 || result.blockedAt !== void 0) this.hooks.onSwept(result, entry.thread);
+		return result;
+	}
+	async warnIfWatermarkHeld() {
+		const status = this.watermark.status();
+		const since = status.stalledSinceUtcMs;
+		if (since === void 0) {
+			this.warnedStallSince = void 0;
+			return;
+		}
+		const heldMs = Date.now() - since;
+		if (heldMs < this.config.stuckWarnMs || this.warnedStallSince === since) return;
+		this.warnedStallSince = since;
+		const sessions = await this.hooks.describeSessions(status.waitingOn).catch(() => []);
+		this.logger.warn("settled watermark held at @settled (head @head) for @ms ms, waiting on xid @xids: @sessions", status.settledThrough, status.head, heldMs, status.waitingOn.join(", "), sessions.map((session) => `pid ${session.pid} ${session.applicationName} ${session.state} since ${session.xactStart ?? "?"}`).join("; "));
+	}
+	warnIfConsumerHeld(entry, settled) {
+		const applied = entry.consumer.appliedThrough;
+		if (applied >= settled || entry.warnedHeld) return;
+		const heldMs = Date.now() - entry.lastAdvanceUtcMs;
+		if (heldMs < this.config.stuckWarnMs) return;
+		entry.warnedHeld = true;
+		this.logger.warn("@consumer cursor held at @applied for @ms ms (settled @settled)", entry.consumer.consumerId, applied, heldMs, settled);
+	}
+	async readPage(after, settled) {
+		const limit = this.config.sweepPageSize;
+		const present = await this.operationIndex.getOrdinalsInRange(after, settled, limit);
+		return {
+			bound: present.length >= limit ? present[present.length - 1] : settled,
+			present
+		};
+	}
+};
+//#endregion
+//#region src/catch-up/types.ts
+const defaultCatchUpConfig = {
+	intervalMs: 2e3,
+	stuckWarnMs: 6e4,
+	maxTrackedAboveCursor: 1e5,
+	sweepPageSize: 1e4
+};
+//#endregion
+//#region src/catch-up/contiguous-cursor.ts
+/** In memory, per consumer; tracks ordinals above appliedThrough only. */
+var ContiguousCursor = class {
+	through;
+	limit;
+	claimed = /* @__PURE__ */ new Set();
+	applied = /* @__PURE__ */ new Set();
+	constructor(through, limit) {
+		this.through = through;
+		this.limit = limit;
+	}
+	setLimit(limit) {
+		this.limit = limit;
+	}
+	/** Every present ordinal at or below this has been applied. */
+	get appliedThrough() {
+		return this.through;
+	}
+	get trackedAbove() {
+		return this.claimed.size + this.applied.size;
+	}
+	/** Ordinals the caller must apply; the rest are already covered. */
+	claim(ordinals) {
+		const mine = /* @__PURE__ */ new Set();
+		for (const ordinal of ordinals) {
+			if (ordinal <= this.through) continue;
+			if (this.claimed.has(ordinal) || this.applied.has(ordinal)) continue;
+			this.claimed.add(ordinal);
+			mine.add(ordinal);
+		}
+		return mine;
+	}
+	/** Releases claims; committed ones join the applied set. */
+	settle(ordinals, committed) {
+		for (const ordinal of ordinals) {
+			if (!this.claimed.delete(ordinal)) continue;
+			if (committed && ordinal > this.through) this.applied.add(ordinal);
+		}
+	}
+	/** Past the limit, clears the applied set; the next sweep re-applies it. */
+	enforceLimit() {
+		if (this.claimed.size + this.applied.size > this.limit) this.applied.clear();
+	}
+	/** Present ordinals above the cursor that no path has claimed or applied. */
+	missing(present) {
+		return present.filter((ordinal) => ordinal > this.through && !this.claimed.has(ordinal) && !this.applied.has(ordinal));
+	}
+	/** `settled`, held below the lowest claimed or unapplied ordinal. */
+	target(settled, present) {
+		let to = settled;
+		for (const ordinal of this.claimed) if (ordinal <= to) to = ordinal - 1;
+		for (const ordinal of present) {
+			if (ordinal <= this.through || ordinal > to) continue;
+			if (!this.applied.has(ordinal)) to = ordinal - 1;
+		}
+		return Math.max(to, this.through);
+	}
+	advance(to) {
+		if (to <= this.through) return;
+		this.through = to;
+		for (const ordinal of this.applied) if (ordinal <= to) this.applied.delete(ordinal);
+		for (const ordinal of this.claimed) if (ordinal <= to) this.claimed.delete(ordinal);
+	}
+};
+//#endregion
+//#region src/read-models/base-read-model.ts
+/** Small enough that a chunk's transaction rarely outlasts the yield deadline. */
+const DEFAULT_COMMIT_CHUNK_SIZE = 50;
+/** Matches the executor's own default, so both paths yield on the same cadence. */
+const DEFAULT_READ_MODEL_YIELD_DEADLINE_MS = 50;
+const defaultReadModelIndexingConfig = {
+	commitChunkSize: 50,
+	yieldDeadlineMs: 50
+};
+/** For read models whose callers can observe where a batch was split. */
+const unchunkedReadModelIndexingConfig = {
+	commitChunkSize: Number.MAX_SAFE_INTEGER,
+	yieldDeadlineMs: 50
+};
+/**
+* Keeps the chunk size at one operation or more: a chunk of zero or less never
+* advances the indexing loop, so the pass would spin without ever resolving.
+*/
+function normalizeIndexingConfig(config) {
+	if (Number.isNaN(config.commitChunkSize)) return {
+		...config,
+		commitChunkSize: 50
+	};
+	return {
+		...config,
+		commitChunkSize: Math.max(1, Math.min(Math.floor(config.commitChunkSize), Number.MAX_SAFE_INTEGER))
+	};
+}
+function ordinalOf(item) {
+	return item.context.ordinal;
+}
+function isTracked(ordinal) {
+	return Number.isFinite(ordinal) && ordinal > 0;
+}
+function streamKeyOf(stream) {
+	return `${stream.documentId}\u0000${stream.scope}\u0000${stream.branch}`;
+}
+function groupByStream(items) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const { documentId, scope, branch } = item.context;
+		const key = streamKeyOf(item.context);
+		let group = groups.get(key);
+		if (group === void 0) {
+			group = {
+				documentId,
+				scope,
+				branch,
+				lowest: ordinalOf(item),
+				late: []
+			};
+			groups.set(key, group);
+		}
+		group.lowest = Math.min(group.lowest, ordinalOf(item));
+		group.late.push(item);
+	}
+	return [...groups.values()].sort((a, b) => a.lowest - b.lowest);
+}
+function mergeByOrdinal(...lists) {
+	const byOrdinal = /* @__PURE__ */ new Map();
+	for (const list of lists) for (const item of list) byOrdinal.set(ordinalOf(item), item);
+	return [...byOrdinal.values()].sort((a, b) => ordinalOf(a) - ordinalOf(b));
+}
+/** The ids whose purge an operation's rows must not outlive. */
+function purgeFenceIds(items) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const { operation, context } of items) {
+		ids.add(context.documentId);
+		if (operation.action.type !== "ADD_RELATIONSHIP") continue;
+		const input = operation.action.input;
+		if (typeof input.sourceId === "string") ids.add(input.sourceId);
+		if (typeof input.targetId === "string") ids.add(input.targetId);
+	}
+	return [...ids].sort();
+}
+function dropPurged(items, purged) {
+	if (purged.size === 0) return items;
+	return items.filter((item) => isPurgeMarker(item.operation) || !purged.has(item.context.documentId));
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** A read model whose cursor only sweeps and boot replay advance. */
+var BaseReadModel = class BaseReadModel {
+	db;
+	operationIndex;
+	writeCache;
+	consistencyTracker;
+	config;
+	name;
+	indexing;
+	catchUpLogger;
+	cursor;
+	persisted = 0;
+	watermark;
+	maxTrackedAboveCursor = defaultCatchUpConfig.maxTrackedAboveCursor;
+	loggedFailure;
+	failedItem;
+	initialized = false;
+	liveInFlight = /* @__PURE__ */ new Map();
+	sweptListeners = /* @__PURE__ */ new Set();
+	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;
+		this.catchUpLogger = childLogger([
+			"reactor",
+			"read-model",
+			config.readModelId
+		]);
+		this.indexing = normalizeIndexingConfig(config.indexing ?? defaultReadModelIndexingConfig);
+		this.cursor = new ContiguousCursor(0, this.maxTrackedAboveCursor);
+		if ((config.purgeFence ?? "locked") === "locked" && this.commitOperations !== BaseReadModel.prototype.commitOperations && !this.constructor.commitsInFenceTransaction) throw new Error(`Read model ${config.readModelId}: purgeFence "locked" commits in a transaction its commitOperations must write through. Write through the trx argument and set static commitsInFenceTransaction to true, or set purgeFence "skip" (rows on another handle) or "none" (no rows here, or its own transaction).`);
+	}
+	/** Set by a subclass whose commitOperations writes through its trx argument. */
+	static commitsInFenceTransaction = false;
+	get consumerId() {
+		return this.config.readModelId;
+	}
+	get appliedThrough() {
+		return this.cursor.appliedThrough;
+	}
+	get trackedAbove() {
+		return this.cursor.trackedAbove;
+	}
+	/** Shares a thread's watermark; otherwise boot probes through this db. */
+	attachCatchUp(watermark, maxTrackedAboveCursor) {
+		this.watermark = watermark;
+		this.maxTrackedAboveCursor = maxTrackedAboveCursor;
+		this.cursor.setLimit(maxTrackedAboveCursor);
+	}
+	/** Notified with the coordinates each sweep applied. */
+	onSwept(listener) {
+		this.sweptListeners.add(listener);
+		return () => {
+			this.sweptListeners.delete(listener);
+		};
+	}
+	/** A chunk that throws ends the replay; sweeps continue from below it. */
+	async init() {
+		if (this.initialized) {
+			await this.replayFromCursor();
+			return;
+		}
+		let stored = await this.loadState();
+		if (stored === void 0) {
+			if (this.config.startFrom === "head") {
+				const watermark = this.settledWatermark();
+				const settled = await watermark.refresh();
+				const head = Math.max(settled, watermark.status().head);
+				await this.initializeState(head);
+				this.resetCursor(head);
+				this.initialized = true;
+				return;
+			}
+			await this.initializeState(0);
+			stored = 0;
+		}
+		this.resetCursor(stored);
+		this.initialized = true;
+		await this.replayFromCursor();
+	}
+	/** The live path: never moves the cursor. */
+	indexOperations(items) {
+		if (items.length === 0) return Promise.resolve();
+		return this.reserveOperations(items).apply();
+	}
+	/** Holds a queued batch as live, so a sweep neither takes nor passes it. */
+	reserveOperations(items) {
+		const cursor = this.cursor;
+		const owned = this.claimLive(items);
+		const unmark = this.markLive(owned);
+		let done = false;
+		return {
+			apply: () => {
+				if (done) return Promise.resolve();
+				done = true;
+				if (cursor !== this.cursor) {
+					unmark();
+					return this.indexOperations(items);
+				}
+				if (owned.length === 0) {
+					unmark();
+					return Promise.resolve();
+				}
+				return this.applyChunked(owned, unmark);
+			},
+			release: () => {
+				if (done) return;
+				done = true;
+				cursor.settle(owned.map(ordinalOf), false);
+				unmark();
+			}
+		};
+	}
+	async sweep(settledThrough, present, signal) {
+		const startedAt = performance.now();
+		const from = this.cursor.appliedThrough;
+		const range = present.filter((ordinal) => ordinal > from && ordinal <= settledThrough);
+		const mine = this.cursor.claim(this.cursor.missing(range));
+		let replayed = 0;
+		let reapplied = 0;
+		let blockedAt;
+		if (mine.size > 0) {
+			let late;
+			try {
+				late = await this.operationIndex.getByOrdinals([...mine], signal);
+			} catch (error) {
+				this.cursor.settle(mine, false);
+				throw error;
+			}
+			const found = new Set(late.map(ordinalOf));
+			this.cursor.settle([...mine].filter((ordinal) => !found.has(ordinal)), true);
+			for (const group of groupByStream(late)) {
+				const outcome = await this.sweepStream(group, signal);
+				replayed += outcome.replayed;
+				reapplied += outcome.reapplied;
+				blockedAt ??= outcome.blockedAt;
+			}
+			if (replayed > 0) this.catchUpLogger.warn("@consumer applied @n operations its live path never received: ordinals @first..@last", this.consumerId, replayed, Math.min(...found), Math.max(...found));
+		}
+		const to = this.cursor.target(settledThrough, range);
+		if (to > from) await this.moveCursor(to);
+		this.cursor.enforceLimit();
+		return {
+			consumerId: this.consumerId,
+			from,
+			to: this.cursor.appliedThrough,
+			durationMs: performance.now() - startedAt,
+			replayed,
+			reapplied,
+			...blockedAt !== void 0 ? { blockedAt } : {}
+		};
+	}
+	/**
+	* 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);
+	}
+	/** The cursor, for subclasses: every present ordinal at or below it is applied. */
+	get lastOrdinal() {
+		return this.cursor.appliedThrough;
+	}
+	/** Called after the cursor advances. */
+	onCursorAdvanced(appliedThrough) {}
+	/** Writes through `trx` when given: the purge fence's transaction. */
+	async commitOperations(items, trx) {}
+	/** The handle document_purges is read through; `db` may be the fence trx. */
+	purgeLookup(db) {
+		return db;
+	}
+	/** False when the batch writes no rows, so the fence opens no transaction. */
+	writesRows(items) {
+		return true;
+	}
+	/** Every delivery commits through here. */
+	async commitFenced(items) {
+		const fence = this.config.purgeFence ?? "locked";
+		if (fence === "none") {
+			await this.commitOperations(items);
+			return;
+		}
+		if (items.length === 0 || !this.writesRows(items)) {
+			if (items.length > 0) await this.commitOperations(items);
+			return;
+		}
+		const ids = purgeFenceIds(items);
+		if (fence === "skip") {
+			const live = dropPurged(items, await findPurged(this.purgeLookup(this.db), ids));
+			if (live.length > 0) await this.commitOperations(live);
+			return;
+		}
+		await this.db.transaction().execute(async (trx) => {
+			await acquirePurgeLocks(trx, ids, "shared");
+			const live = dropPurged(items, await findPurged(this.purgeLookup(trx), ids));
+			if (live.length > 0) await this.commitOperations(live, trx);
+		});
+	}
+	/** Rebuilds resultingState as the executor writes it: scopes plus header. */
+	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.state,
+						header: document.header
+					})
+				}
+			});
+		}
+		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(lastOrdinal = 0) {
+		await this.db.insertInto("ViewState").values({
+			readModelId: this.config.readModelId,
+			lastOrdinal
+		}).onConflict((oc) => oc.column("readModelId").doNothing()).execute();
+	}
+	/**
+	* Updates the consistency tracker with the processed operations.
+	*/
+	updateConsistencyTracker(items) {
+		this.consistencyTracker.update(this.coordinatesOf(items));
+	}
+	coordinatesOf(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
+			});
+		}
+		return coordinates;
+	}
+	settledWatermark() {
+		this.watermark ??= new SettledWatermark(createKyselyWatermarkProbe(this.db), this.catchUpLogger);
+		return this.watermark;
+	}
+	resetCursor(appliedThrough) {
+		this.cursor = new ContiguousCursor(appliedThrough, this.maxTrackedAboveCursor);
+		this.persisted = appliedThrough;
+	}
+	/** Items this pass must apply; untracked ordinals always apply. */
+	claimLive(items) {
+		const mine = this.cursor.claim(items.map(ordinalOf));
+		return items.filter((item) => {
+			const ordinal = ordinalOf(item);
+			return !isTracked(ordinal) || mine.has(ordinal);
+		});
+	}
+	/** Marks items in flight on their streams; returns the release. */
+	markLive(items) {
+		const keys = /* @__PURE__ */ new Set();
+		for (const item of items) {
+			if (!isTracked(ordinalOf(item))) continue;
+			const key = streamKeyOf(item.context);
+			let ordinals = this.liveInFlight.get(key);
+			if (ordinals === void 0) {
+				ordinals = /* @__PURE__ */ new Set();
+				this.liveInFlight.set(key, ordinals);
+			}
+			ordinals.add(ordinalOf(item));
+			keys.add(key);
+		}
+		return () => {
+			for (const item of items) this.liveInFlight.get(streamKeyOf(item.context))?.delete(ordinalOf(item));
+			for (const key of keys) if (this.liveInFlight.get(key)?.size === 0) this.liveInFlight.delete(key);
+		};
+	}
+	/** True while a live pass applies an earlier operation of the stream. */
+	liveBelow(group) {
+		const ordinals = this.liveInFlight.get(streamKeyOf(group));
+		if (ordinals === void 0) return false;
+		for (const ordinal of ordinals) if (ordinal < group.lowest) return true;
+		return false;
+	}
+	/** Commits in chunks, yielding with no transaction open. */
+	async applyChunked(items, release = this.markLive(items)) {
+		try {
+			const { commitChunkSize, yieldDeadlineMs } = this.indexing;
+			let lastYield = performance.now();
+			let committed = 0;
+			for (let start = 0; start < items.length; start += commitChunkSize) {
+				if (start > 0 && performance.now() - lastYield > yieldDeadlineMs) {
+					await yieldToMain();
+					lastYield = performance.now();
+				}
+				const chunk = items.slice(start, start + commitChunkSize);
+				try {
+					await this.commitFenced(chunk);
+				} catch (error) {
+					this.failedItem = chunk[0];
+					const prefix = items.slice(0, committed);
+					this.cursor.settle(prefix.map(ordinalOf), true);
+					this.cursor.settle(items.slice(committed).map(ordinalOf), false);
+					if (prefix.length > 0) this.updateConsistencyTracker(prefix);
+					throw error;
+				}
+				committed += chunk.length;
+			}
+			this.cursor.settle(items.map(ordinalOf), true);
+			this.cursor.enforceLimit();
+			this.updateConsistencyTracker(items);
+		} finally {
+			release();
+		}
+	}
+	async replayFromCursor() {
+		const settledAtBoot = await this.settledAtBoot();
+		let page = await this.operationIndex.getSinceOrdinal(this.cursor.appliedThrough);
+		while (page.results.length > 0) {
+			const ordinals = page.results.map(ordinalOf);
+			const failed = await this.replayPage(page.results);
+			const pageMax = Math.max(...ordinals);
+			const to = this.cursor.target(Math.min(settledAtBoot, pageMax), ordinals);
+			if (to > this.cursor.appliedThrough) await this.moveCursor(to);
+			if (failed || !page.next) break;
+			page = await page.next();
+		}
+	}
+	/** Without a probe, boot replay applies but leaves the cursor to sweeps. */
+	async settledAtBoot() {
+		try {
+			return await this.settledWatermark().refresh();
+		} catch (error) {
+			this.catchUpLogger.warn("@consumer could not probe the settled watermark at boot; the cursor waits for a sweep: @error", this.consumerId, error);
+			return this.cursor.appliedThrough;
+		}
+	}
+	/** Returns true when a chunk failed, which ends the replay. */
+	async replayPage(results) {
+		const owned = this.claimLive(results);
+		if (owned.length === 0) return false;
+		const release = this.markLive(owned);
+		try {
+			return await this.replayOwned(owned);
+		} finally {
+			release();
+		}
+	}
+	async replayOwned(owned) {
+		let rebuilt;
+		try {
+			rebuilt = await this.rebuildIfConfigured(owned);
+		} catch (error) {
+			this.cursor.settle(owned.map(ordinalOf), false);
+			this.block(owned[0], error);
+			return true;
+		}
+		this.cursor.settle(rebuilt.absent, true);
+		if (rebuilt.items.length === 0) return false;
+		try {
+			await this.applyChunked(rebuilt.items);
+		} catch (error) {
+			this.block(this.failedItem ?? rebuilt.items[0], error);
+			return true;
+		}
+		return false;
+	}
+	async sweepStream(group, signal) {
+		const owned = group.late.map(ordinalOf);
+		if (this.liveBelow(group)) {
+			this.cursor.settle(owned, false);
+			return {
+				replayed: 0,
+				reapplied: 0
+			};
+		}
+		const ownedSet = new Set(owned);
+		let items = group.late;
+		if (this.config.replayStreamSuffix ?? true) {
+			let suffix;
+			try {
+				suffix = await this.operationIndex.getStreamAfter(group, group.lowest, signal);
+			} catch (error) {
+				this.cursor.settle(owned, false);
+				return {
+					replayed: 0,
+					reapplied: 0,
+					blockedAt: this.block(group.late[0], error)
+				};
+			}
+			items = mergeByOrdinal(group.late, suffix);
+		}
+		let rebuilt;
+		try {
+			rebuilt = await this.rebuildIfConfigured(items);
+		} catch (error) {
+			this.cursor.settle(owned, false);
+			return {
+				replayed: 0,
+				reapplied: 0,
+				blockedAt: this.block(items[0], error)
+			};
+		}
+		try {
+			await this.commitFenced(rebuilt.items);
+		} catch (error) {
+			this.cursor.settle(owned, false);
+			return {
+				replayed: 0,
+				reapplied: 0,
+				blockedAt: this.block(rebuilt.items[0] ?? items[0], error)
+			};
+		}
+		this.cursor.settle(owned, true);
+		this.updateConsistencyTracker(rebuilt.items);
+		this.notifySwept(rebuilt.items);
+		let replayed = 0;
+		for (const item of rebuilt.items) if (ownedSet.has(ordinalOf(item))) replayed++;
+		return {
+			replayed,
+			reapplied: rebuilt.items.length - replayed
+		};
+	}
+	/** A document gone from the write cache, or purged, is absent. */
+	async rebuildIfConfigured(items) {
+		if (!this.config.rebuildStateOnInit) return {
+			items,
+			absent: []
+		};
+		const rebuilt = [];
+		const absent = [];
+		for (const item of items) {
+			if (isPurgeMarker(item.operation)) {
+				rebuilt.push(item);
+				continue;
+			}
+			let result;
+			try {
+				result = await this.rebuildStateForOperations([item]);
+			} catch (error) {
+				if (!DocumentNotFoundError.isError(error) && !await this.isPurged(item.context.documentId)) throw error;
+				this.catchUpLogger.warn("@consumer dropped ordinal @ordinal: document @documentId is gone", this.consumerId, ordinalOf(item), item.context.documentId);
+				absent.push(ordinalOf(item));
+				continue;
+			}
+			rebuilt.push(...result);
+		}
+		return {
+			items: rebuilt,
+			absent
+		};
+	}
+	/** A failed lookup is no answer: the caller's own error stands. */
+	async isPurged(documentId) {
+		try {
+			return (await findPurged(this.purgeLookup(this.db), [documentId])).has(documentId);
+		} catch {
+			return false;
+		}
+	}
+	block(item, error) {
+		const blockedAt = {
+			ordinal: ordinalOf(item),
+			documentId: item.context.documentId,
+			scope: item.context.scope,
+			branch: item.context.branch,
+			type: item.operation.action.type,
+			error: errorMessage(error)
+		};
+		if (this.loggedFailure !== blockedAt.ordinal) {
+			this.loggedFailure = blockedAt.ordinal;
+			this.catchUpLogger.error("@consumer cursor held at @applied: ordinal @ordinal (@documentId/@scope/@branch, @type) failed: @error", this.consumerId, this.cursor.appliedThrough, blockedAt.ordinal, blockedAt.documentId, blockedAt.scope, blockedAt.branch, blockedAt.type, blockedAt.error);
+		}
+		return blockedAt;
+	}
+	notifySwept(items) {
+		if (this.sweptListeners.size === 0 || items.length === 0) return;
+		const coordinates = this.coordinatesOf(items);
+		for (const listener of this.sweptListeners) listener(coordinates);
+	}
+	/** Compare-and-set against the value this process last wrote. */
+	async moveCursor(to) {
+		if (to <= this.persisted) {
+			this.advanceCursor(to);
+			return;
+		}
+		const expected = this.persisted;
+		const result = await this.db.updateTable("ViewState").set({
+			lastOrdinal: to,
+			lastOperationTimestamp: /* @__PURE__ */ new Date()
+		}).where("readModelId", "=", this.config.readModelId).where("lastOrdinal", "=", expected).executeTakeFirst();
+		if (Number(result.numUpdatedRows) > 0) {
+			this.persisted = to;
+			this.advanceCursor(to);
+			return;
+		}
+		const stored = await this.loadState();
+		if (stored === void 0) {
+			await this.initializeState(0);
+			this.lowered(0);
+			return;
+		}
+		if (stored < this.cursor.appliedThrough) {
+			this.lowered(stored);
+			return;
+		}
+		this.persisted = stored;
+		this.advanceCursor(Math.min(to, stored));
+	}
+	advanceCursor(to) {
+		const before = this.cursor.appliedThrough;
+		this.cursor.advance(to);
+		if (this.cursor.appliedThrough > before) this.onCursorAdvanced(this.cursor.appliedThrough);
+	}
+	lowered(to) {
+		this.catchUpLogger.info("@consumer cursor lowered externally from @old to @new; replaying", this.consumerId, this.cursor.appliedThrough, to);
+		this.resetCursor(to);
+	}
+};
+//#endregion
+//#region src/read-models/coordinator.ts
+/** Claims a batch for every model that supports it, as the batch queues. */
+function reserveBatch(readModels, operations, logger) {
+	const reservations = /* @__PURE__ */ new Map();
+	for (const readModel of readModels) {
+		if (readModel.reserveOperations === void 0) continue;
+		try {
+			reservations.set(readModel, readModel.reserveOperations(operations));
+		} catch (error) {
+			logger.error("Read model @name could not reserve a batch: @Error", readModel.name, error);
+		}
+	}
+	return reservations;
+}
+/** Applies the model's reservation, or indexes a model registered since. */
+function indexReserved(readModel, operations, reservations) {
+	const reservation = reservations.get(readModel);
+	return reservation ? reservation.apply() : readModel.indexOperations(operations);
+}
+/** Splices the instance out of each array; true when any held it. */
+function spliceReadModel(readModel, ...lists) {
+	let found = false;
+	for (const list of lists) {
+		const index = list.indexOf(readModel);
+		if (index < 0) continue;
+		list.splice(index, 1);
+		found = true;
+	}
+	return found;
+}
+/** Waits for every model, so a sibling that throws early cannot let the
+* chain start the next batch while another model still applies this one. */
+async function indexStage(readModels, index, onError) {
+	const results = await Promise.allSettled(readModels.map(index));
+	for (const result of results) if (result.status === "rejected") onError(result.reason);
+}
+/** Frees every claim a run did not apply, so a sweep can take it. */
+function releaseBatch(reservations) {
+	for (const reservation of reservations.values()) reservation.release();
+}
+/**
+* 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 {
+	eventBus;
+	preReady;
+	postReady;
+	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;
+	}
+	indexedReadModels() {
+		return [...this.preReady, ...this.postReady];
+	}
+	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);
+	}
+	removeReadModel(readModel) {
+		return spliceReadModel(readModel, this.preReady, this.postReady, this.readModels);
+	}
+	handleWriteReady(event) {
+		if (event.operations.length === 0) {
+			this.emitEmptyReadReady(event);
+			return;
+		}
+		const enqueuedAt = performance.now();
+		const key = this.queueKeyFor(event);
+		const reservations = reserveBatch(this.readModels, event.operations, this.logger);
+		const run = () => this.runChain(event, enqueuedAt, reservations);
+		const current = (this.chains.get(key) ?? Promise.resolve()).then(run, run);
+		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, reservations) {
+		try {
+			await this.runBatch(event, enqueuedAt, reservations);
+		} finally {
+			releaseBatch(reservations);
+		}
+	}
+	async runBatch(event, enqueuedAt, reservations) {
+		const chainWaitDurationMs = performance.now() - enqueuedAt;
+		const preReadyStart = performance.now();
+		await indexStage([...this.preReady], (readModel) => this.indexWithTiming(readModel, "pre_ready", event, reservations), (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();
+		await indexStage([...this.postReady], (readModel) => this.indexWithTiming(readModel, "post_ready", event, reservations), (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, reservations) {
+		const start = performance.now();
+		let success = false;
+		try {
+			await indexReserved(readModel, event.operations, reservations);
+			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
+/**
+* What a single-document read of a deleted document returns. A listing omits a
+* deleted document under either value.
+*/
+let DeletedDocumentRead = /* @__PURE__ */ function(DeletedDocumentRead) {
+	/**
+	* The document reads as missing: `get` throws and `resolveIdOrSlug` does not
+	* match its id.
+	*/
+	DeletedDocumentRead["NotFound"] = "NotFound";
+	/**
+	* The document's state as of the deletion, with `state.document.isDeleted`
+	* telling the caller what it holds. Only meaningful with `documentDecisions`,
+	* which is what makes deletion positional.
+	*/
+	DeletedDocumentRead["StateAtDeletion"] = "StateAtDeletion";
+	return DeletedDocumentRead;
+}({});
+var KyselyDocumentView = class extends BaseReadModel {
+	operationStore;
+	deletedDocumentRead;
+	static commitsInFenceTransaction = true;
+	_db;
+	logger = childLogger([
+		"reactor",
+		"read-model",
+		DOCUMENT_VIEW_READ_MODEL
+	]);
+	constructor(db, operationStore, operationIndex, writeCache, consistencyTracker, deletedDocumentRead, indexing = defaultReadModelIndexingConfig) {
+		super(db, operationIndex, writeCache, consistencyTracker, {
+			readModelId: DOCUMENT_VIEW_READ_MODEL,
+			rebuildStateOnInit: true,
+			indexing,
+			replayStreamSuffix: false,
+			purgeFence: "locked"
+		});
+		this.operationStore = operationStore;
+		this.deletedDocumentRead = deletedDocumentRead;
+		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.
+	*
+	* Every row accepts a write only from an operation whose global ordinal is
+	* at least the one the row already carries, so an older duplicate from a
+	* sweep, boot replay or chunk interleave never rolls a scope back.
+	*/
+	async commitOperations(items, fenced) {
+		const write = async (trx) => {
+			for (const item of items) {
+				const { operation, context } = item;
+				if (isPurgeMarker(operation)) continue;
+				const { documentId, scope, branch, documentType, resultingState, ordinal } = 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,
+						lastOperationOrdinal: ordinal,
+						lastUpdatedAt: now
+					}).where("documentId", "=", documentId).where("branch", "=", branch).where("lastOperationOrdinal", "<=", ordinal).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").where("lastOperationOrdinal", "<=", ordinal).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 this.logger.warn(`refusing to index ${documentId} scope "${scope}" at operation ${index}: resultingState carries no "${scope}" key; leaving the existing snapshot intact`);
+				}
+				for (const [scopeName, scopeState] of scopesToIndex) {
+					if (typeof scopeState !== "object" || scopeState === null) {
+						this.logger.warn(`refusing to index ${documentId} scope "${scopeName}" at operation ${index}: resultingState carries a non-object "${scopeName}" value; leaving the existing snapshot intact`);
+						continue;
+					}
+					const needsExistingContent = scopeName === "header" && preserveHeaderMeta;
+					const existingSnapshot = await trx.selectFrom("DocumentSnapshot").select([
+						"slug",
+						"name",
+						"isDeleted",
+						"snapshotVersion",
+						"lastOperationOrdinal"
+					]).$if(needsExistingContent, (qb) => qb.select("content")).where("documentId", "=", documentId).where("scope", "=", scopeName).where("branch", "=", branch).executeTakeFirst();
+					if (existingSnapshot !== void 0 && existingSnapshot.lastOperationOrdinal > ordinal) continue;
+					const newState = 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 (needsExistingContent && 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,
+						lastOperationOrdinal: ordinal,
+						lastUpdatedAt: /* @__PURE__ */ new Date(),
+						snapshotVersion: existingSnapshot.snapshotVersion + 1,
+						content: newState,
+						slug,
+						name
+					}).where("documentId", "=", documentId).where("scope", "=", scopeName).where("branch", "=", branch).where("lastOperationOrdinal", "<=", ordinal).execute();
+					else {
+						const snapshot = {
+							id: v4(),
+							documentId,
+							slug,
+							name,
+							scope: scopeName,
+							branch,
+							content: newState,
+							documentType,
+							lastOperationIndex: index,
+							lastOperationHash: hash,
+							lastOperationOrdinal: ordinal,
+							identifiers: null,
+							metadata: null,
+							deletedAt: null
+						};
+						await trx.insertInto("DocumentSnapshot").values(snapshot).execute();
+					}
+				}
+			}
+		};
+		if (fenced) {
+			await write(fenced);
+			return;
+		}
+		await this._db.transaction().execute(write);
+	}
+	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 === "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 = [.../* @__PURE__ */ new Set([
+			"header",
+			"document",
+			...view.scopes
+		])];
+		else scopesToQuery = [];
+		let query = this._db.selectFrom("DocumentSnapshot").selectAll().where("documentId", "=", documentId).where("branch", "=", branch);
+		if (this.deletedDocumentRead === "NotFound") 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 DocumentNotFoundError(documentId, `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 = [.../* @__PURE__ */ 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 rows = await this._db.selectFrom("DocumentSnapshot").select("documentId").select((eb) => eb.fn.max("lastUpdatedAt").as("lastUpdatedAt")).where("documentType", "=", type).where("branch", "=", branch).where("isDeleted", "=", false).groupBy("documentId").orderBy("lastUpdatedAt", "desc").orderBy("documentId", "asc").offset(startIndex).limit(limit + 1).execute();
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const hasMore = rows.length > limit;
+		const docsToFetch = rows.slice(0, limit).map((row) => row.documentId);
+		const documents = [];
+		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 nextCursor = hasMore ? String(startIndex + limit) : void 0;
+		return {
+			results: documents,
+			options: paging || {
+				cursor: "0",
+				limit: 100
+			},
+			nextCursor,
+			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.deletedDocumentRead === "NotFound") 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 DocumentNotFoundError(identifier, `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
+function isRelationshipAction(actionType) {
+	return actionType === "ADD_RELATIONSHIP" || actionType === "REMOVE_RELATIONSHIP" || actionType === "UPDATE_RELATIONSHIP";
+}
+function addRelationshipIds(items) {
+	const ids = [];
+	for (const { operation } of items) {
+		if (operation.action.type !== "ADD_RELATIONSHIP") continue;
+		const { sourceId, targetId } = operation.action.input;
+		if (typeof sourceId === "string") ids.push(sourceId);
+		if (typeof targetId === "string") ids.push(targetId);
+	}
+	return ids;
+}
+function touchesPurged(operation, purged) {
+	const input = operation.action.input;
+	return purged.has(input.sourceId) || purged.has(input.targetId);
+}
+var KyselyDocumentIndexer = class extends BaseReadModel {
+	static commitsInFenceTransaction = true;
+	_db;
+	constructor(db, operationIndex, writeCache, consistencyTracker, indexing = defaultReadModelIndexingConfig) {
+		super(db, operationIndex, writeCache, consistencyTracker, {
+			readModelId: DOCUMENT_INDEXER_READ_MODEL,
+			rebuildStateOnInit: false,
+			indexing,
+			purgeFence: "locked"
+		});
+		this._db = db;
+	}
+	writesRows(items) {
+		return items.some((item) => isRelationshipAction(item.operation.action.type));
+	}
+	/** Opens no transaction for a batch carrying no relationship operation. */
+	async commitOperations(items, fenced) {
+		const relationshipOps = items.filter((item) => isRelationshipAction(item.operation.action.type));
+		if (relationshipOps.length === 0) return;
+		if (fenced) {
+			await this.writeRelationships(relationshipOps, fenced);
+			return;
+		}
+		await this._db.transaction().execute((trx) => this.writeRelationships(relationshipOps, trx));
+	}
+	async writeRelationships(relationshipOps, trx) {
+		const purged = await findPurged(trx, addRelationshipIds(relationshipOps));
+		for (const item of relationshipOps) {
+			const { operation } = item;
+			const actionType = operation.action.type;
+			if (actionType === "ADD_RELATIONSHIP") {
+				if (touchesPurged(operation, purged)) continue;
+				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 = /* @__PURE__ */ 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 { isCatchUpConsumer as S, defaultReadModelIndexingConfig as _, KyselyDocumentView as a, defaultCatchUpConfig as b, ReadModelCoordinator as c, releaseBatch as d, reserveBatch as f, DEFAULT_READ_MODEL_YIELD_DEADLINE_MS as g, DEFAULT_COMMIT_CHUNK_SIZE as h, DeletedDocumentRead as i, indexReserved as l, BaseReadModel as m, ConsistencyTracker as n, DOCUMENT_INDEXER_READ_MODEL as o, spliceReadModel as p, makeConsistencyKey as r, DOCUMENT_VIEW_READ_MODEL as s, KyselyDocumentIndexer as t, indexStage as u, unchunkedReadModelIndexingConfig as v, CatchUpScheduler as x, ContiguousCursor as y };
+
+//# sourceMappingURL=document-indexer-3fkVWCaN.js.map