@powerhousedao/reactor 6.2.3-dev.4 → 6.2.3-dev.41

package/dist/{document-indexer-C5Gsa1B3.js → document-indexer-B3yKal-y.js}

@@ -1,17 +1,379 @@
-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 { At as ReactorEventTypes, D as acquirePurgeLocks, M as createKyselyWatermarkProbe, O as findPurged, Pt as yieldToMain, _t as DocumentNotFoundError, j as SettledWatermark } from "./forwarding-logger-BKDP4JnD.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 Map();
+	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
+};
 /**
-* 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.
+* 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.
 */
-var BaseReadModel = class {
-	lastOrdinal = 0;
+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;
@@ -19,33 +381,134 @@ var BaseReadModel = class {
 		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).`);
 	}
-	/**
-	* Initializes the read model by loading state and catching up on missed operations.
-	*/
+	/** 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() {
-		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();
+		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();
 	}
-	/**
-	* 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);
+	/** 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.
@@ -54,10 +517,46 @@ var BaseReadModel = class {
 		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.
-	*/
+	/** 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) {
@@ -68,7 +567,10 @@ var BaseReadModel = class {
 				operation: op.operation,
 				context: {
 					...op.context,
-					resultingState: JSON.stringify(document)
+					resultingState: JSON.stringify({
+						...document.state,
+						header: document.header
+					})
 				}
 			});
 		}
@@ -84,28 +586,19 @@ var BaseReadModel = class {
 	/**
 	* Initializes the ViewState row for this read model.
 	*/
-	async initializeState() {
+	async initializeState(lastOrdinal = 0) {
 		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();
+			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];
@@ -116,11 +609,309 @@ var BaseReadModel = class {
 				operationIndex: item.operation.index
 			});
 		}
-		this.consistencyTracker.update(coordinates);
+		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);
+}
+/** 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`
@@ -129,6 +920,9 @@ var BaseReadModel = class {
 * implicitly.
 */
 var ReadModelCoordinator = class {
+	eventBus;
+	preReady;
+	postReady;
 	unsubscribe;
 	isRunning = false;
 	chains = /* @__PURE__ */ new Map();
@@ -170,6 +964,9 @@ var ReadModelCoordinator = class {
 	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);
@@ -183,7 +980,9 @@ var ReadModelCoordinator = class {
 		}
 		const enqueuedAt = performance.now();
 		const key = this.queueKeyFor(event);
-		const current = (this.chains.get(key) ?? Promise.resolve()).then(() => this.runChain(event, enqueuedAt));
+		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);
@@ -208,11 +1007,18 @@ var ReadModelCoordinator = class {
 			postReadyDurationMs: 0
 		});
 	}
-	async runChain(event, enqueuedAt) {
+	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();
 		try {
-			await Promise.all(this.preReady.map((readModel) => this.indexWithTiming(readModel, "pre_ready", event)));
+			await Promise.all(this.preReady.map((readModel) => this.indexWithTiming(readModel, "pre_ready", event, reservations)));
 		} catch (error) {
 			this.logger.error("Pre-ready read model indexing failed for job @jobId: @Error", { jobId: event.jobId }, error);
 		}
@@ -230,7 +1036,7 @@ var ReadModelCoordinator = class {
 		const emitDurationMs = performance.now() - emitStart;
 		const postReadyStart = performance.now();
 		try {
-			await Promise.all(this.postReady.map((readModel) => this.indexWithTiming(readModel, "post_ready", event)));
+			await Promise.all(this.postReady.map((readModel) => this.indexWithTiming(readModel, "post_ready", event, reservations)));
 		} catch (error) {
 			this.logger.error("Post-ready read model indexing failed for job @jobId: @Error", { jobId: event.jobId }, error);
 		}
@@ -244,11 +1050,11 @@ var ReadModelCoordinator = class {
 			postReadyDurationMs
 		});
 	}
