@rocicorp/zero 1.10.0-canary.0 → 1.10.0-canary.10

package/out/zero-cache/src/services/change-streamer/sqlite-change-log-comparator.js

@@ -0,0 +1,417 @@
+import { Database } from "../../../../zqlite/src/db.js";
+import { getOrCreateCounter, getOrCreateLatencyHistogram } from "../../observability/metrics.js";
+import { CHANGE_LOG_STREAM_TABLE, readChangeLogMeta } from "../replicator/change-log-db.js";
+import { reconstructWatermarkedChange } from "./change-log-codec.js";
+import { SQLiteChangeLogReader } from "./sqlite-change-log-reader.js";
+import { digestCatchupRange } from "./change-log-compare-digest.js";
+import { isSampledForShard } from "./shard-sampling.js";
+//#region ../zero-cache/src/services/change-streamer/sqlite-change-log-comparator.ts
+/** Interval between comparison cycles. */
+var DEFAULT_COMPARE_INTERVAL_MS = 3e4;
+/** Maximum transactions enumerated per cycle. */
+var DEFAULT_MAX_TRANSACTIONS_PER_CYCLE = 256;
+/** Maximum catchup rows read from each store per cycle. */
+var DEFAULT_MAX_ROWS_PER_SOURCE_PER_CYCLE = 1e3;
+/**
+* Maximum catchup bytes read from each store per cycle.
+*
+* Rows bound the per-row overhead. Bytes bound the read and hash work,
+* which scales with payload size instead of row count. Normal traffic
+* reaches the row limit first. Wide payloads reach this one.
+*/
+var DEFAULT_MAX_BYTES_PER_SOURCE_PER_CYCLE = 32 * 1024 * 1024;
+/** Rows per SQLite catchup batch. */
+var DEFAULT_READ_BATCH_ROWS = 1e3;
+/** Uses separate aggregates so SQLite can use an index for each value. */
+var SQLITE_BOUNDS_SQL = `
+  SELECT
+    (SELECT min("watermark") FROM "${CHANGE_LOG_STREAM_TABLE}")
+      AS "minWatermark",
+    (SELECT max("watermark") FROM "${CHANGE_LOG_STREAM_TABLE}")
+      AS "headWatermark"
+`;
+/** Lists committed transaction watermarks in `(@after, @through]`. */
+var SQLITE_COMMITS_SQL = `
+  SELECT "watermark" FROM "${CHANGE_LOG_STREAM_TABLE}"
+   WHERE "precommit" IS NOT NULL
+     AND "watermark" > @after
+     AND "watermark" <= @through
+   ORDER BY "watermark"
+   LIMIT @limit
+`;
+/**
+* Compares SQLite and Postgres catchup output without affecting subscribers.
+*
+* Each cycle compares complete ranges through the lower store head.
+* It checks every transaction for presence and samples payloads.
+* A bounds change makes the affected result `inconclusive`.
+* Postgres remains authoritative.
+*/
+var SQLiteChangeLogComparator = class {
+	#lc;
+	#shard;
+	#changeLogFile;
+	#identity;
+	#pg;
+	#opts;
+	#now;
+	#setTimeoutFn;
+	#clearTimeoutFn;
+	#yield;
+	#compareResults = getOrCreateCounter("replica", "sqlite_change_log.compare_result", "Outcomes of the dark comparison between what SQLite catchup serves and what PG catchup serves, per committed transaction. `inconclusive` means a purge or reseed moved the pinned bounds mid-comparison.");
+	#compareCycles = getOrCreateCounter("replica", "sqlite_change_log.compare_cycles", "SQLite change-log comparison cycles, by result.");
+	#cycleDuration = getOrCreateLatencyHistogram("replica", "sqlite_change_log.compare_cycle_duration", "Duration of one SQLite change-log comparison cycle.");
+	/** Last handled commit watermark. A restart derives it from current bounds. */
+	#cursor;
+	#running;
+	#timer;
+	#stopped = false;
+	#continueWithoutDelay = false;
+	#fileGeneration = 0;
+	constructor(lc, shard, changeLogFile, identity, pg, opts) {
+		this.#lc = lc.withContext("component", "sqlite-change-log-compare");
+		this.#shard = shard;
+		this.#changeLogFile = changeLogFile;
+		this.#identity = identity;
+		this.#pg = pg;
+		this.#opts = opts;
+		this.#now = opts.now ?? Date.now;
+		this.#setTimeoutFn = opts.setTimeoutFn ?? setTimeout;
+		this.#clearTimeoutFn = opts.clearTimeoutFn ?? clearTimeout;
+		this.#yield = opts.yieldFn ?? (() => new Promise((resolve) => setImmediate(resolve)));
+		this.#scheduleNext();
+	}
+	/**
+	* Runs one cycle. Concurrent calls share the same promise.
+	* Errors produce `skipped: 'error'`.
+	*/
+	compareOnce() {
+		if (this.#stopped) return Promise.resolve({
+			kind: "skipped",
+			reason: "stopped"
+		});
+		if (this.#running === void 0) this.#running = this.#runCycle().then((result) => {
+			if (this.#continueWithoutDelay) this.#rescheduleNext(0);
+			return result;
+		}).finally(() => {
+			this.#running = void 0;
+		});
+		return this.#running;
+	}
+	stop() {
+		this.#stopped = true;
+		if (this.#timer !== void 0) {
+			this.#clearTimeoutFn(this.#timer);
+			this.#timer = void 0;
+		}
+	}
+	/** Invalidates cycles that can still read a replaced file. */
+	invalidate() {
+		this.#fileGeneration++;
+		this.#cursor = void 0;
+		this.#continueWithoutDelay = false;
+	}
+	#scheduleNext(delayMs = this.#opts.intervalMs ?? DEFAULT_COMPARE_INTERVAL_MS) {
+		if (this.#stopped || this.#timer !== void 0) return;
+		this.#timer = this.#setTimeoutFn(() => {
+			this.#timer = void 0;
+			this.compareOnce().finally(() => this.#scheduleNext());
+		}, delayMs);
+	}
+	#rescheduleNext(delayMs) {
+		if (this.#timer !== void 0) {
+			this.#clearTimeoutFn(this.#timer);
+			this.#timer = void 0;
+		}
+		this.#scheduleNext(delayMs);
+	}
+	async #runCycle() {
+		const startedAt = performance.now();
+		const fileGeneration = this.#fileGeneration;
+		this.#continueWithoutDelay = false;
+		let db;
+		let reader;
+		try {
+			try {
+				db = new Database(this.#lc, this.#changeLogFile, { readonly: true });
+			} catch {
+				return this.#skipped("log-unavailable");
+			}
+			const pinned = await this.#pinBounds(db);
+			if (fileGeneration !== this.#fileGeneration) return this.#skipped("log-rebuilt");
+			if (typeof pinned === "string") return this.#skipped(pinned);
+			const { meta } = pinned;
+			const from = maxWatermark(this.#cursor ?? meta.seedWatermark, meta.seedWatermark, pinned.pgMinWatermark, pinned.sqlite.minWatermark);
+			const through = minWatermark(pinned.pgLastWatermark, pinned.sqlite.headWatermark);
+			if (through <= from) return this.#skipped("nothing-to-compare");
+			let transactions = 0;
+			let sampled = 0;
+			const outcomes = {
+				match: 0,
+				mismatch: 0,
+				inconclusive: 0,
+				deferred: 0,
+				oversized: 0
+			};
+			const record = (watermark, outcome) => {
+				this.#compareResults.add(1, { outcome });
+				outcomes[outcome]++;
+				if (outcome === "mismatch") this.#lc.error?.("SQLite change-log catchup output diverged from Postgres", { sqliteChangeLogCompare: { watermark } });
+			};
+			reader = new SQLiteChangeLogReader(this.#lc, this.#changeLogFile);
+			const plan = reader.plan(from);
+			if (plan.kind === "not-ready") return this.#skipped("log-unavailable");
+			if (plan.kind === "ahead") return this.#skipped("nothing-to-compare");
+			if (plan.kind === "too-old") {
+				const reconfirmed = await this.#reconfirm(db, pinned, from);
+				const outcome = fileGeneration === this.#fileGeneration ? reconfirmed : "inconclusive";
+				record(from, outcome);
+				if (outcome === "inconclusive") return this.#compared(from, from, transactions, sampled, outcomes);
+			}
+			const limit = Math.max(1, this.#opts.maxTransactionsPerCycle ?? DEFAULT_MAX_TRANSACTIONS_PER_CYCLE);
+			const union = await this.#enumerateCommits(db, from, through, limit);
+			if (fileGeneration !== this.#fileGeneration) return this.#skipped("log-rebuilt");
+			const maxRowsPerSource = Math.max(1, this.#opts.maxRowsPerSourcePerCycle ?? DEFAULT_MAX_ROWS_PER_SOURCE_PER_CYCLE);
+			const maxBytesPerSource = Math.max(1, this.#opts.maxBytesPerSourcePerCycle ?? DEFAULT_MAX_BYTES_PER_SOURCE_PER_CYCLE);
+			let sqliteRowsRead = 0;
+			let pgRowsRead = 0;
+			let sqliteBytesRead = 0;
+			let pgBytesRead = 0;
+			let previousBoundary = from;
+			let handledThrough = from;
+			for (const { watermark, inSqlite, inPg } of union) {
+				if (this.#stopped) break;
+				let stopAfterTransaction = false;
+				if (!inSqlite || !inPg) {
+					const outcome = await this.#reconfirm(db, pinned, watermark);
+					record(watermark, fileGeneration === this.#fileGeneration ? outcome : "inconclusive");
+				} else if (isSampledForShard(this.#shard, watermark, this.#opts.comparePercent)) {
+					const sqliteRowsRemaining = maxRowsPerSource - sqliteRowsRead;
+					const pgRowsRemaining = maxRowsPerSource - pgRowsRead;
+					const sqliteBytesRemaining = maxBytesPerSource - sqliteBytesRead;
+					const pgBytesRemaining = maxBytesPerSource - pgBytesRead;
+					if (sqliteRowsRemaining === 0 || pgRowsRemaining === 0 || sqliteBytesRemaining <= 0 || pgBytesRemaining <= 0) {
+						record(watermark, "deferred");
+						break;
+					}
+					sampled++;
+					const comparison = await this.#compareTransaction(db, reader, pinned, previousBoundary, watermark, sqliteRowsRemaining, pgRowsRemaining, sqliteBytesRemaining, pgBytesRemaining, maxRowsPerSource, maxBytesPerSource);
+					sqliteRowsRead += comparison.sqliteRowsRead;
+					pgRowsRead += comparison.pgRowsRead;
+					sqliteBytesRead += comparison.sqliteBytesRead;
+					pgBytesRead += comparison.pgBytesRead;
+					const outcome = fileGeneration === this.#fileGeneration ? comparison.outcome : "inconclusive";
+					record(watermark, outcome);
+					if (outcome === "inconclusive") break;
+					if (outcome === "deferred") break;
+					if (outcome === "oversized") stopAfterTransaction = true;
+					await this.#yield();
+				}
+				previousBoundary = watermark;
+				handledThrough = watermark;
+				transactions++;
+				if (stopAfterTransaction) break;
+			}
+			if (!this.#stopped && fileGeneration === this.#fileGeneration && outcomes.inconclusive === 0) {
+				this.#cursor = handledThrough;
+				this.#continueWithoutDelay = handledThrough < through;
+			}
+			return this.#compared(from, handledThrough, transactions, sampled, outcomes);
+		} catch (e) {
+			this.#lc.warn?.("error comparing the SQLite change log", e);
+			return this.#skipped("error");
+		} finally {
+			reader?.close();
+			db?.close();
+			this.#cycleDuration.recordMs(performance.now() - startedAt);
+		}
+	}
+	/** Checks log eligibility and reads the bounds from both stores. */
+	async #pinBounds(db) {
+		let meta;
+		try {
+			meta = readChangeLogMeta(db);
+		} catch {
+			return "log-unavailable";
+		}
+		if (meta.schemaVersion !== 4) return "ineligible-schema";
+		const { epoch, generation, replicaID } = this.#identity;
+		if (meta.epoch !== epoch || meta.generation !== generation || meta.replicaID !== replicaID) return "ineligible-identity";
+		if (this.#now() - meta.seededAtMs < this.#opts.retentionMs) return "cold-log";
+		const sqlite = this.#readSQLiteBounds(db);
+		if (sqlite === void 0) return "log-unavailable";
+		const { minWatermark, lastWatermark } = await this.#pg.getCatchupBounds();
+		if (minWatermark === null) return "nothing-to-compare";
+		return {
+			meta,
+			sqlite,
+			pgMinWatermark: minWatermark,
+			pgLastWatermark: lastWatermark
+		};
+	}
+	#readSQLiteBounds(db) {
+		const bounds = db.prepare(SQLITE_BOUNDS_SQL).get();
+		return bounds.minWatermark === null || bounds.headWatermark === null ? void 0 : {
+			minWatermark: bounds.minWatermark,
+			headWatermark: bounds.headWatermark
+		};
+	}
+	/**
+	* Merges committed transaction watermarks from both stores.
+	* If a list reaches the limit, the result ends at the last complete common range.
+	*/
+	async #enumerateCommits(db, from, through, limit) {
+		let sqlite = db.prepare(SQLITE_COMMITS_SQL).all({
+			after: from,
+			through,
+			limit: limit + 1
+		}).map(({ watermark }) => watermark);
+		let pg = await this.#pg.listCommitWatermarks(from, through, limit + 1);
+		let effectiveThrough = through;
+		if (sqlite.length > limit) {
+			sqlite.length = limit;
+			effectiveThrough = minWatermark(effectiveThrough, sqlite[limit - 1]);
+		}
+		if (pg.length > limit) {
+			pg.length = limit;
+			effectiveThrough = minWatermark(effectiveThrough, pg[limit - 1]);
+		}
+		if (effectiveThrough !== through) {
+			sqlite = sqlite.filter((w) => w <= effectiveThrough);
+			pg = pg.filter((w) => w <= effectiveThrough);
+		}
+		const union = [];
+		let s = 0;
+		let p = 0;
+		while (s < sqlite.length || p < pg.length) {
+			const sw = s < sqlite.length ? sqlite[s] : void 0;
+			const pw = p < pg.length ? pg[p] : void 0;
+			if (sw !== void 0 && (pw === void 0 || sw < pw)) {
+				union.push({
+					watermark: sw,
+					inSqlite: true,
+					inPg: false
+				});
+				s++;
+			} else if (pw !== void 0 && (sw === void 0 || pw < sw)) {
+				union.push({
+					watermark: pw,
+					inSqlite: false,
+					inPg: true
+				});
+				p++;
+			} else if (sw !== void 0) {
+				union.push({
+					watermark: sw,
+					inSqlite: true,
+					inPg: true
+				});
+				s++;
+				p++;
+			}
+		}
+		return union;
+	}
+	/**
+	* Compares the output in `(previousBoundary, watermark]`.
+	* Positional reads do not require either store to contain the boundary row.
+	*/
+	async #compareTransaction(db, reader, pinned, previousBoundary, watermark, sqliteMaxRows, pgMaxRows, sqliteMaxBytes, pgMaxBytes, maxRowsPerSource, maxBytesPerSource) {
+		let sqlite;
+		let pg;
+		try {
+			const readBatchRows = this.#opts.readBatchRows ?? DEFAULT_READ_BATCH_ROWS;
+			sqlite = await digestCatchupRange(reader.read(previousBoundary, watermark, Math.min(readBatchRows, sqliteMaxRows), void 0, sqliteMaxRows), watermark, sqliteMaxRows, sqliteMaxBytes);
+			pg = await digestCatchupRange(reconstructBatches(this.#pg.readCatchupRange(previousBoundary, watermark, pgMaxRows)), watermark, pgMaxRows, pgMaxBytes);
+		} catch (e) {
+			this.#lc.warn?.(`error reading transaction ${watermark} for comparison`, e);
+			return {
+				outcome: await this.#reconfirm(db, pinned, watermark),
+				sqliteRowsRead: 0,
+				pgRowsRead: 0,
+				sqliteBytesRead: 0,
+				pgBytesRead: 0
+			};
+		}
+		const read = {
+			sqliteRowsRead: sqlite.rows,
+			pgRowsRead: pg.rows,
+			sqliteBytesRead: sqlite.bytes,
+			pgBytesRead: pg.bytes
+		};
+		if (sqlite.limitReached || pg.limitReached) {
+			const sqliteFresh = sqliteMaxRows === maxRowsPerSource && sqliteMaxBytes === maxBytesPerSource;
+			const pgFresh = pgMaxRows === maxRowsPerSource && pgMaxBytes === maxBytesPerSource;
+			return {
+				outcome: sqlite.limitReached && sqliteFresh || pg.limitReached && pgFresh ? "oversized" : "deferred",
+				...read
+			};
+		}
+		if (sqlite.digest === pg.digest) return {
+			outcome: "match",
+			...read
+		};
+		return {
+			outcome: await this.#reconfirm(db, pinned, watermark),
+			...read
+		};
+	}
+	/**
+	* Rechecks a suspect result against current store bounds.
+	* A moved bound, changed seed, failed read, or lower head makes the result inconclusive.
+	*/
+	async #reconfirm(db, pinned, watermark) {
+		try {
+			const meta = readChangeLogMeta(db);
+			if (meta.seedWatermark !== pinned.meta.seedWatermark || meta.seededAtMs !== pinned.meta.seededAtMs) return "inconclusive";
+			const sqlite = this.#readSQLiteBounds(db);
+			const { minWatermark, lastWatermark } = await this.#pg.getCatchupBounds();
+			if (sqlite === void 0 || minWatermark === null) return "inconclusive";
+			if (sqlite.minWatermark > pinned.sqlite.minWatermark && watermark <= sqlite.minWatermark || minWatermark > pinned.pgMinWatermark && watermark <= minWatermark || watermark > sqlite.headWatermark || watermark > lastWatermark) return "inconclusive";
+			return "mismatch";
+		} catch {
+			return "inconclusive";
+		}
+	}
+	#skipped(reason) {
+		this.#compareCycles.add(1, { result: reason });
+		if (reason === "error") {} else if (reason !== "nothing-to-compare") this.#lc.debug?.(`skipping SQLite change-log comparison: ${reason}`);
+		return {
+			kind: "skipped",
+			reason
+		};
+	}
+	#compared(fromWatermark, throughWatermark, transactions, sampled, outcomes) {
+		this.#compareCycles.add(1, { result: "compared" });
+		const result = {
+			kind: "compared",
+			fromWatermark,
+			throughWatermark,
+			transactions,
+			sampled,
+			matched: outcomes.match,
+			mismatched: outcomes.mismatch,
+			inconclusive: outcomes.inconclusive,
+			deferred: outcomes.deferred,
+			oversized: outcomes.oversized
+		};
+		this.#lc.debug?.("SQLite change-log comparison cycle", { sqliteChangeLogCompare: result });
+		return result;
+	}
+};
+/** Applies the same reconstruction as Postgres catchup. */
+async function* reconstructBatches(batches) {
+	for await (const batch of batches) yield batch.map(reconstructWatermarkedChange);
+}
+function minWatermark(a, b) {
+	return a < b ? a : b;
+}
+function maxWatermark(...watermarks) {
+	let max = watermarks[0];
+	for (const w of watermarks) if (w > max) max = w;
+	return max;
+}
+//#endregion
+export { SQLiteChangeLogComparator };
+
+//# sourceMappingURL=sqlite-change-log-comparator.js.map

package/out/zero-cache/src/services/change-streamer/sqlite-change-log-comparator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-change-log-comparator.js","names":["#lc","#shard","#changeLogFile","#identity","#pg","#opts","#now","#setTimeoutFn","#clearTimeoutFn","#yield","#compareResults","#compareCycles","#cycleDuration","#scheduleNext","#stopped","#running","#runCycle","#continueWithoutDelay","#rescheduleNext","#timer","#fileGeneration","#cursor","#skipped","#pinBounds","#reconfirm","#compared","#enumerateCommits","#compareTransaction","#readSQLiteBounds"],"sources":["../../../../../../zero-cache/src/services/change-streamer/sqlite-change-log-comparator.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {\n  getOrCreateCounter,\n  getOrCreateLatencyHistogram,\n} from '../../observability/metrics.ts';\nimport type {ShardID} from '../../types/shards.ts';\nimport {\n  CHANGE_LOG_DB_SCHEMA_VERSION,\n  CHANGE_LOG_STREAM_TABLE,\n  readChangeLogMeta,\n  type ChangeLogIdentity,\n  type ChangeLogMeta,\n} from '../replicator/change-log-db.ts';\nimport {\n  reconstructWatermarkedChange,\n  type ChangeLogEntry,\n} from './change-log-codec.ts';\nimport {\n  digestCatchupRange,\n  type CatchupRangeDigest,\n} from './change-log-compare-digest.ts';\nimport type {WatermarkedChange} from './change-streamer.ts';\nimport {isSampledForShard} from './shard-sampling.ts';\nimport {SQLiteChangeLogReader} from './sqlite-change-log-reader.ts';\n\n/** Interval between comparison cycles. */\nconst DEFAULT_COMPARE_INTERVAL_MS = 30_000;\n\n/** Maximum transactions enumerated per cycle. */\nconst DEFAULT_MAX_TRANSACTIONS_PER_CYCLE = 256;\n\n/** Maximum catchup rows read from each store per cycle. */\nconst DEFAULT_MAX_ROWS_PER_SOURCE_PER_CYCLE = 1000;\n\n/**\n * Maximum catchup bytes read from each store per cycle.\n *\n * Rows bound the per-row overhead. Bytes bound the read and hash work,\n * which scales with payload size instead of row count. Normal traffic\n * reaches the row limit first. Wide payloads reach this one.\n */\nconst DEFAULT_MAX_BYTES_PER_SOURCE_PER_CYCLE = 32 * 1024 * 1024;\n\n/** Rows per SQLite catchup batch. */\nconst DEFAULT_READ_BATCH_ROWS = 1000;\n\n/**\n * Result for one committed transaction.\n *\n * `mismatch` covers missing, extra, changed, or reordered rows.\n * `inconclusive` means that store bounds changed during the comparison.\n */\nexport type CompareOutcome =\n  | 'match'\n  | 'mismatch'\n  | 'inconclusive'\n  | 'deferred'\n  | 'oversized';\n\nexport type CompareSkipReason =\n  // The comparator was stopped.\n  | 'stopped'\n  // The writer replaced the file during this cycle.\n  | 'log-rebuilt'\n  // The file is absent, unreadable, or uninitialized.\n  | 'log-unavailable'\n  // The schema version does not match this build.\n  | 'ineligible-schema'\n  // The log belongs to a different replica.\n  | 'ineligible-identity'\n  // The log is younger than the warm-up period.\n  | 'cold-log'\n  // The stores have no complete committed range in common.\n  | 'nothing-to-compare'\n  // The cycle failed. The error was logged and counted.\n  | 'error';\n\nexport type CompareCycleResult =\n  | {readonly kind: 'skipped'; readonly reason: CompareSkipReason}\n  | {\n      readonly kind: 'compared';\n      /** Exclusive lower bound of the compared range. */\n      readonly fromWatermark: string;\n      /** Inclusive upper bound handled. The next cycle resumes from here. */\n      readonly throughWatermark: string;\n      /** Committed transactions handled through `throughWatermark`. */\n      readonly transactions: number;\n      /** Transactions with compared catchup output. */\n      readonly sampled: number;\n      readonly matched: number;\n      readonly mismatched: number;\n      /** Suspects rejected because store bounds changed. */\n      readonly inconclusive: number;\n      /** Sampled transactions deferred to a fresh budget. */\n      readonly deferred: number;\n      /** Sampled transactions that exceed a fresh budget. */\n      readonly oversized: number;\n    };\n\n/** Provides the Postgres side of the catchup comparison. */\nexport interface PGChangeLogRangeReader {\n  getCatchupBounds(): Promise<{\n    minWatermark: string | null;\n    lastWatermark: string;\n  }>;\n  listCommitWatermarks(\n    afterWatermark: string,\n    throughWatermark: string,\n    limit: number,\n  ): Promise<string[]>;\n  readCatchupRange(\n    afterWatermark: string,\n    throughWatermark: string,\n    batchRows?: number | undefined,\n  ): AsyncIterable<ChangeLogEntry[]>;\n}\n\nexport type SQLiteChangeLogCompareOptions = {\n  /** Stable percentage of transactions selected for payload comparison. */\n  readonly comparePercent: number;\n  /** Warm-up time after a seed. The comparator skips a younger log. */\n  readonly retentionMs: number;\n  readonly intervalMs?: number | undefined;\n  readonly maxTransactionsPerCycle?: number | undefined;\n  /** Maximum catchup rows read from each store in one cycle. */\n  readonly maxRowsPerSourcePerCycle?: number | undefined;\n  /** Maximum catchup bytes read from each store in one cycle. */\n  readonly maxBytesPerSourcePerCycle?: number | undefined;\n  readonly readBatchRows?: number | undefined;\n  /** Clock for the warm-up period. Defaults to `Date.now`. */\n  readonly now?: (() => number) | undefined;\n  readonly setTimeoutFn?: typeof setTimeout | undefined;\n  readonly clearTimeoutFn?: typeof clearTimeout | undefined;\n  /** Yields between sampled transactions. Defaults to `setImmediate`. */\n  readonly yieldFn?: (() => Promise<void>) | undefined;\n};\n\n/** Uses separate aggregates so SQLite can use an index for each value. */\nconst SQLITE_BOUNDS_SQL = /*sql*/ `\n  SELECT\n    (SELECT min(\"watermark\") FROM \"${CHANGE_LOG_STREAM_TABLE}\")\n      AS \"minWatermark\",\n    (SELECT max(\"watermark\") FROM \"${CHANGE_LOG_STREAM_TABLE}\")\n      AS \"headWatermark\"\n`;\n\n/** Lists committed transaction watermarks in `(@after, @through]`. */\nconst SQLITE_COMMITS_SQL = /*sql*/ `\n  SELECT \"watermark\" FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n   WHERE \"precommit\" IS NOT NULL\n     AND \"watermark\" > @after\n     AND \"watermark\" <= @through\n   ORDER BY \"watermark\"\n   LIMIT @limit\n`;\n\ntype SQLiteBounds = {\n  readonly minWatermark: string;\n  readonly headWatermark: string;\n};\n\ntype PinnedBounds = {\n  readonly meta: ChangeLogMeta;\n  readonly sqlite: SQLiteBounds;\n  readonly pgMinWatermark: string;\n  readonly pgLastWatermark: string;\n};\n\ntype SampledComparison = {\n  readonly outcome: CompareOutcome;\n  readonly sqliteRowsRead: number;\n  readonly pgRowsRead: number;\n  readonly sqliteBytesRead: number;\n  readonly pgBytesRead: number;\n};\n\n/**\n * Compares SQLite and Postgres catchup output without affecting subscribers.\n *\n * Each cycle compares complete ranges through the lower store head.\n * It checks every transaction for presence and samples payloads.\n * A bounds change makes the affected result `inconclusive`.\n * Postgres remains authoritative.\n */\nexport class SQLiteChangeLogComparator {\n  readonly #lc: LogContext;\n  readonly #shard: ShardID;\n  readonly #changeLogFile: string;\n  readonly #identity: ChangeLogIdentity;\n  readonly #pg: PGChangeLogRangeReader;\n  readonly #opts: SQLiteChangeLogCompareOptions;\n  readonly #now: () => number;\n  readonly #setTimeoutFn: typeof setTimeout;\n  readonly #clearTimeoutFn: typeof clearTimeout;\n  readonly #yield: () => Promise<void>;\n\n  readonly #compareResults = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.compare_result',\n    'Outcomes of the dark comparison between what SQLite catchup serves and ' +\n      'what PG catchup serves, per committed transaction. `inconclusive` ' +\n      'means a purge or reseed moved the pinned bounds mid-comparison.',\n  );\n  readonly #compareCycles = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.compare_cycles',\n    'SQLite change-log comparison cycles, by result.',\n  );\n  readonly #cycleDuration = getOrCreateLatencyHistogram(\n    'replica',\n    'sqlite_change_log.compare_cycle_duration',\n    'Duration of one SQLite change-log comparison cycle.',\n  );\n\n  /** Last handled commit watermark. A restart derives it from current bounds. */\n  #cursor: string | undefined;\n  #running: Promise<CompareCycleResult> | undefined;\n  #timer: ReturnType<typeof setTimeout> | undefined;\n  #stopped = false;\n  #continueWithoutDelay = false;\n  #fileGeneration = 0;\n\n  constructor(\n    lc: LogContext,\n    shard: ShardID,\n    changeLogFile: string,\n    identity: ChangeLogIdentity,\n    pg: PGChangeLogRangeReader,\n    opts: SQLiteChangeLogCompareOptions,\n  ) {\n    this.#lc = lc.withContext('component', 'sqlite-change-log-compare');\n    this.#shard = shard;\n    this.#changeLogFile = changeLogFile;\n    this.#identity = identity;\n    this.#pg = pg;\n    this.#opts = opts;\n    this.#now = opts.now ?? Date.now;\n    this.#setTimeoutFn = opts.setTimeoutFn ?? setTimeout;\n    this.#clearTimeoutFn = opts.clearTimeoutFn ?? clearTimeout;\n    this.#yield =\n      opts.yieldFn ??\n      (() => new Promise<void>(resolve => setImmediate(resolve)));\n    this.#scheduleNext();\n  }\n\n  /**\n   * Runs one cycle. Concurrent calls share the same promise.\n   * Errors produce `skipped: 'error'`.\n   */\n  compareOnce(): Promise<CompareCycleResult> {\n    if (this.#stopped) {\n      return Promise.resolve({kind: 'skipped', reason: 'stopped'});\n    }\n    if (this.#running === undefined) {\n      this.#running = this.#runCycle()\n        .then(result => {\n          if (this.#continueWithoutDelay) {\n            this.#rescheduleNext(0);\n          }\n          return result;\n        })\n        .finally(() => {\n          this.#running = undefined;\n        });\n    }\n    return this.#running;\n  }\n\n  stop(): void {\n    this.#stopped = true;\n    if (this.#timer !== undefined) {\n      this.#clearTimeoutFn(this.#timer);\n      this.#timer = undefined;\n    }\n  }\n\n  /** Invalidates cycles that can still read a replaced file. */\n  invalidate(): void {\n    this.#fileGeneration++;\n    this.#cursor = undefined;\n    this.#continueWithoutDelay = false;\n  }\n\n  #scheduleNext(\n    delayMs = this.#opts.intervalMs ?? DEFAULT_COMPARE_INTERVAL_MS,\n  ): void {\n    if (this.#stopped || this.#timer !== undefined) {\n      return;\n    }\n    this.#timer = this.#setTimeoutFn(() => {\n      this.#timer = undefined;\n      void this.compareOnce().finally(() => this.#scheduleNext());\n    }, delayMs);\n  }\n\n  #rescheduleNext(delayMs: number): void {\n    if (this.#timer !== undefined) {\n      this.#clearTimeoutFn(this.#timer);\n      this.#timer = undefined;\n    }\n    this.#scheduleNext(delayMs);\n  }\n\n  async #runCycle(): Promise<CompareCycleResult> {\n    const startedAt = performance.now();\n    const fileGeneration = this.#fileGeneration;\n    this.#continueWithoutDelay = false;\n    let db: Database | undefined;\n    let reader: SQLiteChangeLogReader | undefined;\n    try {\n      try {\n        // A readonly handle does not create a missing file.\n        db = new Database(this.#lc, this.#changeLogFile, {readonly: true});\n      } catch {\n        return this.#skipped('log-unavailable');\n      }\n\n      const pinned = await this.#pinBounds(db);\n      if (fileGeneration !== this.#fileGeneration) {\n        return this.#skipped('log-rebuilt');\n      }\n      if (typeof pinned === 'string') {\n        return this.#skipped(pinned);\n      }\n      const {meta} = pinned;\n\n      const from = maxWatermark(\n        this.#cursor ?? meta.seedWatermark,\n        // Exclude the synthetic SQLite seed transaction.\n        // The Postgres seed has no `precommit`, so enumeration also excludes it.\n        meta.seedWatermark,\n        // A store cannot serve the transaction at its minimum watermark.\n        pinned.pgMinWatermark,\n        pinned.sqlite.minWatermark,\n      );\n      const through = minWatermark(\n        pinned.pgLastWatermark,\n        pinned.sqlite.headWatermark,\n      );\n      if (through <= from) {\n        return this.#skipped('nothing-to-compare');\n      }\n\n      let transactions = 0;\n      let sampled = 0;\n      const outcomes: Record<CompareOutcome, number> = {\n        match: 0,\n        mismatch: 0,\n        inconclusive: 0,\n        deferred: 0,\n        oversized: 0,\n      };\n      const record = (watermark: string, outcome: CompareOutcome) => {\n        this.#compareResults.add(1, {outcome});\n        outcomes[outcome]++;\n        if (outcome === 'mismatch') {\n          // Log only the watermark because payloads contain customer data.\n          this.#lc.error?.(\n            'SQLite change-log catchup output diverged from Postgres',\n            {sqliteChangeLogCompare: {watermark}},\n          );\n        }\n      };\n\n      reader = new SQLiteChangeLogReader(this.#lc, this.#changeLogFile);\n      const plan = reader.plan(from);\n      if (plan.kind === 'not-ready') {\n        return this.#skipped('log-unavailable');\n      }\n      if (plan.kind === 'ahead') {\n        return this.#skipped('nothing-to-compare');\n      }\n      if (plan.kind === 'too-old') {\n        // A fixed lower bound makes this result a mismatch.\n        // A changed lower bound makes it inconclusive.\n        const reconfirmed = await this.#reconfirm(db, pinned, from);\n        const outcome =\n          fileGeneration === this.#fileGeneration\n            ? reconfirmed\n            : 'inconclusive';\n        record(from, outcome);\n        if (outcome === 'inconclusive') {\n          // Keep the cursor unchanged because the bounds moved.\n          return this.#compared(from, from, transactions, sampled, outcomes);\n        }\n        // Positional reads can continue after a missing boundary.\n        // Advancing avoids reporting the same boundary in every cycle.\n      }\n\n      const limit = Math.max(\n        1,\n        this.#opts.maxTransactionsPerCycle ??\n          DEFAULT_MAX_TRANSACTIONS_PER_CYCLE,\n      );\n      const union = await this.#enumerateCommits(db, from, through, limit);\n      if (fileGeneration !== this.#fileGeneration) {\n        return this.#skipped('log-rebuilt');\n      }\n      const maxRowsPerSource = Math.max(\n        1,\n        this.#opts.maxRowsPerSourcePerCycle ??\n          DEFAULT_MAX_ROWS_PER_SOURCE_PER_CYCLE,\n      );\n      const maxBytesPerSource = Math.max(\n        1,\n        this.#opts.maxBytesPerSourcePerCycle ??\n          DEFAULT_MAX_BYTES_PER_SOURCE_PER_CYCLE,\n      );\n\n      let sqliteRowsRead = 0;\n      let pgRowsRead = 0;\n      let sqliteBytesRead = 0;\n      let pgBytesRead = 0;\n      let previousBoundary = from;\n      let handledThrough = from;\n      for (const {watermark, inSqlite, inPg} of union) {\n        if (this.#stopped) {\n          break;\n        }\n        let stopAfterTransaction = false;\n        if (!inSqlite || !inPg) {\n          // Check every transaction for presence because this needs no payload read.\n          const outcome = await this.#reconfirm(db, pinned, watermark);\n          record(\n            watermark,\n            fileGeneration === this.#fileGeneration ? outcome : 'inconclusive',\n          );\n        } else if (\n          isSampledForShard(this.#shard, watermark, this.#opts.comparePercent)\n        ) {\n          const sqliteRowsRemaining = maxRowsPerSource - sqliteRowsRead;\n          const pgRowsRemaining = maxRowsPerSource - pgRowsRead;\n          // A read may pass the byte budget by its last row, so this\n          // compares against zero rather than checking for equality.\n          const sqliteBytesRemaining = maxBytesPerSource - sqliteBytesRead;\n          const pgBytesRemaining = maxBytesPerSource - pgBytesRead;\n          if (\n            sqliteRowsRemaining === 0 ||\n            pgRowsRemaining === 0 ||\n            sqliteBytesRemaining <= 0 ||\n            pgBytesRemaining <= 0\n          ) {\n            record(watermark, 'deferred');\n            break;\n          }\n          sampled++;\n          const comparison = await this.#compareTransaction(\n            db,\n            reader,\n            pinned,\n            previousBoundary,\n            watermark,\n            sqliteRowsRemaining,\n            pgRowsRemaining,\n            sqliteBytesRemaining,\n            pgBytesRemaining,\n            maxRowsPerSource,\n            maxBytesPerSource,\n          );\n          sqliteRowsRead += comparison.sqliteRowsRead;\n          pgRowsRead += comparison.pgRowsRead;\n          sqliteBytesRead += comparison.sqliteBytesRead;\n          pgBytesRead += comparison.pgBytesRead;\n          const outcome =\n            fileGeneration === this.#fileGeneration\n              ? comparison.outcome\n              : 'inconclusive';\n          record(watermark, outcome);\n          if (outcome === 'inconclusive') {\n            break;\n          }\n          if (outcome === 'deferred') {\n            break;\n          }\n          if (outcome === 'oversized') {\n            // Advance past a transaction that cannot fit in a fresh budget.\n            stopAfterTransaction = true;\n          }\n          // Yield between sampled reads so other stream work can continue.\n          await this.#yield();\n        }\n        previousBoundary = watermark;\n        handledThrough = watermark;\n        transactions++;\n        if (stopAfterTransaction) {\n          break;\n        }\n      }\n\n      if (\n        !this.#stopped &&\n        fileGeneration === this.#fileGeneration &&\n        outcomes.inconclusive === 0\n      ) {\n        this.#cursor = handledThrough;\n        this.#continueWithoutDelay = handledThrough < through;\n      }\n      return this.#compared(\n        from,\n        handledThrough,\n        transactions,\n        sampled,\n        outcomes,\n      );\n    } catch (e) {\n      this.#lc.warn?.('error comparing the SQLite change log', e);\n      return this.#skipped('error');\n    } finally {\n      reader?.close();\n      db?.close();\n      this.#cycleDuration.recordMs(performance.now() - startedAt);\n    }\n  }\n\n  /** Checks log eligibility and reads the bounds from both stores. */\n  async #pinBounds(db: Database): Promise<PinnedBounds | CompareSkipReason> {\n    let meta: ChangeLogMeta;\n    try {\n      meta = readChangeLogMeta(db);\n    } catch {\n      // The writer has not initialized the log.\n      return 'log-unavailable';\n    }\n    if (meta.schemaVersion !== CHANGE_LOG_DB_SCHEMA_VERSION) {\n      return 'ineligible-schema';\n    }\n    const {epoch, generation, replicaID} = this.#identity;\n    if (\n      meta.epoch !== epoch ||\n      meta.generation !== generation ||\n      meta.replicaID !== replicaID\n    ) {\n      return 'ineligible-identity';\n    }\n    if (this.#now() - meta.seededAtMs < this.#opts.retentionMs) {\n      return 'cold-log';\n    }\n    const sqlite = this.#readSQLiteBounds(db);\n    if (sqlite === undefined) {\n      return 'log-unavailable';\n    }\n    const {minWatermark, lastWatermark} = await this.#pg.getCatchupBounds();\n    if (minWatermark === null) {\n      // Only a new replica has an empty Postgres change log.\n      return 'nothing-to-compare';\n    }\n    return {\n      meta,\n      sqlite,\n      pgMinWatermark: minWatermark,\n      pgLastWatermark: lastWatermark,\n    };\n  }\n\n  #readSQLiteBounds(db: Database): SQLiteBounds | undefined {\n    const bounds = db\n      .prepare(SQLITE_BOUNDS_SQL)\n      .get<{minWatermark: string | null; headWatermark: string | null}>();\n    return bounds.minWatermark === null || bounds.headWatermark === null\n      ? undefined\n      : {\n          minWatermark: bounds.minWatermark,\n          headWatermark: bounds.headWatermark,\n        };\n  }\n\n  /**\n   * Merges committed transaction watermarks from both stores.\n   * If a list reaches the limit, the result ends at the last complete common range.\n   */\n  async #enumerateCommits(\n    db: Database,\n    from: string,\n    through: string,\n    limit: number,\n  ): Promise<{watermark: string; inSqlite: boolean; inPg: boolean}[]> {\n    let sqlite: string[] = db\n      .prepare(SQLITE_COMMITS_SQL)\n      .all<{watermark: string}>({after: from, through, limit: limit + 1})\n      .map(({watermark}) => watermark);\n    let pg = await this.#pg.listCommitWatermarks(from, through, limit + 1);\n\n    let effectiveThrough = through;\n    if (sqlite.length > limit) {\n      sqlite.length = limit;\n      effectiveThrough = minWatermark(effectiveThrough, sqlite[limit - 1]);\n    }\n    if (pg.length > limit) {\n      pg.length = limit;\n      effectiveThrough = minWatermark(effectiveThrough, pg[limit - 1]);\n    }\n    if (effectiveThrough !== through) {\n      sqlite = sqlite.filter(w => w <= effectiveThrough);\n      pg = pg.filter(w => w <= effectiveThrough);\n    }\n\n    const union: {watermark: string; inSqlite: boolean; inPg: boolean}[] = [];\n    let s = 0;\n    let p = 0;\n    while (s < sqlite.length || p < pg.length) {\n      const sw = s < sqlite.length ? sqlite[s] : undefined;\n      const pw = p < pg.length ? pg[p] : undefined;\n      if (sw !== undefined && (pw === undefined || sw < pw)) {\n        union.push({watermark: sw, inSqlite: true, inPg: false});\n        s++;\n      } else if (pw !== undefined && (sw === undefined || pw < sw)) {\n        union.push({watermark: pw, inSqlite: false, inPg: true});\n        p++;\n      } else if (sw !== undefined) {\n        union.push({watermark: sw, inSqlite: true, inPg: true});\n        s++;\n        p++;\n      }\n    }\n    return union;\n  }\n\n  /**\n   * Compares the output in `(previousBoundary, watermark]`.\n   * Positional reads do not require either store to contain the boundary row.\n   */\n  async #compareTransaction(\n    db: Database,\n    reader: SQLiteChangeLogReader,\n    pinned: PinnedBounds,\n    previousBoundary: string,\n    watermark: string,\n    sqliteMaxRows: number,\n    pgMaxRows: number,\n    sqliteMaxBytes: number,\n    pgMaxBytes: number,\n    maxRowsPerSource: number,\n    maxBytesPerSource: number,\n  ): Promise<SampledComparison> {\n    let sqlite: CatchupRangeDigest;\n    let pg: CatchupRangeDigest;\n    try {\n      const readBatchRows = this.#opts.readBatchRows ?? DEFAULT_READ_BATCH_ROWS;\n      sqlite = await digestCatchupRange(\n        reader.read(\n          previousBoundary,\n          watermark,\n          Math.min(readBatchRows, sqliteMaxRows),\n          undefined,\n          sqliteMaxRows,\n        ),\n        watermark,\n        sqliteMaxRows,\n        sqliteMaxBytes,\n      );\n      pg = await digestCatchupRange(\n        reconstructBatches(\n          this.#pg.readCatchupRange(previousBoundary, watermark, pgMaxRows),\n        ),\n        watermark,\n        pgMaxRows,\n        pgMaxBytes,\n      );\n    } catch (e) {\n      // A failed catchup read makes the transaction suspect.\n      this.#lc.warn?.(\n        `error reading transaction ${watermark} for comparison`,\n        e,\n      );\n      return {\n        outcome: await this.#reconfirm(db, pinned, watermark),\n        sqliteRowsRead: 0,\n        pgRowsRead: 0,\n        sqliteBytesRead: 0,\n        pgBytesRead: 0,\n      };\n    }\n    const read = {\n      sqliteRowsRead: sqlite.rows,\n      pgRowsRead: pg.rows,\n      sqliteBytesRead: sqlite.bytes,\n      pgBytesRead: pg.bytes,\n    };\n    if (sqlite.limitReached || pg.limitReached) {\n      // Skip a transaction that cannot fit in a fresh budget.\n      // Defer one that does not fit only in the remaining budget.\n      // A budget is fresh when neither dimension has been spent.\n      const sqliteFresh =\n        sqliteMaxRows === maxRowsPerSource &&\n        sqliteMaxBytes === maxBytesPerSource;\n      const pgFresh =\n        pgMaxRows === maxRowsPerSource && pgMaxBytes === maxBytesPerSource;\n      const outcome =\n        (sqlite.limitReached && sqliteFresh) || (pg.limitReached && pgFresh)\n          ? 'oversized'\n          : 'deferred';\n      return {outcome, ...read};\n    }\n    if (sqlite.digest === pg.digest) {\n      return {outcome: 'match', ...read};\n    }\n    return {\n      outcome: await this.#reconfirm(db, pinned, watermark),\n      ...read,\n    };\n  }\n\n  /**\n   * Rechecks a suspect result against current store bounds.\n   * A moved bound, changed seed, failed read, or lower head makes the result inconclusive.\n   */\n  async #reconfirm(\n    db: Database,\n    pinned: PinnedBounds,\n    watermark: string,\n  ): Promise<'mismatch' | 'inconclusive'> {\n    try {\n      const meta = readChangeLogMeta(db);\n      if (\n        meta.seedWatermark !== pinned.meta.seedWatermark ||\n        meta.seededAtMs !== pinned.meta.seededAtMs\n      ) {\n        return 'inconclusive';\n      }\n      const sqlite = this.#readSQLiteBounds(db);\n      const {minWatermark, lastWatermark} = await this.#pg.getCatchupBounds();\n      if (sqlite === undefined || minWatermark === null) {\n        return 'inconclusive';\n      }\n      if (\n        (sqlite.minWatermark > pinned.sqlite.minWatermark &&\n          watermark <= sqlite.minWatermark) ||\n        (minWatermark > pinned.pgMinWatermark && watermark <= minWatermark) ||\n        watermark > sqlite.headWatermark ||\n        watermark > lastWatermark\n      ) {\n        return 'inconclusive';\n      }\n      return 'mismatch';\n    } catch {\n      return 'inconclusive';\n    }\n  }\n\n  #skipped(reason: CompareSkipReason): CompareCycleResult {\n    this.#compareCycles.add(1, {result: reason});\n    if (reason === 'error') {\n      // The caller logged the error.\n    } else if (reason !== 'nothing-to-compare') {\n      this.#lc.debug?.(`skipping SQLite change-log comparison: ${reason}`);\n    }\n    return {kind: 'skipped', reason};\n  }\n\n  #compared(\n    fromWatermark: string,\n    throughWatermark: string,\n    transactions: number,\n    sampled: number,\n    outcomes: Record<CompareOutcome, number>,\n  ): CompareCycleResult {\n    this.#compareCycles.add(1, {result: 'compared'});\n    const result = {\n      kind: 'compared',\n      fromWatermark,\n      throughWatermark,\n      transactions,\n      sampled,\n      matched: outcomes.match,\n      mismatched: outcomes.mismatch,\n      inconclusive: outcomes.inconclusive,\n      deferred: outcomes.deferred,\n      oversized: outcomes.oversized,\n    } as const;\n    this.#lc.debug?.('SQLite change-log comparison cycle', {\n      sqliteChangeLogCompare: result,\n    });\n    return result;\n  }\n}\n\n/** Applies the same reconstruction as Postgres catchup. */\nasync function* reconstructBatches(\n  batches: AsyncIterable<ChangeLogEntry[]>,\n): AsyncIterable<WatermarkedChange[]> {\n  for await (const batch of batches) {\n    yield batch.map(reconstructWatermarkedChange);\n  }\n}\n\nfunction minWatermark(a: string, b: string): string {\n  return a < b ? a : b;\n}\n\nfunction maxWatermark(...watermarks: string[]): string {\n  let max = watermarks[0];\n  for (const w of watermarks) {\n    if (w > max) {\n      max = w;\n    }\n  }\n  return max;\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/change-streamer/sqlite-change-log-purge-scheduler.d.ts

@@ -0,0 +1,121 @@
+import type { LogContext } from '@rocicorp/logger';
+import type { Database } from '../../../../zqlite/src/db.ts';
+import type { SQLiteChangeLogCleanupGuard } from './sqlite-change-log-catchup.ts';
+/** Why a pass stopped before draining the eligible set. */
+export type PurgeStopReason = 'stopped' | 'paused' | 'writer-unavailable' | 'subscriber-behind' | 'batch-limit' | 'error';
+/**
+ * The invariant-14 probe's classification of `plan(floor)` after a pass.
+ *
+ * `too-old` at the floor is not by itself a violation: a log that never held
+ * that history — routine at every fork, restore, and rolling restart — returns
+ * `too-old` without having purged anything. Only the seed point distinguishes
+ * the two, which is why `seedWatermark` is in the v2 meta row:
+ *
+ * ```
+ * violation  ⇔  plan(floor) is `too-old`  AND  seedWatermark <= floor
+ * ```
+ */
+export type FloorProbeOutcome = 'retained' | 'ahead' | 'cold-log' | 'violation';
+/** When the cleanup coordinator should run another pass. */
+export type PurgeContinuation = 'immediate' | 'deferred';
+export type PurgePassResult = {
+    /** The external floor the pass used. */
+    readonly floor: string;
+    readonly batches: number;
+    readonly deletedRows: number;
+    /** Why the pass ended before draining, if it did. */
+    readonly stopped: PurgeStopReason | undefined;
+    /** The invariant-14 probe's outcome, when the log was available to probe. */
+    readonly probe: FloorProbeOutcome | undefined;
+    /** Whether, and how soon, the cleanup coordinator should run another pass. */
+    readonly continuation: PurgeContinuation | undefined;
+};
+export type SQLiteChangeLogPurgeSchedulerOptions = {
+    /**
+     * `sqliteChangeLogRetentionMs`: the minimum retention window, ANDed on top
+     * of the external floor. It can only make purge more conservative — the
+     * purger never accepts it as a standalone bound.
+     */
+    readonly retentionMs: number;
+    /**
+     * `sqliteChangeLogPurgeBatchRows`: the starting chunk size per batch. Not
+     * the bound — the statement duration target is.
+     */
+    readonly batchRows: number;
+    readonly statementTargetMs?: number | undefined;
+    readonly maxBatchesPerPass?: number | undefined;
+    readonly inTransactionPollMs?: number | undefined;
+    /** The clock the retention cutoff is measured against. Defaults to `Date.now`. */
+    readonly now?: (() => number) | undefined;
+    readonly setTimeoutFn?: typeof setTimeout | undefined;
+    readonly clearTimeoutFn?: typeof clearTimeout | undefined;
+    /**
+     * Awaited between batches so fan-out and catchup make progress. Defaults to
+     * a macrotask (`setImmediate`), so pending I/O runs before the next batch.
+     */
+    readonly yieldFn?: (() => Promise<void>) | undefined;
+};
+/**
+ * Runs bounded SQLite change-log purge passes on the writer's own connection.
+ *
+ * The caller supplies the current durable cleanup floor independently of any
+ * other change-log implementation and owns the timing of subsequent passes.
+ * Within a pass this class drains bounded batches, re-checking live subscriber
+ * ACKs before each one and releasing the cleanup guard between them, so a
+ * catchup registration or snapshot reservation never waits longer than one
+ * batch.
+ *
+ * Purge windows exist only between the writer's commits: purge shares the
+ * writer's connection, so it cannot run inside the writer's open transaction,
+ * and a batch that finds one waits for the commit notification instead.
+ *
+ * The result tells the cleanup coordinator whether the next pass should be
+ * immediate or deferred. This class deliberately owns no cleanup timer: the
+ * same level-triggered coordinator continues a large drain, advances the
+ * retention clock on a quiet source, and retries changing external state.
+ */
+export declare class SQLiteChangeLogPurgeScheduler {
+    #private;
+    /**
+     * The guard that brackets catchup registration: required-head capture and
+     * `Forwarder.add()` run under the same mutex as purge batches, so the
+     * registered ACK is visible to `Forwarder.getAcks()` before the next batch
+     * evaluates its gate.
+     */
+    readonly cleanupGuard: SQLiteChangeLogCleanupGuard;
+    /**
+     * @param connection the writer's own connection (§3.3). `undefined` until
+     *     the writer's first reconcile creates the file, and again after the
+     *     writer fails soft and deletes it — both of which defer the pass rather
+     *     than fail it, so a later coordinator pass picks up a late-appearing
+     *     file without a restart.
+     * @param subscriberAcks live subscriber ACKs, re-read before every batch so
+     *     the supplied floor remains safe throughout an asynchronous drain.
+     */
+    constructor(lc: LogContext, connection: () => Database | undefined, subscriberAcks: () => Iterable<string>, opts: SQLiteChangeLogPurgeSchedulerOptions);
+    /**
+     * Runs one purge pass for the current durable cleanup `floor`.
+     * Never rejects; a failed pass is logged and reported as `stopped: 'error'`.
+     */
+    purge(floor: string): Promise<PurgePassResult>;
+    /**
+     * Pauses purging while `taskID` holds a snapshot reservation. The returned
+     * promise resolves once no purge batch is in flight, i.e. once the bounds a
+     * backup monitor is about to advertise cannot be invalidated by a batch
+     * that had already been dispatched.
+     */
+    pause(taskID: string): Promise<void>;
+    /**
+     * Ends one of `taskID`'s pauses. A later coordinator pass can purge once
+     * every reservation has ended. Unknown `taskID`s are ignored.
+     */
+    resume(taskID: string): void;
+    /**
+     * Notes that the writer's open transaction has ended, waking any batch
+     * waiting for a purge window. A missed notification costs one poll
+     * interval, never correctness.
+     */
+    onWriterIdle(): void;
+    stop(): void;
+}
+//# sourceMappingURL=sqlite-change-log-purge-scheduler.d.ts.map

package/out/zero-cache/src/services/change-streamer/sqlite-change-log-purge-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-change-log-purge-scheduler.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/sqlite-change-log-purge-scheduler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,QAAQ,EAAY,MAAM,8BAA8B,CAAC;AAWtE,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,gCAAgC,CAAC;AA2BhF,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAEvB,SAAS,GAET,QAAQ,GAGR,oBAAoB,GAIpB,mBAAmB,GAEnB,aAAa,GAEb,OAAO,CAAC;AAEZ;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,GAGzB,UAAU,GAGV,OAAO,GAIP,UAAU,GAIV,WAAW,CAAC;AAEhB,4DAA4D;AAC5D,MAAM,MAAM,iBAAiB,GAEzB,WAAW,GAGX,UAAU,CAAC;AAEf,MAAM,MAAM,eAAe,GAAG;IAC5B,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,SAAS,CAAC;IAC9C,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC9C,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,iBAAiB,GAAG,SAAS,CAAC;CACtD,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,kFAAkF;IAClF,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,UAAU,GAAG,SAAS,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,YAAY,GAAG,SAAS,CAAC;IAC1D;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;CACtD,CAAC;AA0CF;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,6BAA6B;;IAkExC;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,2BAA2B,CAEhD;IAEF;;;;;;;;OAQG;gBAED,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,MAAM,QAAQ,GAAG,SAAS,EACtC,cAAc,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,EACtC,IAAI,EAAE,oCAAoC;IAsB5C;;;OAGG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAapD;;;;;OAKG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKpC;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAY5B;;;;OAIG;IACH,YAAY,IAAI,IAAI;IAOpB,IAAI,IAAI,IAAI;CAiRb"}