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

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

@@ -0,0 +1,261 @@
+import { AbortError } from "../../../../shared/src/abort-error.js";
+import { sleep } from "../../../../shared/src/sleep.js";
+import { getOrCreateCounter } from "../../observability/metrics.js";
+import { resolver } from "@rocicorp/resolver";
+//#region ../zero-cache/src/services/change-streamer/sqlite-change-log-catchup.ts
+var DEFAULT_BARRIER_POLL_INTERVAL_MS = 1e3;
+var NOOP_CLEANUP_GUARD = { runWhilePurgeBlocked: (register) => Promise.resolve(register()) };
+/**
+* Coordinates a serving subscriber's gap-free transition from replica-local
+* SQLite catchup to the Forwarder's live stream.
+*
+* Registration and required-head capture happen in one synchronous callback.
+* The subscriber therefore either sees a transaction in SQLite catchup or in
+* its live backlog (duplicates across that boundary are filtered by
+* Subscriber), never in neither place.
+*/
+var SQLiteChangeLogCatchup = class {
+	#lc;
+	#forwarder;
+	#reader;
+	#batchSize;
+	#barrierTimeoutMs;
+	#barrierPollIntervalMs;
+	#cleanupGuard;
+	#sleep;
+	#now;
+	#barrierTimeouts = getOrCreateCounter("replication", "sqlite_change_log.barrier_timeouts", "SQLite change-log catchups that timed out waiting for the required head.");
+	#barrierBacklogOverflows = getOrCreateCounter("replication", "sqlite_change_log.barrier_backlog_overflows", "SQLite change-log catchups abandoned because the subscriber backlog reached its high water mark while waiting for the required head.");
+	#barrierWakeups = getOrCreateCounter("replication", "sqlite_change_log.barrier_wakeups", "SQLite catchup barrier waits, labeled by what ended the wait. A population dominated by \"poll\" means the change-log writer's commit notification is not reaching the barrier.");
+	#catchups = /* @__PURE__ */ new Map();
+	#commitWaiters = /* @__PURE__ */ new Set();
+	#closed = false;
+	constructor(lc, forwarder, reader, opts) {
+		this.#lc = lc.withContext("component", "sqlite-change-log-catchup");
+		this.#forwarder = forwarder;
+		this.#reader = reader;
+		this.#batchSize = opts.batchSize;
+		this.#barrierTimeoutMs = opts.barrierTimeoutMs;
+		this.#barrierPollIntervalMs = opts.barrierPollIntervalMs ?? DEFAULT_BARRIER_POLL_INTERVAL_MS;
+		this.#cleanupGuard = opts.cleanupGuard ?? NOOP_CLEANUP_GUARD;
+		this.#sleep = opts.sleep ?? sleep;
+		this.#now = opts.now ?? Date.now;
+	}
+	/**
+	* Registers the subscriber before resolving. Catchup itself continues in
+	* the background so subscribe() does not wait for SQLite to reach the
+	* required head.
+	*/
+	async catchup(subscriber, captureRequiredHead) {
+		if (this.#closed) {
+			subscriber.fail(new AbortError("SQLite change-log catchup is closed"));
+			return;
+		}
+		const abort = new AbortController();
+		this.#catchups.set(subscriber, abort);
+		let requiredHead;
+		try {
+			await this.#cleanupGuard.runWhilePurgeBlocked(() => {
+				this.#throwIfAborted(abort.signal);
+				requiredHead = captureRequiredHead();
+				this.#forwarder.add(subscriber);
+			});
+		} catch (error) {
+			this.#catchups.delete(subscriber);
+			if (!abort.signal.aborted) {
+				this.#lc.error?.(`error while registering SQLite catchup subscriber ${subscriber.id}`, error);
+				subscriber.fail(error);
+			}
+			return;
+		}
+		this.#run(subscriber, requiredHead, abort);
+	}
+	/**
+	* Notes that the change-log writer has committed `watermark`, i.e. that the
+	* log's head has advanced to it. The writer runs in this process, so this is
+	* the event itself rather than a subscriber's ACK of it.
+	*
+	* It is a wakeup, not an authority: `plan()` still decides what can be read.
+	* A notification that never arrives costs the barrier a poll interval, and one
+	* that arrives early costs an extra `plan()` call.
+	*/
+	onChangeLogCommit(watermark) {
+		for (const waiter of this.#commitWaiters) if (watermark >= waiter.watermark) {
+			this.#commitWaiters.delete(waiter);
+			waiter.resolve();
+		}
+	}
+	remove(subscriber) {
+		this.#catchups.get(subscriber)?.abort();
+		this.#catchups.delete(subscriber);
+		this.#forwarder.remove(subscriber);
+	}
+	close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		for (const [subscriber, abort] of this.#catchups) {
+			abort.abort();
+			this.#forwarder.remove(subscriber);
+		}
+		this.#catchups.clear();
+		this.#reader.close();
+	}
+	[Symbol.dispose]() {
+		this.close();
+	}
+	async #run(subscriber, requiredHead, abort) {
+		const { signal } = abort;
+		try {
+			const requiredHeadStart = this.#now();
+			const required = await this.#awaitRequiredHead(requiredHead, signal);
+			const requiredHeadWaitMs = this.#now() - requiredHeadStart;
+			if (requiredHeadWaitMs > this.#barrierTimeoutMs) this.#lc.info?.(`waited ${requiredHeadWaitMs} ms for the forwarded transaction to commit before starting the SQLite barrier for ${subscriber.id}`);
+			const deadline = this.#now() + this.#barrierTimeoutMs;
+			const plan = await this.#waitForPlan(subscriber, required, deadline, signal);
+			this.#throwIfAborted(signal);
+			if (plan.kind === "too-old") {
+				const message = `earliest supported watermark is ${plan.minWatermark} (requested ${subscriber.watermark})`;
+				this.#lc.warn?.(`rejecting subscriber at watermark ${subscriber.watermark} (earliest watermark: ${plan.minWatermark})`);
+				subscriber.close(2, message);
+				return;
+			}
+			let count = 0;
+			const start = this.#now();
+			if (plan.kind === "range") {
+				let lastBatchConsumed;
+				for await (const changes of this.#reader.read(subscriber.watermark, plan.headWatermark, this.#batchSize, signal)) {
+					const waitStart = this.#now();
+					await lastBatchConsumed;
+					const elapsed = this.#now() - waitStart;
+					if (lastBatchConsumed) this.#lc[elapsed > 100 ? "info" : "debug"]?.(`waited ${elapsed.toFixed(3)} ms for ${subscriber.id} to consume the previous SQLite catchup batch`);
+					this.#throwIfAborted(signal);
+					for (const change of changes) {
+						lastBatchConsumed = subscriber.catchup(change);
+						count++;
+					}
+				}
+				await lastBatchConsumed;
+			} else this.#lc.warn?.(`subscriber ${subscriber.id} at watermark ${subscriber.watermark} is ahead of the SQLite change-log head ${plan.headWatermark}; waiting for the replica to catch up`);
+			this.#throwIfAborted(signal);
+			this.#lc.info?.(`caught up ${subscriber.id} from SQLite with ${count} changes (${this.#now() - start} ms)`);
+			subscriber.setCaughtUp();
+		} catch (error) {
+			if (signal.aborted) return;
+			if (error instanceof SQLiteChangeLogBarrierError) {
+				if (error instanceof SQLiteChangeLogBarrierTimeoutError) this.#barrierTimeouts.add(1);
+				this.#lc.warn?.(`ending subscription for ${subscriber.id} to retry SQLite catchup`, error);
+				subscriber.close();
+				return;
+			}
+			this.#lc.error?.(`error while catching up subscriber ${subscriber.id} from SQLite`, error);
+			subscriber.fail(error);
+		} finally {
+			if (this.#catchups.get(subscriber) === abort) this.#catchups.delete(subscriber);
+		}
+	}
+	/**
+	* Waits for the transaction that was in flight at registration to finish.
+	*
+	* This wait is bounded by the upstream transaction rather than by
+	* `barrierTimeoutMs`: the completion settles on both commit and rollback,
+	* and an interrupted change stream forwards a synthetic rollback, so it
+	* always settles. Aborting -- the subscriber disconnecting or the service
+	* shutting down -- is what releases it early.
+	*/
+	async #awaitRequiredHead(requiredHead, signal) {
+		if (typeof requiredHead === "string") return requiredHead;
+		this.#throwIfAborted(signal);
+		let onAbort;
+		try {
+			return await Promise.race([requiredHead, new Promise((_, reject) => {
+				onAbort = () => reject(new AbortError("SQLite change-log catchup aborted"));
+				signal.addEventListener("abort", onAbort, { once: true });
+			})]);
+		} finally {
+			if (onAbort) signal.removeEventListener("abort", onAbort);
+		}
+	}
+	async #waitForPlan(subscriber, requiredHead, deadline, signal) {
+		const backlogFull = subscriber.whenBacklogFull();
+		const barrier = new AbortController();
+		const abortBarrier = () => barrier.abort();
+		signal.addEventListener("abort", abortBarrier, { once: true });
+		if (signal.aborted) barrier.abort();
+		let observedHead = subscriber.watermark;
+		try {
+			const planReady = (async () => {
+				while (true) {
+					this.#throwIfAborted(barrier.signal);
+					const plan = this.#reader.plan(subscriber.watermark);
+					if (plan.kind !== "not-ready") {
+						observedHead = plan.headWatermark;
+						if (plan.headWatermark >= requiredHead) return plan;
+					}
+					const remaining = deadline - this.#now();
+					if (remaining <= 0) throw new SQLiteChangeLogBarrierTimeoutError(`timed out waiting for SQLite head ${observedHead} to reach required head ${requiredHead}`);
+					await this.#awaitChangeLogProgress(requiredHead, remaining, barrier.signal);
+				}
+			})();
+			const backlogOverflow = backlogFull.promise.then(() => {
+				this.#throwIfAborted(signal);
+				if (!subscriber.backlogFull) return new Promise(() => {});
+				this.#barrierWakeups.add(1, { "wakeup.source": "backlog" });
+				this.#barrierBacklogOverflows.add(1);
+				throw new SQLiteChangeLogBarrierBacklogError(`backlog for subscriber ${subscriber.id} reached its high water mark while waiting for SQLite head ${observedHead} to reach required head ${requiredHead}`);
+			});
+			return await Promise.race([planReady, backlogOverflow]);
+		} finally {
+			signal.removeEventListener("abort", abortBarrier);
+			barrier.abort();
+			backlogFull.cancel();
+		}
+	}
+	/**
+	* Waits for the change-log writer to commit `requiredHead`, or the poll
+	* interval as a backstop.
+	*
+	* No notification can be missed by registering after `plan()` was read: the
+	* notification follows the commit it reports, so if the writer had already
+	* committed `requiredHead`, `plan()` would have seen it.
+	*/
+	async #awaitChangeLogProgress(requiredHead, remainingMs, signal) {
+		const committed = resolver();
+		const waiter = {
+			watermark: requiredHead,
+			resolve: committed.resolve
+		};
+		this.#commitWaiters.add(waiter);
+		const poll = new AbortController();
+		const abortPoll = () => poll.abort();
+		signal.addEventListener("abort", abortPoll, { once: true });
+		try {
+			const wokenBy = await Promise.race([committed.promise.then(() => "commit"), this.#sleep(Math.min(this.#barrierPollIntervalMs, remainingMs), poll.signal).then(() => "poll")]);
+			this.#barrierWakeups.add(1, { "wakeup.source": wokenBy });
+		} finally {
+			this.#commitWaiters.delete(waiter);
+			signal.removeEventListener("abort", abortPoll);
+			poll.abort();
+		}
+	}
+	#throwIfAborted(signal) {
+		if (this.#closed || signal.aborted) throw new AbortError("SQLite change-log catchup aborted");
+	}
+};
+/**
+* A barrier that gave up on the replica reaching the required head. Both
+* reasons mean "not yet", not "never", so both end the subscription cleanly
+* for a retry rather than failing it.
+*/
+var SQLiteChangeLogBarrierError = class extends Error {};
+/** The replica did not reach the required head before the deadline. */
+var SQLiteChangeLogBarrierTimeoutError = class extends SQLiteChangeLogBarrierError {
+	name = "SQLiteChangeLogBarrierTimeoutError";
+};
+/** Waiting any longer would have cost more than reconnecting. */
+var SQLiteChangeLogBarrierBacklogError = class extends SQLiteChangeLogBarrierError {
+	name = "SQLiteChangeLogBarrierBacklogError";
+};
+//#endregion
+export { SQLiteChangeLogCatchup };
+
+//# sourceMappingURL=sqlite-change-log-catchup.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-change-log-catchup.js","names":["#lc","#forwarder","#reader","#batchSize","#barrierTimeoutMs","#barrierPollIntervalMs","#cleanupGuard","#sleep","#now","#barrierTimeouts","#barrierBacklogOverflows","#barrierWakeups","#catchups","#commitWaiters","#closed","#throwIfAborted","#run","#awaitRequiredHead","#waitForPlan","#awaitChangeLogProgress"],"sources":["../../../../../../zero-cache/src/services/change-streamer/sqlite-change-log-catchup.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport {AbortError} from '../../../../shared/src/abort-error.ts';\nimport {sleep} from '../../../../shared/src/sleep.ts';\nimport {getOrCreateCounter} from '../../observability/metrics.ts';\nimport type {WatermarkedChange} from './change-streamer.ts';\nimport * as ErrorType from './error-type-enum.ts';\nimport type {Forwarder} from './forwarder.ts';\nimport type {CatchupPlan} from './sqlite-change-log-reader.ts';\nimport type {Subscriber} from './subscriber.ts';\n\nexport interface SQLiteChangeLogCatchupReader {\n  plan(fromWatermark: string): CatchupPlan;\n  read(\n    fromWatermark: string,\n    throughWatermark: string,\n    batchSize: number,\n    signal?: AbortSignal,\n  ): AsyncIterable<readonly WatermarkedChange[]>;\n  close(): void;\n}\n\n/**\n * Slice 9 replaces this no-op implementation with a guard that waits for an\n * in-flight purge and blocks new purge dispatch while the subscriber's ACK is\n * made visible to the Forwarder.\n */\nexport interface SQLiteChangeLogCleanupGuard {\n  runWhilePurgeBlocked<T>(register: () => T): Promise<T>;\n}\n\n// How long the barrier waits for the change-log writer's commit notification\n// before re-reading the log itself. The notification normally arrives first, so\n// this is a backstop for the windows in which none is coming: the writer is\n// disabled, or it is between stream connections.\nconst DEFAULT_BARRIER_POLL_INTERVAL_MS = 1000;\n\nexport type SQLiteChangeLogCatchupOptions = {\n  batchSize: number;\n  barrierTimeoutMs: number;\n  barrierPollIntervalMs?: number | undefined;\n  cleanupGuard?: SQLiteChangeLogCleanupGuard | undefined;\n  sleep?: typeof sleep | undefined;\n  now?: (() => number) | undefined;\n};\n\nconst NOOP_CLEANUP_GUARD: SQLiteChangeLogCleanupGuard = {\n  runWhilePurgeBlocked: register => Promise.resolve(register()),\n};\n\n/**\n * Coordinates a serving subscriber's gap-free transition from replica-local\n * SQLite catchup to the Forwarder's live stream.\n *\n * Registration and required-head capture happen in one synchronous callback.\n * The subscriber therefore either sees a transaction in SQLite catchup or in\n * its live backlog (duplicates across that boundary are filtered by\n * Subscriber), never in neither place.\n */\nexport class SQLiteChangeLogCatchup implements Disposable {\n  readonly #lc: LogContext;\n  readonly #forwarder: Forwarder;\n  readonly #reader: SQLiteChangeLogCatchupReader;\n  readonly #batchSize: number;\n  readonly #barrierTimeoutMs: number;\n  readonly #barrierPollIntervalMs: number;\n  readonly #cleanupGuard: SQLiteChangeLogCleanupGuard;\n  readonly #sleep: typeof sleep;\n  readonly #now: () => number;\n  readonly #barrierTimeouts = getOrCreateCounter(\n    'replication',\n    'sqlite_change_log.barrier_timeouts',\n    'SQLite change-log catchups that timed out waiting for the required head.',\n  );\n  readonly #barrierBacklogOverflows = getOrCreateCounter(\n    'replication',\n    'sqlite_change_log.barrier_backlog_overflows',\n    'SQLite change-log catchups abandoned because the subscriber backlog ' +\n      'reached its high water mark while waiting for the required head.',\n  );\n  readonly #barrierWakeups = getOrCreateCounter(\n    'replication',\n    'sqlite_change_log.barrier_wakeups',\n    'SQLite catchup barrier waits, labeled by what ended the wait. A ' +\n      'population dominated by \"poll\" means the change-log writer\\'s commit ' +\n      'notification is not reaching the barrier.',\n  );\n  readonly #catchups = new Map<Subscriber, AbortController>();\n  readonly #commitWaiters = new Set<CommitWaiter>();\n  #closed = false;\n\n  constructor(\n    lc: LogContext,\n    forwarder: Forwarder,\n    reader: SQLiteChangeLogCatchupReader,\n    opts: SQLiteChangeLogCatchupOptions,\n  ) {\n    this.#lc = lc.withContext('component', 'sqlite-change-log-catchup');\n    this.#forwarder = forwarder;\n    this.#reader = reader;\n    this.#batchSize = opts.batchSize;\n    this.#barrierTimeoutMs = opts.barrierTimeoutMs;\n    this.#barrierPollIntervalMs =\n      opts.barrierPollIntervalMs ?? DEFAULT_BARRIER_POLL_INTERVAL_MS;\n    this.#cleanupGuard = opts.cleanupGuard ?? NOOP_CLEANUP_GUARD;\n    this.#sleep = opts.sleep ?? sleep;\n    this.#now = opts.now ?? Date.now;\n  }\n\n  /**\n   * Registers the subscriber before resolving. Catchup itself continues in\n   * the background so subscribe() does not wait for SQLite to reach the\n   * required head.\n   */\n  async catchup(\n    subscriber: Subscriber,\n    captureRequiredHead: () => string | Promise<string>,\n  ): Promise<void> {\n    if (this.#closed) {\n      subscriber.fail(new AbortError('SQLite change-log catchup is closed'));\n      return;\n    }\n\n    const abort = new AbortController();\n    this.#catchups.set(subscriber, abort);\n    let requiredHead: string | Promise<string> | undefined;\n    try {\n      await this.#cleanupGuard.runWhilePurgeBlocked(() => {\n        this.#throwIfAborted(abort.signal);\n        requiredHead = captureRequiredHead();\n        this.#forwarder.add(subscriber);\n      });\n    } catch (error) {\n      this.#catchups.delete(subscriber);\n      if (!abort.signal.aborted) {\n        this.#lc.error?.(\n          `error while registering SQLite catchup subscriber ${subscriber.id}`,\n          error,\n        );\n        subscriber.fail(error);\n      }\n      return;\n    }\n\n    void this.#run(subscriber, requiredHead as string | Promise<string>, abort);\n  }\n\n  /**\n   * Notes that the change-log writer has committed `watermark`, i.e. that the\n   * log's head has advanced to it. The writer runs in this process, so this is\n   * the event itself rather than a subscriber's ACK of it.\n   *\n   * It is a wakeup, not an authority: `plan()` still decides what can be read.\n   * A notification that never arrives costs the barrier a poll interval, and one\n   * that arrives early costs an extra `plan()` call.\n   */\n  onChangeLogCommit(watermark: string): void {\n    for (const waiter of this.#commitWaiters) {\n      if (watermark >= waiter.watermark) {\n        this.#commitWaiters.delete(waiter);\n        waiter.resolve();\n      }\n    }\n  }\n\n  remove(subscriber: Subscriber): void {\n    this.#catchups.get(subscriber)?.abort();\n    this.#catchups.delete(subscriber);\n    this.#forwarder.remove(subscriber);\n  }\n\n  close(): void {\n    if (this.#closed) {\n      return;\n    }\n    this.#closed = true;\n    for (const [subscriber, abort] of this.#catchups) {\n      abort.abort();\n      this.#forwarder.remove(subscriber);\n    }\n    this.#catchups.clear();\n    this.#reader.close();\n  }\n\n  [Symbol.dispose](): void {\n    this.close();\n  }\n\n  async #run(\n    subscriber: Subscriber,\n    requiredHead: string | Promise<string>,\n    abort: AbortController,\n  ): Promise<void> {\n    const {signal} = abort;\n    try {\n      const requiredHeadStart = this.#now();\n      const required = await this.#awaitRequiredHead(requiredHead, signal);\n      const requiredHeadWaitMs = this.#now() - requiredHeadStart;\n      if (requiredHeadWaitMs > this.#barrierTimeoutMs) {\n        this.#lc.info?.(\n          `waited ${requiredHeadWaitMs} ms for the forwarded transaction to ` +\n            `commit before starting the SQLite barrier for ${subscriber.id}`,\n        );\n      }\n      // The barrier bounds replica lag, not upstream transaction duration, so\n      // its deadline starts once the required head is known. Sharing one\n      // deadline with the wait above would fail subscribers that registered\n      // during a transaction longer than barrierTimeoutMs, however current\n      // the replica is.\n      const deadline = this.#now() + this.#barrierTimeoutMs;\n      const plan = await this.#waitForPlan(\n        subscriber,\n        required,\n        deadline,\n        signal,\n      );\n      this.#throwIfAborted(signal);\n\n      if (plan.kind === 'too-old') {\n        const message =\n          `earliest supported watermark is ${plan.minWatermark} ` +\n          `(requested ${subscriber.watermark})`;\n        this.#lc.warn?.(\n          `rejecting subscriber at watermark ${subscriber.watermark} ` +\n            `(earliest watermark: ${plan.minWatermark})`,\n        );\n        subscriber.close(ErrorType.WatermarkTooOld, message);\n        return;\n      }\n\n      let count = 0;\n      const start = this.#now();\n      if (plan.kind === 'range') {\n        let lastBatchConsumed: Promise<unknown> | undefined;\n        for await (const changes of this.#reader.read(\n          subscriber.watermark,\n          plan.headWatermark,\n          this.#batchSize,\n          signal,\n        )) {\n          const waitStart = this.#now();\n          await lastBatchConsumed;\n          const elapsed = this.#now() - waitStart;\n          if (lastBatchConsumed) {\n            this.#lc[elapsed > 100 ? 'info' : 'debug']?.(\n              `waited ${elapsed.toFixed(3)} ms for ${subscriber.id} to consume ` +\n                `the previous SQLite catchup batch`,\n            );\n          }\n          this.#throwIfAborted(signal);\n          for (const change of changes) {\n            lastBatchConsumed = subscriber.catchup(change);\n            count++;\n          }\n        }\n        await lastBatchConsumed;\n      } else {\n        this.#lc.warn?.(\n          `subscriber ${subscriber.id} at watermark ${subscriber.watermark} ` +\n            `is ahead of the SQLite change-log head ${plan.headWatermark}; ` +\n            `waiting for the replica to catch up`,\n        );\n      }\n\n      this.#throwIfAborted(signal);\n      this.#lc.info?.(\n        `caught up ${subscriber.id} from SQLite with ${count} changes ` +\n          `(${this.#now() - start} ms)`,\n      );\n      // Keep buffering live sends until the asynchronous backlog drain has\n      // established its ordering boundary.\n      void subscriber.setCaughtUp();\n    } catch (error) {\n      if (signal.aborted) {\n        return;\n      }\n      if (error instanceof SQLiteChangeLogBarrierError) {\n        if (error instanceof SQLiteChangeLogBarrierTimeoutError) {\n          this.#barrierTimeouts.add(1);\n        }\n        // Giving up on the barrier means the replica has not caught up *yet*,\n        // not that it cannot serve this subscriber. End the subscription\n        // cleanly so the client reconnects and retries: IncrementalSyncer\n        // treats any ['error', ...] message as terminal and restores a fresh\n        // replica from litestream, whereas a clean end backs off and\n        // re-subscribes. If retries keep failing until the change log is purged\n        // past the subscriber's watermark, plan() returns 'too-old', which is\n        // terminal by design.\n        this.#lc.warn?.(\n          `ending subscription for ${subscriber.id} to retry SQLite catchup`,\n          error,\n        );\n        subscriber.close();\n        return;\n      }\n      this.#lc.error?.(\n        `error while catching up subscriber ${subscriber.id} from SQLite`,\n        error,\n      );\n      subscriber.fail(error);\n    } finally {\n      if (this.#catchups.get(subscriber) === abort) {\n        this.#catchups.delete(subscriber);\n      }\n    }\n  }\n\n  /**\n   * Waits for the transaction that was in flight at registration to finish.\n   *\n   * This wait is bounded by the upstream transaction rather than by\n   * `barrierTimeoutMs`: the completion settles on both commit and rollback,\n   * and an interrupted change stream forwards a synthetic rollback, so it\n   * always settles. Aborting -- the subscriber disconnecting or the service\n   * shutting down -- is what releases it early.\n   */\n  async #awaitRequiredHead(\n    requiredHead: string | Promise<string>,\n    signal: AbortSignal,\n  ): Promise<string> {\n    if (typeof requiredHead === 'string') {\n      return requiredHead;\n    }\n    this.#throwIfAborted(signal);\n    let onAbort: (() => void) | undefined;\n    try {\n      return await Promise.race([\n        requiredHead,\n        new Promise<never>((_, reject) => {\n          onAbort = () =>\n            reject(new AbortError('SQLite change-log catchup aborted'));\n          signal.addEventListener('abort', onAbort, {once: true});\n        }),\n      ]);\n    } finally {\n      if (onAbort) {\n        signal.removeEventListener('abort', onAbort);\n      }\n    }\n  }\n\n  async #waitForPlan(\n    subscriber: Subscriber,\n    requiredHead: string,\n    deadline: number,\n    signal: AbortSignal,\n  ): Promise<Exclude<CatchupPlan, {kind: 'not-ready'}>> {\n    // Race backlog growth once around the whole polling loop. Attaching the\n    // same unresolved promise to every per-poll race would retain one reaction\n    // per iteration until the subscriber's backlog eventually filled.\n    const backlogFull = subscriber.whenBacklogFull();\n    const barrier = new AbortController();\n    const abortBarrier = () => barrier.abort();\n    signal.addEventListener('abort', abortBarrier, {once: true});\n    if (signal.aborted) {\n      barrier.abort();\n    }\n\n    let observedHead = subscriber.watermark;\n    try {\n      const planReady = (async () => {\n        while (true) {\n          this.#throwIfAborted(barrier.signal);\n          const plan = this.#reader.plan(subscriber.watermark);\n          // A not-ready log has no head to compare, so it can never satisfy\n          // the required head: keep waiting for the writer to create and\n          // reconcile it, and let the barrier deadline end the subscription\n          // cleanly for a retry. Selection declines a not-ready log before a\n          // subscriber gets here, and neither purging nor reconciliation can\n          // empty a log that had content, so this is a belt-and-braces path.\n          if (plan.kind !== 'not-ready') {\n            observedHead = plan.headWatermark;\n            if (plan.headWatermark >= requiredHead) {\n              return plan;\n            }\n          }\n          const remaining = deadline - this.#now();\n          if (remaining <= 0) {\n            throw new SQLiteChangeLogBarrierTimeoutError(\n              `timed out waiting for SQLite head ${observedHead} to ` +\n                `reach required head ${requiredHead}`,\n            );\n          }\n          await this.#awaitChangeLogProgress(\n            requiredHead,\n            remaining,\n            barrier.signal,\n          );\n        }\n      })();\n\n      const backlogOverflow = backlogFull.promise.then(() => {\n        this.#throwIfAborted(signal);\n        // close() also resolves backlog waiters so none are stranded. The\n        // backlog is cleared first, which distinguishes close from overflow.\n        if (!subscriber.backlogFull) {\n          return new Promise<never>(() => {});\n        }\n        this.#barrierWakeups.add(1, {'wakeup.source': 'backlog'});\n        // Bytes, not time, are what the barrier actually costs: past the high\n        // water mark this subscriber's send() no longer resolves, so it holds\n        // up every flush and can stall the replica this barrier waits on.\n        this.#barrierBacklogOverflows.add(1);\n        throw new SQLiteChangeLogBarrierBacklogError(\n          `backlog for subscriber ${subscriber.id} reached its high water ` +\n            `mark while waiting for SQLite head ${observedHead} to ` +\n            `reach required head ${requiredHead}`,\n        );\n      });\n\n      return await Promise.race([planReady, backlogOverflow]);\n    } finally {\n      signal.removeEventListener('abort', abortBarrier);\n      barrier.abort();\n      backlogFull.cancel();\n    }\n  }\n\n  /**\n   * Waits for the change-log writer to commit `requiredHead`, or the poll\n   * interval as a backstop.\n   *\n   * No notification can be missed by registering after `plan()` was read: the\n   * notification follows the commit it reports, so if the writer had already\n   * committed `requiredHead`, `plan()` would have seen it.\n   */\n  async #awaitChangeLogProgress(\n    requiredHead: string,\n    remainingMs: number,\n    signal: AbortSignal,\n  ): Promise<void> {\n    const committed = resolver<void>();\n    const waiter = {watermark: requiredHead, resolve: committed.resolve};\n    this.#commitWaiters.add(waiter);\n    // Scopes the backstop timer to this wait so that a commit cancels it rather\n    // than leaving it to fire against a barrier that has already moved on.\n    const poll = new AbortController();\n    const abortPoll = () => poll.abort();\n    signal.addEventListener('abort', abortPoll, {once: true});\n    try {\n      const wokenBy = await Promise.race([\n        committed.promise.then(() => 'commit' as const),\n        this.#sleep(\n          Math.min(this.#barrierPollIntervalMs, remainingMs),\n          poll.signal,\n        ).then(() => 'poll' as const),\n      ]);\n      this.#barrierWakeups.add(1, {'wakeup.source': wokenBy});\n    } finally {\n      this.#commitWaiters.delete(waiter);\n      signal.removeEventListener('abort', abortPoll);\n      poll.abort();\n    }\n  }\n\n  #throwIfAborted(signal: AbortSignal): void {\n    if (this.#closed || signal.aborted) {\n      throw new AbortError('SQLite change-log catchup aborted');\n    }\n  }\n}\n\ntype CommitWaiter = {watermark: string; resolve: () => void};\n\n/**\n * A barrier that gave up on the replica reaching the required head. Both\n * reasons mean \"not yet\", not \"never\", so both end the subscription cleanly\n * for a retry rather than failing it.\n */\nexport class SQLiteChangeLogBarrierError extends Error {}\n\n/** The replica did not reach the required head before the deadline. */\nexport class SQLiteChangeLogBarrierTimeoutError extends SQLiteChangeLogBarrierError {\n  readonly name = 'SQLiteChangeLogBarrierTimeoutError';\n}\n\n/** Waiting any longer would have cost more than reconnecting. */\nexport class SQLiteChangeLogBarrierBacklogError extends SQLiteChangeLogBarrierError {\n  readonly name = 'SQLiteChangeLogBarrierBacklogError';\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"}