-	async indexWithTiming(readModel, stage, event) {
+	async indexWithTiming(readModel, stage, event, reservations) {
 		const start = performance.now();
 		let success = false;
 		try {
-			await readModel.indexOperations(event.operations);
+			await indexReserved(readModel, event.operations, reservations);
 			success = true;
 		} finally {
 			this.emitReadModelIndexed({
@@ -280,15 +1086,39 @@ const DOCUMENT_VIEW_READ_MODEL = "document-view";
 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;
-	constructor(db, operationStore, operationIndex, writeCache, consistencyTracker, servesDeletionBoundary) {
+	constructor(db, operationStore, operationIndex, writeCache, consistencyTracker, deletedDocumentRead, indexing = defaultReadModelIndexingConfig) {
 		super(db, operationIndex, writeCache, consistencyTracker, {
 			readModelId: DOCUMENT_VIEW_READ_MODEL,
-			rebuildStateOnInit: true
+			rebuildStateOnInit: true,
+			indexing,
+			replayStreamSuffix: false,
+			purgeFence: "locked"
 		});
 		this.operationStore = operationStore;
-		this.servesDeletionBoundary = servesDeletionBoundary;
+		this.deletedDocumentRead = deletedDocumentRead;
 		this._db = db;
 	}
 	/**
@@ -300,12 +1130,17 @@ var KyselyDocumentView = class extends BaseReadModel {
 	* 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) {
-		await this._db.transaction().execute(async (trx) => {
+	async commitOperations(items, fenced) {
+		const write = async (trx) => {
 			for (const item of items) {
 				const { operation, context } = item;
-				const { documentId, scope, branch, documentType, resultingState } = context;
+				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;
@@ -324,10 +1159,11 @@ var KyselyDocumentView = class extends BaseReadModel {
 						deletedAt: now,
 						lastOperationIndex: index,
 						lastOperationHash: hash,
+						lastOperationOrdinal: ordinal,
 						lastUpdatedAt: now
-					}).where("documentId", "=", documentId).where("branch", "=", branch).execute();
+					}).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").execute();
+					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;
 				}
@@ -345,7 +1181,15 @@ var KyselyDocumentView = class extends BaseReadModel {
 					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 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 = typeof scopeState === "object" && scopeState !== null ? scopeState : {};
 					let slug = existingSnapshot?.slug ?? null;
 					let name = existingSnapshot?.name ?? null;
@@ -354,7 +1198,7 @@ var KyselyDocumentView = class extends BaseReadModel {
 						const headerName = newState.name;
 						if (typeof headerSlug === "string") slug = headerSlug;
 						if (typeof headerName === "string") name = headerName;
-						if (preserveHeaderMeta && existingSnapshot) {
+						if (needsExistingContent && existingSnapshot) {
 							const existingHeader = existingSnapshot.content;
 							if (existingHeader && "meta" in existingHeader) newState.meta = existingHeader.meta;
 						}
@@ -372,12 +1216,13 @@ var KyselyDocumentView = class extends BaseReadModel {
 					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).execute();
+					}).where("documentId", "=", documentId).where("scope", "=", scopeName).where("branch", "=", branch).where("lastOperationOrdinal", "<=", ordinal).execute();
 					else {
 						const snapshot = {
 							id: v4(),
@@ -390,6 +1235,7 @@ var KyselyDocumentView = class extends BaseReadModel {
 							documentType,
 							lastOperationIndex: index,
 							lastOperationHash: hash,
+							lastOperationOrdinal: ordinal,
 							identifiers: null,
 							metadata: null,
 							deletedAt: null
@@ -398,13 +1244,18 @@ var KyselyDocumentView = class extends BaseReadModel {
 					}
 				}
 			}
-		});
+		};
+		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 === DocumentExistence.IncludingDeleted ? await this.idsWithStreams(documentIds, signal) : await this.liveIds(documentIds);
+		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) {
@@ -412,17 +1263,17 @@ var KyselyDocumentView = class extends BaseReadModel {
 		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([
+		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.servesDeletionBoundary) query = query.where("isDeleted", "=", false);
+		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 Error(`Document not found: ${documentId}`);
+		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}`);
@@ -449,7 +1300,7 @@ var KyselyDocumentView = class extends BaseReadModel {
 		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([
+		if (view?.scopes && view.scopes.length > 0) scopesToQuery = [.../* @__PURE__ */ new Set([
 			"header",
 			"document",
 			...view.scopes
@@ -508,17 +1359,11 @@ var KyselyDocumentView = class extends BaseReadModel {
 		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();
+		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");
-		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);
+		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 {
@@ -528,7 +1373,6 @@ var KyselyDocumentView = class extends BaseReadModel {
 				continue;
 			}
 		}
-		const hasMore = allDocumentIds.length > startIndex + limit;
 		const nextCursor = hasMore ? String(startIndex + limit) : void 0;
 		return {
 			results: documents,
@@ -537,7 +1381,6 @@ var KyselyDocumentView = class extends BaseReadModel {
 				limit: 100
 			},
 			nextCursor,
-			totalCount: allDocumentIds.length,
 			next: hasMore ? () => this.findByType(type, view, {
 				cursor: nextCursor,
 				limit
@@ -564,7 +1407,7 @@ var KyselyDocumentView = class extends BaseReadModel {
 		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);
+		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]);
@@ -573,7 +1416,7 @@ var KyselyDocumentView = class extends BaseReadModel {
 		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}`);
+		if (!resolvedDocumentId) throw new DocumentNotFoundError(identifier, `Document not found: ${identifier}`);
 		return resolvedDocumentId;
 	}
 	/**
@@ -713,25 +1556,59 @@ async function collectAllPages(firstPage, signal) {
 }
 //#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) {
+	constructor(db, operationIndex, writeCache, consistencyTracker, indexing = defaultReadModelIndexingConfig) {
 		super(db, operationIndex, writeCache, consistencyTracker, {
 			readModelId: DOCUMENT_INDEXER_READ_MODEL,
-			rebuildStateOnInit: false
+			rebuildStateOnInit: false,
+			indexing,
+			purgeFence: "locked"
 		});
 		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);
-			}
-		});
+	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);
@@ -896,7 +1773,7 @@ var KyselyDocumentIndexer = class extends BaseReadModel {
 	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 nodes = /* @__PURE__ */ new Set([documentId]);
 		const edges = [];
 		const queue = [documentId];
 		const visited = /* @__PURE__ */ new Set();
@@ -953,6 +1830,6 @@ var KyselyDocumentIndexer = class extends BaseReadModel {
 	}
 };
 //#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 };
+export { ContiguousCursor as _, KyselyDocumentView as a, isCatchUpConsumer as b, ReadModelCoordinator as c, reserveBatch as d, BaseReadModel as f, unchunkedReadModelIndexingConfig as g, defaultReadModelIndexingConfig as h, DeletedDocumentRead as i, indexReserved as l, DEFAULT_READ_MODEL_YIELD_DEADLINE_MS as m, ConsistencyTracker as n, DOCUMENT_INDEXER_READ_MODEL as o, DEFAULT_COMMIT_CHUNK_SIZE as p, makeConsistencyKey as r, DOCUMENT_VIEW_READ_MODEL as s, KyselyDocumentIndexer as t, releaseBatch as u, defaultCatchUpConfig as v, CatchUpScheduler as y };
 
-//# sourceMappingURL=document-indexer-C5Gsa1B3.js.map
+//# sourceMappingURL=document-indexer-B3yKal-y.js.map