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

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

@@ -0,0 +1,270 @@
+import { assert } from "../../../../shared/src/asserts.js";
+import { must } from "../../../../shared/src/must.js";
+import { BigIntJSON } from "../../../../shared/src/bigint-json.js";
+import { schemaChangeTags } from "../change-source/protocol/current/schema-change-tags.js";
+import { Database } from "../../../../zqlite/src/db.js";
+import { getOrCreateCounter } from "../../observability/metrics.js";
+import { backfillRequestsFrom, foldCookies } from "../replicator/change-log-cookies.js";
+import { readBackfillRequests, readReplicaCookies } from "../replicator/schema/backfilling.js";
+import { getReplicationState } from "../replicator/schema/replication-state.js";
+import { StatementRunner } from "../../db/statements.js";
+import { CHANGE_LOG_STREAM_TABLE } from "../replicator/change-log-db.js";
+import { SQLITE_CHANGE_LOG_BOUNDARY_SQL } from "./sqlite-change-log-reader.js";
+//#region ../zero-cache/src/services/change-streamer/change-log-initializer.ts
+/**
+* The most change-log rows one comparison will scan.
+*
+* The interval is `(replicaWatermark, pgWatermark]`, so it is normally a
+* handful of transactions — but a replicator that has been stalled can leave it
+* arbitrarily large, and this runs on the stream loop between reconciliation and
+* `startStream`, where latency delays the resumption of replication. Over the
+* cap the comparison declines rather than pays: a chronically lagging replicator
+* shows up as `inconclusive`, which is charted, and not as a stall.
+*/
+var MAX_FOLD_SCAN_ROWS = 1e4;
+var ChangeLogInitializer = class {
+	#lc;
+	#initFromPgChangeLog;
+	#initFromReplica;
+	#sources;
+	#resultCounter = getOrCreateCounter("replica", "sqlite_change_log.init_compare_result", "Comparisons of the replica-derived stream initialization parameters against the Postgres-derived ones, by classification.");
+	#lastComparison;
+	constructor(lc, { initFromPgChangeLog, initFromReplica }, sources) {
+		assert(initFromPgChangeLog || initFromReplica, `At least one of initFromPgChangeLog or initFromReplica must be true`);
+		this.#lc = lc.withContext("component", "change-log-initializer");
+		this.#initFromPgChangeLog = initFromPgChangeLog;
+		this.#initFromReplica = initFromReplica;
+		this.#sources = sources;
+	}
+	/**
+	* Returns the comparison result from the most recent {@link initialize}
+	* call. Returns `undefined` when that call used only one source.
+	*
+	* Tests and metrics use this result. It does not affect initialization.
+	*/
+	lastComparison() {
+		return this.#lastComparison;
+	}
+	/**
+	* Returns the initialization parameters for one stream connection after it
+	* reconciles the change log.
+	*
+	* The selected source determines how reconciliation works. Keeping both
+	* operations here hides that choice from the caller.
+	*/
+	async initialize() {
+		this.#lastComparison = void 0;
+		const pg = this.#initFromPgChangeLog ? await this.#sources.pgChangeLog() : void 0;
+		const replica = this.#initFromReplica ? this.#readReplica(pg === void 0) : void 0;
+		const reconciled = this.#sources.reconcileChangeLog(pg && {
+			resumeWatermark: pg.lastWatermark,
+			cookies: pg.cookies
+		}, () => resumePointOf(must(replica, "no seed for the SQLite change log")));
+		if (pg) {
+			if (replica) this.#lastComparison = this.#compare(pg, replica);
+			return pg;
+		}
+		const resumePoint = reconciled ?? resumePointOf(must(replica, "no initialization source"));
+		return {
+			lastWatermark: resumePoint.resumeWatermark,
+			cookies: resumePoint.cookies,
+			backfillRequests: backfillRequestsFrom(resumePoint.cookies)
+		};
+	}
+	/**
+	* Compares both sources and records the result. Postgres remains
+	* authoritative when both sources are enabled.
+	*/
+	#compare(pg, replica) {
+		let result;
+		try {
+			result = this.#classify(pg, replica);
+		} catch (e) {
+			this.#lc.warn?.("failed to compare change-log initialization sources", e);
+			result = "error";
+		}
+		this.#resultCounter.add(1, { result });
+		this.#lc.debug?.("compared change-log initialization sources", { changeLogInitCompare: {
+			result,
+			pgWatermark: pg.lastWatermark,
+			replicaWatermark: replica.lastWatermark
+		} });
+		return result;
+	}
+	#readReplica(required) {
+		try {
+			return this.#sources.replica();
+		} catch (e) {
+			if (required) throw e;
+			this.#lc.warn?.("failed to derive change-log initialization from the replica", e);
+			this.#resultCounter.add(1, { result: "error" });
+			return;
+		}
+	}
+	#classify(pg, replica) {
+		if (replica.lastWatermark > pg.lastWatermark) return "inconclusive";
+		if (replica.lastWatermark === pg.lastWatermark) return this.#report(pg, replica, replica.cookies, "equal");
+		const db = this.#sources.changeLog();
+		if (db === void 0 || !spansInterval(db, replica.lastWatermark)) return "inconclusive";
+		const changes = readSchemaChanges(db, replica.lastWatermark, pg.lastWatermark);
+		if (changes === void 0) return "inconclusive";
+		return this.#report(pg, replica, foldCookies(replica.cookies, changes), "equal-after-fold", changes.length);
+	}
+	#report(pg, replica, derived, whenEqual, foldedChanges = 0) {
+		const expected = canonicalizeCookies(pg.cookies);
+		const actual = canonicalizeCookies(derived);
+		if (expected === actual) return whenEqual;
+		this.#lc.error?.("the replica-derived change-log cookies do not match Postgres", { changeLogInitCompare: {
+			pgWatermark: pg.lastWatermark,
+			replicaWatermark: replica.lastWatermark,
+			foldedChanges,
+			expected,
+			actual
+		} });
+		return "divergent";
+	}
+};
+var resumePointOf = ({ lastWatermark, cookies }) => ({
+	resumeWatermark: lastWatermark,
+	cookies
+});
+/**
+* Reads the replica's initialization parameters in one snapshot, which is
+* invariant 15 on the replica side: the state version and the cookies are only
+* meaningful together.
+*/
+function readReplicaInitializationParameters(db) {
+	const runner = new StatementRunner(db);
+	runner.begin();
+	try {
+		return {
+			lastWatermark: getReplicationState(runner).stateVersion,
+			backfillRequests: readBackfillRequests(db),
+			cookies: readReplicaCookies(db)
+		};
+	} finally {
+		if (db.inTransaction) runner.rollback();
+	}
+}
+/**
+* The replica source for {@link ChangeLogInitializer}, opening and closing the
+* file per stream connection rather than holding a handle on a database another
+* process owns.
+*
+* The handle is read-only, which is invariant 19 stated in the API: the
+* replica's cookie tables are written by the change-processor and by nothing
+* else. Note that a read-only SQLite connection still needs to attach the
+* WAL's `-shm`, so this can fail if it opens at a moment when no writer holds
+* the replica; that surfaces as the `error` classification, which is the point
+* of running the path under observation before anything depends on it.
+*/
+function replicaInitializationSource(lc, replicaFile) {
+	return () => {
+		const db = new Database(lc.withContext("component", "change-log-initializer"), replicaFile, { readonly: true });
+		try {
+			return readReplicaInitializationParameters(db);
+		} finally {
+			db.close();
+		}
+	};
+}
+/**
+* Whether the log holds the complete interval above `fromWatermark`, using the
+* same predicate catchup uses to decide `too-old`: the log both reaches back
+* that far and contains that transaction's `commit` row, so the next row after
+* it is the first change of the interval rather than the middle of a
+* transaction the log only partly holds.
+*/
+function spansInterval(db, fromWatermark) {
+	if (!streamTableExists(db)) return false;
+	const row = db.prepare(`
+      SELECT
+        (SELECT min("watermark") FROM "${CHANGE_LOG_STREAM_TABLE}")
+          AS "minWatermark",
+        coalesce((${SQLITE_CHANGE_LOG_BOUNDARY_SQL}), 0) AS "boundaryExists"
+    `).get({ fromWatermark });
+	return row.minWatermark !== null && fromWatermark >= row.minWatermark && row.boundaryExists === 1;
+}
+var SCHEMA_CHANGE_TAG_LIST = schemaChangeTags.map((tag) => `'${tag}'`).join(", ");
+/**
+* The log's schema changes over `(after, through]`, in stream order, or
+* `undefined` if the interval is too large to scan (see
+* {@link MAX_FOLD_SCAN_ROWS}).
+*
+* The tag is stored beside the verbatim change so this scan never parses the
+* payloads of ordinary data changes. The row count is still checked first so a
+* stalled replicator cannot make the range scan unbounded.
+*
+* The count is itself capped, at one row past the cap it is deciding. A bare
+* `count(*)` over the interval is `O(interval)`, so the unbounded interval this
+* exists to decline would still be walked in full before being declined —
+* which is the latency the cap is here to avoid, not a cheaper form of it. The
+* `LIMIT` makes the decision `O(MAX_FOLD_SCAN_ROWS)`, and the comparison is
+* unaffected: the subquery returns the true count whenever it is within the
+* cap, and `cap + 1` whenever it is not.
+*/
+function readSchemaChanges(db, after, through) {
+	const { rows } = db.prepare(`
+      SELECT count(*) AS "rows" FROM (
+        SELECT 1 FROM "${CHANGE_LOG_STREAM_TABLE}"
+          WHERE "watermark" > ? AND "watermark" <= ?
+          LIMIT ${MAX_FOLD_SCAN_ROWS + 1}
+      )
+    `).get(after, through);
+	if (rows > MAX_FOLD_SCAN_ROWS) return;
+	return db.prepare(`
+      SELECT "change" FROM "${CHANGE_LOG_STREAM_TABLE}"
+        WHERE "watermark" > ? AND "watermark" <= ?
+          AND "tag" IN (${SCHEMA_CHANGE_TAG_LIST})
+        ORDER BY "watermark", "pos"
+    `).all(after, through).map(({ change }) => BigIntJSON.parse(change));
+}
+function streamTableExists(db) {
+	return db.prepare(`
+        SELECT 1 FROM "sqlite_master" WHERE "type" = 'table' AND "name" = ?
+      `).get(CHANGE_LOG_STREAM_TABLE) !== void 0;
+}
+/**
+* A canonical rendering of a whole cookie set: rows sorted by primary key,
+* object keys sorted at every depth.
+*
+* Both the equality check and the `divergent` log line fall out of this one
+* value, and neither can be defeated by a difference that is not a difference.
+* Postgres stores the cookie documents as `jsonb`, which does not preserve key
+* order, and the two readers order their rows in SQL in two engines under two
+* collations -- `storer.ts` pins `COLLATE "C"` for exactly that reason. Sorting
+* again here means an ordering or key-order regression can never be reported as
+* a divergence, which is a class of false alert that would cost more than it
+* caught.
+*/
+function canonicalizeCookies(cookies) {
+	return BigIntJSON.stringify({
+		tableMetadata: byKey(cookies.tableMetadata, (c) => [c.schema, c.table]).map((c) => [
+			c.schema,
+			c.table,
+			sortKeys(c.metadata)
+		]),
+		backfilling: byKey(cookies.backfilling, (c) => [
+			c.schema,
+			c.table,
+			c.column
+		]).map((c) => [
+			c.schema,
+			c.table,
+			c.column,
+			sortKeys(c.backfill)
+		])
+	});
+}
+function byKey(rows, key) {
+	return rows.map((row) => [JSON.stringify(key(row)), row]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, row]) => row);
+}
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (value === null || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => [k, sortKeys(v)]));
+}
+//#endregion
+export { ChangeLogInitializer, replicaInitializationSource };
+
+//# sourceMappingURL=change-log-initializer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"change-log-initializer.js","names":["#lc","#initFromPgChangeLog","#initFromReplica","#sources","#resultCounter","#lastComparison","#readReplica","#compare","#classify","#report"],"sources":["../../../../../../zero-cache/src/services/change-streamer/change-log-initializer.ts"],"sourcesContent":["/**\n * Where a stream connection's initialization parameters come from.\n *\n * A change-streamer starts a stream from three things read at one position: the\n * watermark to resume at, the {@link BackfillRequest}s to hand the change\n * source, and the cookie set those requests were derived from. Postgres has\n * always supplied all three (`Storer.getStartStreamInitializationParameters()`).\n * The point of this workstream is that a restored replica can supply them\n * instead, which is what lets the `cdc` schema be decommissioned.\n *\n * This is the two-source stage. Both are computed on every stream connection,\n * compared, and Postgres's is used — so the replica-derived path runs in\n * production, at full rate, before anything depends on it. The flip is\n * `initFromPgChangeLog: false`, not a rewrite.\n *\n * The shape is {@link UpstreamAcker}'s, deliberately: two stores, one output, a\n * flag per store, and the Postgres flag carrying the marker that retires it.\n * That class solved the identical problem for upstream ACKs earlier in this\n * workstream.\n *\n * ### Why the comparison is a fold and not an equality\n *\n * The replica is a subscriber downstream of the change-streamer's write loop,\n * so its state version trails the log's head by however long the replicator is\n * behind. A raw difference between the two cookie sets is therefore the normal\n * case and says nothing. What is checked instead is that the replica's set,\n * carried forward over exactly the schema changes the log holds in the interval,\n * equals Postgres's set at Postgres's watermark. The log holds precisely those\n * transactions, schema changes are rare, and the check is exact rather than\n * approximate — so it also happens to be the strongest available test of the\n * premise that three interpreters of one fold agree.\n */\n\nimport type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport {BigIntJSON} from '../../../../shared/src/bigint-json.ts';\nimport {must} from '../../../../shared/src/must.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {StatementRunner} from '../../db/statements.ts';\nimport {getOrCreateCounter} from '../../observability/metrics.ts';\nimport type {SchemaChange} from '../change-source/protocol/current/data.ts';\nimport {schemaChangeTags} from '../change-source/protocol/current/schema-change-tags.ts';\nimport type {BackfillRequest} from '../change-source/protocol/current/upstream.ts';\nimport {\n  backfillRequestsFrom,\n  foldCookies,\n  type CookieSet,\n} from '../replicator/change-log-cookies.ts';\nimport {\n  CHANGE_LOG_STREAM_TABLE,\n  type ChangeLogResumePoint,\n} from '../replicator/change-log-db.ts';\nimport {\n  readBackfillRequests,\n  readReplicaCookies,\n} from '../replicator/schema/backfilling.ts';\nimport {getReplicationState} from '../replicator/schema/replication-state.ts';\nimport {SQLITE_CHANGE_LOG_BOUNDARY_SQL} from './sqlite-change-log-reader.ts';\n\n/** Everything one stream connection starts from, read at one position. */\nexport type InitializationParameters = {\n  readonly lastWatermark: string;\n  readonly backfillRequests: BackfillRequest[];\n  readonly cookies: CookieSet;\n};\n\n/**\n * - `equal` — the two stores were at the same watermark and held the same\n *   cookies. Nothing had to be folded, which is the strongest of the four.\n * - `equal-after-fold` — the replica trailed, and carrying its set forward over\n *   the log's schema changes in the interval reproduced Postgres's exactly.\n *   The expected steady-state result.\n * - `divergent` — the two disagree at the same position. Alert; investigate\n *   individually.\n * - `inconclusive` — the log does not span the interval, so the fold cannot be\n *   performed. Routine on a cold log, and not a finding.\n * - `error` — the comparison itself failed: the replica could not be read, or\n *   the fold threw. Not one of the four classifications, because it is a\n *   statement about this process rather than about the two stores. Kept\n *   separate rather than folded into `inconclusive` so that a change-streamer\n *   that has silently stopped being able to read its replica is visible before\n *   that read becomes the only source.\n */\nexport type InitComparisonResult =\n  | 'equal'\n  | 'equal-after-fold'\n  | 'divergent'\n  | 'inconclusive'\n  | 'error';\n\nexport type ChangeLogInitializerSources = {\n  /** `Storer.getStartStreamInitializationParameters()`. */\n  readonly pgChangeLog: () => Promise<InitializationParameters>;\n  /** Typically {@link replicaInitializationSource}. */\n  readonly replica: () => InitializationParameters;\n  /**\n   * Reconciles the SQLite change log and returns its current resume point.\n   *\n   * When `resumeFrom` is present, it supplies the resume point. Otherwise, a\n   * valid log uses its own head. A new or invalid log uses `seed`.\n   *\n   * Returns `undefined` when the writer is disabled or unavailable.\n   */\n  readonly reconcileChangeLog: (\n    resumeFrom: ChangeLogResumePoint | undefined,\n    seed: () => ChangeLogResumePoint,\n  ) => ChangeLogResumePoint | undefined;\n  /**\n   * The change log, for the fold. `undefined` before the stream loop's first\n   * reconcile has created it, and again once the writer has failed soft and\n   * deleted it — both of which make the comparison `inconclusive` rather than\n   * an error, since neither says anything about the two stores.\n   */\n  readonly changeLog: () => Database | undefined;\n};\n\ntype Opts = {\n  /**\n   * When true, Postgres supplies the resume point and the cookies for a new\n   * change log.\n   *\n   * When false, a valid log resumes from its own head. The replica supplies the\n   * resume point for a new or invalid log.\n   */\n  // TODO: set false when retiring PG\n  readonly initFromPgChangeLog: boolean;\n  /**\n   * Derive the parameters from the replica. When Postgres is enabled, these\n   * parameters are used only for comparison.\n   *\n   * When Postgres is disabled, the replica supplies the seed and the fallback\n   * resume point.\n   */\n  readonly initFromReplica: boolean;\n};\n\n/**\n * The most change-log rows one comparison will scan.\n *\n * The interval is `(replicaWatermark, pgWatermark]`, so it is normally a\n * handful of transactions — but a replicator that has been stalled can leave it\n * arbitrarily large, and this runs on the stream loop between reconciliation and\n * `startStream`, where latency delays the resumption of replication. Over the\n * cap the comparison declines rather than pays: a chronically lagging replicator\n * shows up as `inconclusive`, which is charted, and not as a stall.\n */\nconst MAX_FOLD_SCAN_ROWS = 10_000;\n\nexport class ChangeLogInitializer {\n  readonly #lc: LogContext;\n  readonly #initFromPgChangeLog: boolean;\n  readonly #initFromReplica: boolean;\n  readonly #sources: ChangeLogInitializerSources;\n\n  readonly #resultCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.init_compare_result',\n    'Comparisons of the replica-derived stream initialization parameters ' +\n      'against the Postgres-derived ones, by classification.',\n  );\n\n  #lastComparison: InitComparisonResult | undefined;\n\n  constructor(\n    lc: LogContext,\n    {initFromPgChangeLog, initFromReplica}: Opts,\n    sources: ChangeLogInitializerSources,\n  ) {\n    assert(\n      initFromPgChangeLog || initFromReplica,\n      `At least one of initFromPgChangeLog or initFromReplica must be true`,\n    );\n    this.#lc = lc.withContext('component', 'change-log-initializer');\n    this.#initFromPgChangeLog = initFromPgChangeLog;\n    this.#initFromReplica = initFromReplica;\n    this.#sources = sources;\n  }\n\n  /**\n   * Returns the comparison result from the most recent {@link initialize}\n   * call. Returns `undefined` when that call used only one source.\n   *\n   * Tests and metrics use this result. It does not affect initialization.\n   */\n  lastComparison(): InitComparisonResult | undefined {\n    return this.#lastComparison;\n  }\n\n  /**\n   * Returns the initialization parameters for one stream connection after it\n   * reconciles the change log.\n   *\n   * The selected source determines how reconciliation works. Keeping both\n   * operations here hides that choice from the caller.\n   */\n  async initialize(): Promise<InitializationParameters> {\n    this.#lastComparison = undefined;\n    const pg = this.#initFromPgChangeLog\n      ? await this.#sources.pgChangeLog()\n      : undefined;\n    // The replica is required when Postgres is disabled. It seeds a new log and\n    // supplies a resume point when the writer is unavailable.\n    const replica = this.#initFromReplica\n      ? this.#readReplica(pg === undefined)\n      : undefined;\n\n    const reconciled = this.#sources.reconcileChangeLog(\n      pg && {resumeWatermark: pg.lastWatermark, cookies: pg.cookies},\n      () => resumePointOf(must(replica, 'no seed for the SQLite change log')),\n    );\n\n    if (pg) {\n      if (replica) {\n        // Compare only after reconciliation. The fold must read the schema\n        // changes from the replica watermark through the Postgres watermark.\n        // Reconciliation makes sure that the log contains that interval.\n        this.#lastComparison = this.#compare(pg, replica);\n      }\n      return pg;\n    }\n\n    // Use the reconciled log position. If the writer is unavailable, use the\n    // replica position.\n    const resumePoint =\n      reconciled ?? resumePointOf(must(replica, 'no initialization source'));\n    return {\n      lastWatermark: resumePoint.resumeWatermark,\n      cookies: resumePoint.cookies,\n      // Derive the requests from these cookies so that the requests and the\n      // watermark describe the same position.\n      backfillRequests: backfillRequestsFrom(resumePoint.cookies),\n    };\n  }\n\n  /**\n   * Compares both sources and records the result. Postgres remains\n   * authoritative when both sources are enabled.\n   */\n  #compare(\n    pg: InitializationParameters,\n    replica: InitializationParameters,\n  ): InitComparisonResult {\n    let result: InitComparisonResult;\n    try {\n      result = this.#classify(pg, replica);\n    } catch (e) {\n      this.#lc.warn?.('failed to compare change-log initialization sources', e);\n      result = 'error';\n    }\n    this.#resultCounter.add(1, {result});\n    this.#lc.debug?.('compared change-log initialization sources', {\n      changeLogInitCompare: {\n        result,\n        pgWatermark: pg.lastWatermark,\n        replicaWatermark: replica.lastWatermark,\n      },\n    });\n    return result;\n  }\n\n  #readReplica(required: boolean): InitializationParameters | undefined {\n    try {\n      return this.#sources.replica();\n    } catch (e) {\n      if (required) {\n        throw e;\n      }\n      // Observational until the flip, so a replica that cannot be read must not\n      // stop replication -- but it must not be quiet either, since the flip\n      // makes this read the only source.\n      this.#lc.warn?.(\n        'failed to derive change-log initialization from the replica',\n        e,\n      );\n      this.#resultCounter.add(1, {result: 'error'});\n      return undefined;\n    }\n  }\n\n  #classify(\n    pg: InitializationParameters,\n    replica: InitializationParameters,\n  ): InitComparisonResult {\n    if (replica.lastWatermark > pg.lastWatermark) {\n      // Transactions reach subscribers before the storer's commit, so a replica\n      // read taken while one is in flight can be a transaction ahead. The fold\n      // only runs forward, so there is nothing to be said either way.\n      return 'inconclusive';\n    }\n    if (replica.lastWatermark === pg.lastWatermark) {\n      return this.#report(pg, replica, replica.cookies, 'equal');\n    }\n\n    const db = this.#sources.changeLog();\n    if (db === undefined || !spansInterval(db, replica.lastWatermark)) {\n      return 'inconclusive';\n    }\n    const changes = readSchemaChanges(\n      db,\n      replica.lastWatermark,\n      pg.lastWatermark,\n    );\n    if (changes === undefined) {\n      return 'inconclusive'; // over MAX_FOLD_SCAN_ROWS\n    }\n    return this.#report(\n      pg,\n      replica,\n      foldCookies(replica.cookies, changes),\n      'equal-after-fold',\n      changes.length,\n    );\n  }\n\n  #report(\n    pg: InitializationParameters,\n    replica: InitializationParameters,\n    derived: CookieSet,\n    whenEqual: InitComparisonResult,\n    foldedChanges = 0,\n  ): InitComparisonResult {\n    const expected = canonicalizeCookies(pg.cookies);\n    const actual = canonicalizeCookies(derived);\n    if (expected === actual) {\n      return whenEqual;\n    }\n    // Both sets are normally empty and are at most a handful of rows, so they\n    // are logged whole: a divergence is investigated individually (`P§:10`)\n    // and the two renderings are the whole of what there is to look at.\n    this.#lc.error?.(\n      'the replica-derived change-log cookies do not match Postgres',\n      {\n        changeLogInitCompare: {\n          pgWatermark: pg.lastWatermark,\n          replicaWatermark: replica.lastWatermark,\n          foldedChanges,\n          expected,\n          actual,\n        },\n      },\n    );\n    return 'divergent';\n  }\n}\n\nconst resumePointOf = ({\n  lastWatermark,\n  cookies,\n}: InitializationParameters): ChangeLogResumePoint => ({\n  resumeWatermark: lastWatermark,\n  cookies,\n});\n\n/**\n * Reads the replica's initialization parameters in one snapshot, which is\n * invariant 15 on the replica side: the state version and the cookies are only\n * meaningful together.\n */\nexport function readReplicaInitializationParameters(\n  db: Database,\n): InitializationParameters {\n  const runner = new StatementRunner(db);\n  runner.begin(); // deferred, i.e. one read snapshot for the three statements\n  try {\n    return {\n      lastWatermark: getReplicationState(runner).stateVersion,\n      backfillRequests: readBackfillRequests(db),\n      cookies: readReplicaCookies(db),\n    };\n  } finally {\n    if (db.inTransaction) {\n      runner.rollback();\n    }\n  }\n}\n\n/**\n * The replica source for {@link ChangeLogInitializer}, opening and closing the\n * file per stream connection rather than holding a handle on a database another\n * process owns.\n *\n * The handle is read-only, which is invariant 19 stated in the API: the\n * replica's cookie tables are written by the change-processor and by nothing\n * else. Note that a read-only SQLite connection still needs to attach the\n * WAL's `-shm`, so this can fail if it opens at a moment when no writer holds\n * the replica; that surfaces as the `error` classification, which is the point\n * of running the path under observation before anything depends on it.\n */\nexport function replicaInitializationSource(\n  lc: LogContext,\n  replicaFile: string,\n): () => InitializationParameters {\n  return () => {\n    const db = new Database(\n      lc.withContext('component', 'change-log-initializer'),\n      replicaFile,\n      {readonly: true},\n    );\n    try {\n      return readReplicaInitializationParameters(db);\n    } finally {\n      db.close();\n    }\n  };\n}\n\n/**\n * Whether the log holds the complete interval above `fromWatermark`, using the\n * same predicate catchup uses to decide `too-old`: the log both reaches back\n * that far and contains that transaction's `commit` row, so the next row after\n * it is the first change of the interval rather than the middle of a\n * transaction the log only partly holds.\n */\nfunction spansInterval(db: Database, fromWatermark: string): boolean {\n  if (!streamTableExists(db)) {\n    return false;\n  }\n  const row = db\n    .prepare(/*sql*/ `\n      SELECT\n        (SELECT min(\"watermark\") FROM \"${CHANGE_LOG_STREAM_TABLE}\")\n          AS \"minWatermark\",\n        coalesce((${SQLITE_CHANGE_LOG_BOUNDARY_SQL}), 0) AS \"boundaryExists\"\n    `)\n    .get<{minWatermark: string | null; boundaryExists: number}>({\n      fromWatermark,\n    });\n  return (\n    row.minWatermark !== null &&\n    fromWatermark >= row.minWatermark &&\n    row.boundaryExists === 1\n  );\n}\n\nconst SCHEMA_CHANGE_TAG_LIST = schemaChangeTags\n  .map(tag => `'${tag}'`)\n  .join(', ');\n\n/**\n * The log's schema changes over `(after, through]`, in stream order, or\n * `undefined` if the interval is too large to scan (see\n * {@link MAX_FOLD_SCAN_ROWS}).\n *\n * The tag is stored beside the verbatim change so this scan never parses the\n * payloads of ordinary data changes. The row count is still checked first so a\n * stalled replicator cannot make the range scan unbounded.\n *\n * The count is itself capped, at one row past the cap it is deciding. A bare\n * `count(*)` over the interval is `O(interval)`, so the unbounded interval this\n * exists to decline would still be walked in full before being declined —\n * which is the latency the cap is here to avoid, not a cheaper form of it. The\n * `LIMIT` makes the decision `O(MAX_FOLD_SCAN_ROWS)`, and the comparison is\n * unaffected: the subquery returns the true count whenever it is within the\n * cap, and `cap + 1` whenever it is not.\n */\nfunction readSchemaChanges(\n  db: Database,\n  after: string,\n  through: string,\n): SchemaChange[] | undefined {\n  const {rows} = db\n    .prepare(/*sql*/ `\n      SELECT count(*) AS \"rows\" FROM (\n        SELECT 1 FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n          WHERE \"watermark\" > ? AND \"watermark\" <= ?\n          LIMIT ${MAX_FOLD_SCAN_ROWS + 1}\n      )\n    `)\n    .get<{rows: number}>(after, through);\n  if (rows > MAX_FOLD_SCAN_ROWS) {\n    return undefined;\n  }\n  return db\n    .prepare(/*sql*/ `\n      SELECT \"change\" FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n        WHERE \"watermark\" > ? AND \"watermark\" <= ?\n          AND \"tag\" IN (${SCHEMA_CHANGE_TAG_LIST})\n        ORDER BY \"watermark\", \"pos\"\n    `)\n    .all<{change: string}>(after, through)\n    .map(({change}) => BigIntJSON.parse(change) as SchemaChange);\n}\n\nfunction streamTableExists(db: Database): boolean {\n  return (\n    db\n      .prepare(/*sql*/ `\n        SELECT 1 FROM \"sqlite_master\" WHERE \"type\" = 'table' AND \"name\" = ?\n      `)\n      .get<{1: number} | undefined>(CHANGE_LOG_STREAM_TABLE) !== undefined\n  );\n}\n\n/**\n * A canonical rendering of a whole cookie set: rows sorted by primary key,\n * object keys sorted at every depth.\n *\n * Both the equality check and the `divergent` log line fall out of this one\n * value, and neither can be defeated by a difference that is not a difference.\n * Postgres stores the cookie documents as `jsonb`, which does not preserve key\n * order, and the two readers order their rows in SQL in two engines under two\n * collations -- `storer.ts` pins `COLLATE \"C\"` for exactly that reason. Sorting\n * again here means an ordering or key-order regression can never be reported as\n * a divergence, which is a class of false alert that would cost more than it\n * caught.\n */\nfunction canonicalizeCookies(cookies: CookieSet): string {\n  return BigIntJSON.stringify({\n    tableMetadata: byKey(cookies.tableMetadata, c => [c.schema, c.table]).map(\n      c => [c.schema, c.table, sortKeys(c.metadata)],\n    ),\n    backfilling: byKey(cookies.backfilling, c => [\n      c.schema,\n      c.table,\n      c.column,\n    ]).map(c => [c.schema, c.table, c.column, sortKeys(c.backfill)]),\n  });\n}\n\nfunction byKey<T>(rows: readonly T[], key: (row: T) => string[]): T[] {\n  return rows\n    .map(row => [JSON.stringify(key(row)), row] as const)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n    .map(([, row]) => row);\n}\n\nfunction sortKeys(value: unknown): unknown {\n  if (Array.isArray(value)) {\n    return value.map(sortKeys);\n  }\n  if (value === null || typeof value !== 'object') {\n    return value;\n  }\n  return Object.fromEntries(\n    Object.entries(value)\n      .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n      .map(([k, v]) => [k, sortKeys(v)]),\n  );\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/change-streamer/change-log-transaction-hash.d.ts

@@ -0,0 +1,19 @@
+export type ChangeLogHashRow = {
+    readonly watermark: string;
+    readonly pos: number;
+    readonly tag: string;
+    readonly change: string;
+    readonly precommit: string | null;
+};
+/**
+ * Computes a stable digest over the fields shared by the Postgres and SQLite
+ * change logs. Values are length-prefixed so different field boundaries cannot
+ * produce the same byte stream.
+ */
+export declare class ChangeLogTransactionHasher {
+    #private;
+    constructor();
+    add(row: ChangeLogHashRow): void;
+    digest(): string;
+}
+//# sourceMappingURL=change-log-transaction-hash.d.ts.map

package/out/zero-cache/src/services/change-streamer/change-log-transaction-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-log-transaction-hash.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/change-log-transaction-hash.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC,CAAC;AAEF;;;;GAIG;AACH,qBAAa,0BAA0B;;;IAQrC,GAAG,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI;IAahC,MAAM,IAAI,MAAM;CAGjB"}

package/out/zero-cache/src/services/change-streamer/change-log-transaction-hash.js

@@ -0,0 +1,39 @@
+import { createHash } from "node:crypto";
+//#region ../zero-cache/src/services/change-streamer/change-log-transaction-hash.ts
+/**
+* Computes a stable digest over the fields shared by the Postgres and SQLite
+* change logs. Values are length-prefixed so different field boundaries cannot
+* produce the same byte stream.
+*/
+var ChangeLogTransactionHasher = class {
+	#hash;
+	constructor() {
+		this.#hash = createHash("sha256");
+		writeString(this.#hash, "zero-change-log-transaction-v1");
+	}
+	add(row) {
+		writeString(this.#hash, row.watermark);
+		writeString(this.#hash, String(row.pos));
+		writeString(this.#hash, row.tag);
+		writeString(this.#hash, row.change);
+		if (row.precommit === null) this.#hash.update(Uint8Array.of(0));
+		else {
+			this.#hash.update(Uint8Array.of(1));
+			writeString(this.#hash, row.precommit);
+		}
+	}
+	digest() {
+		return this.#hash.digest("hex");
+	}
+};
+function writeString(hash, value) {
+	const bytes = Buffer.from(value);
+	const length = Buffer.allocUnsafe(4);
+	length.writeUInt32BE(bytes.byteLength);
+	hash.update(length);
+	hash.update(bytes);
+}
+//#endregion
+export { ChangeLogTransactionHasher };
+
+//# sourceMappingURL=change-log-transaction-hash.js.map

package/out/zero-cache/src/services/change-streamer/change-log-transaction-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-log-transaction-hash.js","names":["#hash"],"sources":["../../../../../../zero-cache/src/services/change-streamer/change-log-transaction-hash.ts"],"sourcesContent":["import {createHash, type Hash} from 'node:crypto';\n\nexport type ChangeLogHashRow = {\n  readonly watermark: string;\n  readonly pos: number;\n  readonly tag: string;\n  readonly change: string;\n  readonly precommit: string | null;\n};\n\n/**\n * Computes a stable digest over the fields shared by the Postgres and SQLite\n * change logs. Values are length-prefixed so different field boundaries cannot\n * produce the same byte stream.\n */\nexport class ChangeLogTransactionHasher {\n  readonly #hash: Hash;\n\n  constructor() {\n    this.#hash = createHash('sha256');\n    writeString(this.#hash, 'zero-change-log-transaction-v1');\n  }\n\n  add(row: ChangeLogHashRow): void {\n    writeString(this.#hash, row.watermark);\n    writeString(this.#hash, String(row.pos));\n    writeString(this.#hash, row.tag);\n    writeString(this.#hash, row.change);\n    if (row.precommit === null) {\n      this.#hash.update(Uint8Array.of(0));\n    } else {\n      this.#hash.update(Uint8Array.of(1));\n      writeString(this.#hash, row.precommit);\n    }\n  }\n\n  digest(): string {\n    return this.#hash.digest('hex');\n  }\n}\n\nfunction writeString(hash: Hash, value: string): void {\n  const bytes = Buffer.from(value);\n  const length = Buffer.allocUnsafe(4);\n  length.writeUInt32BE(bytes.byteLength);\n  hash.update(length);\n  hash.update(bytes);\n}\n"],"mappings":";;;;;;;AAeA,IAAa,6BAAb,MAAwC;CACtC;CAEA,cAAc;EACZ,KAAKA,QAAQ,WAAW,QAAQ;EAChC,YAAY,KAAKA,OAAO,gCAAgC;CAC1D;CAEA,IAAI,KAA6B;EAC/B,YAAY,KAAKA,OAAO,IAAI,SAAS;EACrC,YAAY,KAAKA,OAAO,OAAO,IAAI,GAAG,CAAC;EACvC,YAAY,KAAKA,OAAO,IAAI,GAAG;EAC/B,YAAY,KAAKA,OAAO,IAAI,MAAM;EAClC,IAAI,IAAI,cAAc,MACpB,KAAKA,MAAM,OAAO,WAAW,GAAG,CAAC,CAAC;OAC7B;GACL,KAAKA,MAAM,OAAO,WAAW,GAAG,CAAC,CAAC;GAClC,YAAY,KAAKA,OAAO,IAAI,SAAS;EACvC;CACF;CAEA,SAAiB;EACf,OAAO,KAAKA,MAAM,OAAO,KAAK;CAChC;AACF;AAEA,SAAS,YAAY,MAAY,OAAqB;CACpD,MAAM,QAAQ,OAAO,KAAK,KAAK;CAC/B,MAAM,SAAS,OAAO,YAAY,CAAC;CACnC,OAAO,cAAc,MAAM,UAAU;CACrC,KAAK,OAAO,MAAM;CAClB,KAAK,OAAO,KAAK;AACnB"}

package/out/zero-cache/src/services/change-streamer/change-streamer-http.d.ts

@@ -4,8 +4,7 @@ import { type Worker } from '../../types/processes.ts';
 import { type ShardID } from '../../types/shards.ts';
 import { type Source } from '../../types/streams.ts';
 import { HttpService } from '../http-service.ts';
-import type { BackupMonitor } from './backup-monitor.ts';
-import { type ChangeStreamer, type ChangeStreamerService, type Downstream, type SubscriberContext } from './change-streamer.ts';
+import { type ChangeStreamer, type ChangeStreamerService, type SerializedDownstream, type SubscriberContext } from './change-streamer.ts';
 import { type SnapshotMessage } from './snapshot.ts';
 type Options = {
     port: number;
@@ -15,7 +14,7 @@ type Options = {
 export declare class ChangeStreamerHttpServer extends HttpService {
     #private;
     readonly id = "change-streamer-http-server";
-    constructor(lc: LogContext, opts: Options, parent: Worker, changeStreamer: ChangeStreamerService, backupMonitor: BackupMonitor | null);
+    constructor(lc: LogContext, opts: Options, parent: Worker, changeStreamer: ChangeStreamerService);
     protected _onStart(): void;
     protected _onStop(): Promise<void>;
 }
@@ -23,7 +22,7 @@ export declare class ChangeStreamerHttpClient implements ChangeStreamer {
     #private;
     constructor(lc: LogContext, shardID: ShardID, changeDB: string, changeStreamerURI: string | undefined);
     reserveSnapshot(taskID: string): Promise<Source<SnapshotMessage>>;
-    subscribe(ctx: SubscriberContext): Promise<Source<Downstream>>;
+    subscribe(ctx: SubscriberContext): Promise<Source<SerializedDownstream>>;
 }
 type RequestHeaders = Pick<IncomingMessage, 'url' | 'headers'>;
 export declare function getSubscriberContext(req: RequestHeaders): SubscriberContext;

package/out/zero-cache/src/services/change-streamer/change-streamer-http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"change-streamer-http.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/change-streamer-http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,WAAW,CAAC;AAE/C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAMjD,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAC,KAAK,OAAO,EAAC,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAIL,KAAK,MAAM,EACZ,MAAM,wBAAwB,CAAC;AAIhC,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,UAAU,EACf,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAwB,KAAK,eAAe,EAAC,MAAM,eAAe,CAAC;AAW1E,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,qBAAa,wBAAyB,SAAQ,WAAW;;IACvD,QAAQ,CAAC,EAAE,iCAAiC;gBAO1C,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,qBAAqB,EACrC,aAAa,EAAE,aAAa,GAAG,IAAI;cA4GlB,QAAQ,IAAI,IAAI;cAWV,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAKlD;AAED,qBAAa,wBAAyB,YAAW,cAAc;;gBAO3D,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,MAAM,GAAG,SAAS;IA8BjC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;IASjE,SAAS,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;CAQrE;AAED,KAAK,cAAc,GAAG,IAAI,CAAC,eAAe,EAAE,KAAK,GAAG,SAAS,CAAC,CAAC;AAE/D,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,iBAAiB,CAc3E"}
+{"version":3,"file":"change-streamer-http.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/change-streamer-http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,WAAW,CAAC;AAE/C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAKjD,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAC,KAAK,OAAO,EAAC,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAKL,KAAK,MAAM,EACZ,MAAM,wBAAwB,CAAC;AAIhC,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAwB,KAAK,eAAe,EAAC,MAAM,eAAe,CAAC;AAW1E,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,qBAAa,wBAAyB,SAAQ,WAAW;;IACvD,QAAQ,CAAC,EAAE,iCAAiC;gBAM1C,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,qBAAqB;cAgGpB,QAAQ,IAAI,IAAI;cAWV,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAKlD;AAED,qBAAa,wBAAyB,YAAW,cAAc;;gBAO3D,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,MAAM,GAAG,SAAS;IA8BjC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;IASjE,SAAS,CACb,GAAG,EAAE,iBAAiB,GACrB,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;CAQzC;AAED,KAAK,cAAc,GAAG,IAAI,CAAC,eAAe,EAAE,KAAK,GAAG,SAAS,CAAC,CAAC;AAE/D,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,iBAAiB,CAkB3E"}

package/out/zero-cache/src/services/change-streamer/change-streamer-http.js

@@ -1,19 +1,18 @@
 import { assert } from "../../../../shared/src/asserts.js";
-import { must } from "../../../../shared/src/must.js";
 import "../../types/processes.js";
 import { pgClient } from "../../types/pg.js";
 import { HttpService } from "../http-service.js";
 import { PROTOCOL_ERROR, closeWithError } from "../../types/ws.js";
 import { installWebSocketReceiver } from "../../types/websocket-handoff.js";
+import { streamIn, streamInStringified, streamOut, streamOutStringified } from "../../types/streams.js";
 import { discoverChangeStreamerAddress } from "./schema/tables.js";
-import { streamIn, streamOut, streamOutStringified } from "../../types/streams.js";
 import { URLParams } from "../../types/url-params.js";
 import { downstreamSchema } from "./change-streamer.js";
 import { snapshotMessageSchema } from "./snapshot.js";
-import WebSocket from "ws";
+import WebSocket$1 from "ws";
 import websocket from "@fastify/websocket";
 //#region ../zero-cache/src/services/change-streamer/change-streamer-http.ts
-var MIN_SUPPORTED_PROTOCOL_VERSION = 1;
+var MIN_SUPPORTED_PROTOCOL_VERSION = 4;
 var SNAPSHOT_PATH_PATTERN = "/replication/:version/snapshot";
 var CHANGES_PATH_PATTERN = "/replication/:version/changes";
 var PATH_REGEX = /\/replication\/v(?<version>\d+)\/(changes|snapshot)$/;
@@ -24,8 +23,7 @@ var ChangeStreamerHttpServer = class extends HttpService {
 	#lc;
 	#opts;
 	#changeStreamer;
-	#backupMonitor;
-	constructor(lc, opts, parent, changeStreamer, backupMonitor) {
+	constructor(lc, opts, parent, changeStreamer) {
 		super("change-streamer-http-server", lc, opts, async (fastify) => {
 			await fastify.register(websocket);
 			fastify.get(CHANGES_PATH_PATTERN, { websocket: true }, this.#subscribe);
@@ -35,10 +33,6 @@ var ChangeStreamerHttpServer = class extends HttpService {
 		this.#lc = lc;
 		this.#opts = opts;
 		this.#changeStreamer = changeStreamer;
-		this.#backupMonitor = backupMonitor;
-	}
-	#getBackupMonitor() {
-		return must(this.#backupMonitor, "replication-manager is not configured with a ZERO_LITESTREAM_BACKUP_URL");
 	}
 	#receiveWebsocket = (ws, action, msg) => {
 		switch (action) {
@@ -49,13 +43,14 @@ var ChangeStreamerHttpServer = class extends HttpService {
 				return;
 		}
 	};
-	#reserveSnapshot = (ws, req) => {
+	#reserveSnapshot = async (ws, req) => {
+		this.#ensureChangeStreamerStarted("incoming snapshot reservation");
 		try {
 			const url = new URL(req.url ?? "", req.headers.origin ?? "http://localhost");
 			checkProtocolVersion(url.pathname);
 			const taskID = url.searchParams.get("taskID");
 			if (!taskID) throw new Error("Missing taskID in snapshot request");
-			const downstream = this.#getBackupMonitor().startSnapshotReservation(taskID);
+			const downstream = await this.#changeStreamer.startSnapshotReservation(taskID);
 			streamOut(this._lc, downstream, ws);
 		} catch (err) {
 			closeWithError(this._lc, ws, err, PROTOCOL_ERROR);
@@ -66,7 +61,6 @@ var ChangeStreamerHttpServer = class extends HttpService {
 			const ctx = getSubscriberContext(req);
 			if (ctx.mode === "serving") this.#ensureChangeStreamerStarted("incoming subscription");
 			const downstream = await this.#changeStreamer.subscribe(ctx);
-			if (ctx.initial && ctx.taskID && this.#backupMonitor) this.#backupMonitor.endReservation(ctx.taskID);
 			streamOutStringified(this._lc, downstream, ws);
 		} catch (err) {
 			closeWithError(this._lc, ws, err, PROTOCOL_ERROR);
@@ -114,12 +108,12 @@ var ChangeStreamerHttpClient = class {
 		return uri;
 	}
 	async reserveSnapshot(taskID) {
-		const ws = new WebSocket(await this.#resolveChangeStreamer(SNAPSHOT_PATH) + `?${new URLSearchParams({ taskID }).toString()}`);
+		const ws = new WebSocket$1(await this.#resolveChangeStreamer(SNAPSHOT_PATH) + `?${new URLSearchParams({ taskID }).toString()}`);
 		return streamIn(this.#lc, ws, snapshotMessageSchema);
 	}
 	async subscribe(ctx) {
-		const ws = new WebSocket(await this.#resolveChangeStreamer(CHANGES_PATH) + `?${getParams(ctx).toString()}`);
-		return streamIn(this.#lc, ws, downstreamSchema);
+		const ws = new WebSocket$1(await this.#resolveChangeStreamer(CHANGES_PATH) + `?${getParams(ctx).toString()}`);
+		return streamInStringified(this.#lc, ws, downstreamSchema);
 	}
 };
 function getSubscriberContext(req) {
@@ -129,11 +123,12 @@ function getSubscriberContext(req) {
 	return {
 		protocolVersion,
 		id: params.get("id", true),
-		taskID: params.get("taskID", false),
+		taskID: params.get("taskID", true),
 		mode: params.get("mode", false) === "backup" ? "backup" : "serving",
 		replicaVersion: params.get("replicaVersion", true),
 		watermark: params.get("watermark", true),
-		initial: params.getBoolean("initial")
+		initial: params.getBoolean("initial"),
+		logsChangeStream: params.getBoolean("logsChangeStream")
 	};
 }
 function checkProtocolVersion(pathname) {
@@ -148,8 +143,8 @@ function getParams(ctx) {
 	assert(protocolVersion === 6, `replicator should be setting protocolVersion to 6`);
 	return new URLSearchParams({
 		...stringParams,
-		taskID: ctx.taskID ? ctx.taskID : "",
-		initial: ctx.initial ? "true" : "false"
+		initial: ctx.initial ? "true" : "false",
+		logsChangeStream: ctx.logsChangeStream ? "true" : "false"
 	});
 }
 //#endregion

package/out/zero-cache/src/services/change-streamer/change-streamer-http.js.map

@@ -1 +1 @@
-{"version":3,"file":"change-streamer-http.js","names":["#lc","#opts","#changeStreamer","#backupMonitor","#subscribe","#reserveSnapshot","#receiveWebsocket","#getBackupMonitor","#ensureChangeStreamerStarted","#changeStreamerStarted","#shardID","#changeDB","#changeStreamerURI","#resolveChangeStreamer"],"sources":["../../../../../../zero-cache/src/services/change-streamer/change-streamer-http.ts"],"sourcesContent":["import type {IncomingMessage} from 'node:http';\nimport websocket from '@fastify/websocket';\nimport type {LogContext} from '@rocicorp/logger';\nimport WebSocket from 'ws';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport {must} from '../../../../shared/src/must.ts';\nimport type {IncomingMessageSubset} from '../../types/http.ts';\nimport {pgClient, type PostgresDB} from '../../types/pg.ts';\nimport {type Worker} from '../../types/processes.ts';\nimport {type ShardID} from '../../types/shards.ts';\nimport {\n  streamIn,\n  streamOut,\n  streamOutStringified,\n  type Source,\n} from '../../types/streams.ts';\nimport {URLParams} from '../../types/url-params.ts';\nimport {installWebSocketReceiver} from '../../types/websocket-handoff.ts';\nimport {closeWithError, PROTOCOL_ERROR} from '../../types/ws.ts';\nimport {HttpService} from '../http-service.ts';\nimport type {BackupMonitor} from './backup-monitor.ts';\nimport {\n  downstreamSchema,\n  PROTOCOL_VERSION,\n  type ChangeStreamer,\n  type ChangeStreamerService,\n  type Downstream,\n  type SubscriberContext,\n} from './change-streamer.ts';\nimport {discoverChangeStreamerAddress} from './schema/tables.ts';\nimport {snapshotMessageSchema, type SnapshotMessage} from './snapshot.ts';\n\nconst MIN_SUPPORTED_PROTOCOL_VERSION = 1;\n\nconst SNAPSHOT_PATH_PATTERN = '/replication/:version/snapshot';\nconst CHANGES_PATH_PATTERN = '/replication/:version/changes';\nconst PATH_REGEX = /\\/replication\\/v(?<version>\\d+)\\/(changes|snapshot)$/;\n\nconst SNAPSHOT_PATH = `/replication/v${PROTOCOL_VERSION}/snapshot`;\nconst CHANGES_PATH = `/replication/v${PROTOCOL_VERSION}/changes`;\n\ntype Options = {\n  port: number;\n  keepaliveTimeoutMs: number | undefined;\n  startupDelayMs: number;\n};\n\nexport class ChangeStreamerHttpServer extends HttpService {\n  readonly id = 'change-streamer-http-server';\n  readonly #lc: LogContext;\n  readonly #opts: Options;\n  readonly #changeStreamer: ChangeStreamerService;\n  readonly #backupMonitor: BackupMonitor | null;\n\n  constructor(\n    lc: LogContext,\n    opts: Options,\n    parent: Worker,\n    changeStreamer: ChangeStreamerService,\n    backupMonitor: BackupMonitor | null,\n  ) {\n    super('change-streamer-http-server', lc, opts, async fastify => {\n      await fastify.register(websocket);\n\n      fastify.get(CHANGES_PATH_PATTERN, {websocket: true}, this.#subscribe);\n      fastify.get(\n        SNAPSHOT_PATH_PATTERN,\n        {websocket: true},\n        this.#reserveSnapshot,\n      );\n\n      installWebSocketReceiver<'snapshot' | 'changes'>(\n        lc,\n        fastify.websocketServer,\n        this.#receiveWebsocket,\n        parent,\n      );\n    });\n\n    this.#lc = lc;\n    this.#opts = opts;\n    this.#changeStreamer = changeStreamer;\n    this.#backupMonitor = backupMonitor;\n  }\n\n  #getBackupMonitor() {\n    return must(\n      this.#backupMonitor,\n      'replication-manager is not configured with a ZERO_LITESTREAM_BACKUP_URL',\n    );\n  }\n\n  // Called when receiving a web socket via the main dispatcher handoff.\n  readonly #receiveWebsocket = (\n    ws: WebSocket,\n    action: 'changes' | 'snapshot',\n    msg: IncomingMessageSubset,\n  ) => {\n    switch (action) {\n      case 'snapshot':\n        return this.#reserveSnapshot(ws, msg);\n      case 'changes':\n        return this.#subscribe(ws, msg);\n      default:\n        closeWithError(\n          this._lc,\n          ws,\n          `invalid action \"${action}\" received in handoff`,\n        );\n        return;\n    }\n  };\n\n  readonly #reserveSnapshot = (ws: WebSocket, req: RequestHeaders) => {\n    try {\n      const url = new URL(\n        req.url ?? '',\n        req.headers.origin ?? 'http://localhost',\n      );\n      checkProtocolVersion(url.pathname);\n      const taskID = url.searchParams.get('taskID');\n      if (!taskID) {\n        throw new Error('Missing taskID in snapshot request');\n      }\n      const downstream =\n        this.#getBackupMonitor().startSnapshotReservation(taskID);\n      void streamOut(this._lc, downstream, ws);\n    } catch (err) {\n      closeWithError(this._lc, ws, err, PROTOCOL_ERROR);\n    }\n  };\n\n  readonly #subscribe = async (ws: WebSocket, req: RequestHeaders) => {\n    try {\n      const ctx = getSubscriberContext(req);\n      if (ctx.mode === 'serving') {\n        this.#ensureChangeStreamerStarted('incoming subscription');\n      }\n\n      const downstream = await this.#changeStreamer.subscribe(ctx);\n      if (ctx.initial && ctx.taskID && this.#backupMonitor) {\n        // Now that the change-streamer knows about the subscriber and watermark,\n        // end the reservation to safely resume scheduling cleanup.\n        this.#backupMonitor.endReservation(ctx.taskID);\n      }\n      void streamOutStringified(this._lc, downstream, ws);\n    } catch (err) {\n      closeWithError(this._lc, ws, err, PROTOCOL_ERROR);\n    }\n  };\n\n  #changeStreamerStarted = false;\n\n  #ensureChangeStreamerStarted(reason: string) {\n    if (!this.#changeStreamerStarted && this._state.shouldRun()) {\n      this.#lc.info?.(`starting ChangeStreamerService: ${reason}`);\n      void this.#changeStreamer\n        .run()\n        .catch(e =>\n          this.#lc.warn?.(`ChangeStreamerService ended with error`, e),\n        )\n        .finally(() => this.stop());\n\n      this.#changeStreamerStarted = true;\n    }\n  }\n\n  protected override _onStart(): void {\n    const {startupDelayMs} = this.#opts;\n    this._state.setTimeout(\n      () =>\n        this.#ensureChangeStreamerStarted(\n          `startup delay elapsed (${startupDelayMs} ms)`,\n        ),\n      startupDelayMs,\n    );\n  }\n\n  protected override async _onStop(): Promise<void> {\n    if (this.#changeStreamerStarted) {\n      await this.#changeStreamer.stop();\n    }\n  }\n}\n\nexport class ChangeStreamerHttpClient implements ChangeStreamer {\n  readonly #lc: LogContext;\n  readonly #shardID: ShardID;\n  readonly #changeDB: PostgresDB;\n  readonly #changeStreamerURI: string | undefined;\n\n  constructor(\n    lc: LogContext,\n    shardID: ShardID,\n    changeDB: string,\n    changeStreamerURI: string | undefined,\n  ) {\n    this.#lc = lc;\n    this.#shardID = shardID;\n    // Create a pg client with a single short-lived connection for the purpose\n    // of change-streamer discovery (i.e. ChangeDB as DNS).\n    this.#changeDB = pgClient(lc, changeDB, 'change-streamer-discovery', {\n      max: 1,\n      ['idle_timeout']: 15,\n    });\n    this.#changeStreamerURI = changeStreamerURI;\n  }\n\n  async #resolveChangeStreamer(path: string) {\n    let baseURL = this.#changeStreamerURI;\n    if (!baseURL) {\n      const address = await discoverChangeStreamerAddress(\n        this.#shardID,\n        this.#changeDB,\n      );\n      if (!address) {\n        throw new Error(`no change-streamer is running`);\n      }\n      baseURL = address.includes('://') ? `${address}/` : `ws://${address}/`;\n    }\n    const uri = new URL(path, baseURL);\n    this.#lc.info?.(`connecting to change-streamer@${uri}`);\n    return uri;\n  }\n\n  async reserveSnapshot(taskID: string): Promise<Source<SnapshotMessage>> {\n    const uri = await this.#resolveChangeStreamer(SNAPSHOT_PATH);\n\n    const params = new URLSearchParams({taskID});\n    const ws = new WebSocket(uri + `?${params.toString()}`);\n\n    return streamIn(this.#lc, ws, snapshotMessageSchema);\n  }\n\n  async subscribe(ctx: SubscriberContext): Promise<Source<Downstream>> {\n    const uri = await this.#resolveChangeStreamer(CHANGES_PATH);\n\n    const params = getParams(ctx);\n    const ws = new WebSocket(uri + `?${params.toString()}`);\n\n    return streamIn(this.#lc, ws, downstreamSchema);\n  }\n}\n\ntype RequestHeaders = Pick<IncomingMessage, 'url' | 'headers'>;\n\nexport function getSubscriberContext(req: RequestHeaders): SubscriberContext {\n  const url = new URL(req.url ?? '', req.headers.origin ?? 'http://localhost');\n  const protocolVersion = checkProtocolVersion(url.pathname);\n  const params = new URLParams(url);\n\n  return {\n    protocolVersion,\n    id: params.get('id', true),\n    taskID: params.get('taskID', false),\n    mode: params.get('mode', false) === 'backup' ? 'backup' : 'serving',\n    replicaVersion: params.get('replicaVersion', true),\n    watermark: params.get('watermark', true),\n    initial: params.getBoolean('initial'),\n  };\n}\n\nfunction checkProtocolVersion(pathname: string): number {\n  const match = PATH_REGEX.exec(pathname);\n  if (!match) {\n    throw new Error(`invalid path: ${pathname}`);\n  }\n  const v = Number(match.groups?.version);\n  if (\n    Number.isNaN(v) ||\n    v > PROTOCOL_VERSION ||\n    v < MIN_SUPPORTED_PROTOCOL_VERSION\n  ) {\n    throw new Error(\n      `Cannot service client at protocol v${v}. ` +\n        `Supported protocols: [v${MIN_SUPPORTED_PROTOCOL_VERSION} ... v${PROTOCOL_VERSION}]`,\n    );\n  }\n  return v;\n}\n\n// This is called from the client-side (i.e. the replicator).\nfunction getParams(ctx: SubscriberContext): URLSearchParams {\n  // The protocolVersion is hard-coded into the CHANGES_PATH.\n  const {protocolVersion, ...stringParams} = ctx;\n  assert(\n    protocolVersion === PROTOCOL_VERSION,\n    `replicator should be setting protocolVersion to ${PROTOCOL_VERSION}`,\n  );\n  return new URLSearchParams({\n    ...stringParams,\n    taskID: ctx.taskID ? ctx.taskID : '',\n    initial: ctx.initial ? 'true' : 'false',\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"change-streamer-http.js","names":["#lc","#opts","#changeStreamer","#subscribe","#reserveSnapshot","#receiveWebsocket","#ensureChangeStreamerStarted","#changeStreamerStarted","#shardID","#changeDB","#changeStreamerURI","#resolveChangeStreamer"],"sources":["../../../../../../zero-cache/src/services/change-streamer/change-streamer-http.ts"],"sourcesContent":["import type {IncomingMessage} from 'node:http';\nimport websocket from '@fastify/websocket';\nimport type {LogContext} from '@rocicorp/logger';\nimport WebSocket from 'ws';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {IncomingMessageSubset} from '../../types/http.ts';\nimport {pgClient, type PostgresDB} from '../../types/pg.ts';\nimport {type Worker} from '../../types/processes.ts';\nimport {type ShardID} from '../../types/shards.ts';\nimport {\n  streamIn,\n  streamInStringified,\n  streamOut,\n  streamOutStringified,\n  type Source,\n} from '../../types/streams.ts';\nimport {URLParams} from '../../types/url-params.ts';\nimport {installWebSocketReceiver} from '../../types/websocket-handoff.ts';\nimport {closeWithError, PROTOCOL_ERROR} from '../../types/ws.ts';\nimport {HttpService} from '../http-service.ts';\nimport {\n  downstreamSchema,\n  PROTOCOL_VERSION,\n  type ChangeStreamer,\n  type ChangeStreamerService,\n  type SerializedDownstream,\n  type SubscriberContext,\n} from './change-streamer.ts';\nimport {discoverChangeStreamerAddress} from './schema/tables.ts';\nimport {snapshotMessageSchema, type SnapshotMessage} from './snapshot.ts';\n\nconst MIN_SUPPORTED_PROTOCOL_VERSION = 4;\n\nconst SNAPSHOT_PATH_PATTERN = '/replication/:version/snapshot';\nconst CHANGES_PATH_PATTERN = '/replication/:version/changes';\nconst PATH_REGEX = /\\/replication\\/v(?<version>\\d+)\\/(changes|snapshot)$/;\n\nconst SNAPSHOT_PATH = `/replication/v${PROTOCOL_VERSION}/snapshot`;\nconst CHANGES_PATH = `/replication/v${PROTOCOL_VERSION}/changes`;\n\ntype Options = {\n  port: number;\n  keepaliveTimeoutMs: number | undefined;\n  startupDelayMs: number;\n};\n\nexport class ChangeStreamerHttpServer extends HttpService {\n  readonly id = 'change-streamer-http-server';\n  readonly #lc: LogContext;\n  readonly #opts: Options;\n  readonly #changeStreamer: ChangeStreamerService;\n\n  constructor(\n    lc: LogContext,\n    opts: Options,\n    parent: Worker,\n    changeStreamer: ChangeStreamerService,\n  ) {\n    super('change-streamer-http-server', lc, opts, async fastify => {\n      await fastify.register(websocket);\n\n      fastify.get(CHANGES_PATH_PATTERN, {websocket: true}, this.#subscribe);\n      fastify.get(\n        SNAPSHOT_PATH_PATTERN,\n        {websocket: true},\n        this.#reserveSnapshot,\n      );\n\n      installWebSocketReceiver<'snapshot' | 'changes'>(\n        lc,\n        fastify.websocketServer,\n        this.#receiveWebsocket,\n        parent,\n      );\n    });\n\n    this.#lc = lc;\n    this.#opts = opts;\n    this.#changeStreamer = changeStreamer;\n  }\n\n  // Called when receiving a web socket via the main dispatcher handoff.\n  readonly #receiveWebsocket = (\n    ws: WebSocket,\n    action: 'changes' | 'snapshot',\n    msg: IncomingMessageSubset,\n  ) => {\n    switch (action) {\n      case 'snapshot':\n        return this.#reserveSnapshot(ws, msg);\n      case 'changes':\n        return this.#subscribe(ws, msg);\n      default:\n        closeWithError(\n          this._lc,\n          ws,\n          `invalid action \"${action}\" received in handoff`,\n        );\n        return;\n    }\n  };\n\n  readonly #reserveSnapshot = async (ws: WebSocket, req: RequestHeaders) => {\n    this.#ensureChangeStreamerStarted('incoming snapshot reservation');\n    try {\n      const url = new URL(\n        req.url ?? '',\n        req.headers.origin ?? 'http://localhost',\n      );\n      checkProtocolVersion(url.pathname);\n      const taskID = url.searchParams.get('taskID');\n      if (!taskID) {\n        throw new Error('Missing taskID in snapshot request');\n      }\n      const downstream =\n        await this.#changeStreamer.startSnapshotReservation(taskID);\n      void streamOut(this._lc, downstream, ws);\n    } catch (err) {\n      closeWithError(this._lc, ws, err, PROTOCOL_ERROR);\n    }\n  };\n\n  readonly #subscribe = async (ws: WebSocket, req: RequestHeaders) => {\n    try {\n      const ctx = getSubscriberContext(req);\n      if (ctx.mode === 'serving') {\n        this.#ensureChangeStreamerStarted('incoming subscription');\n      }\n\n      const downstream = await this.#changeStreamer.subscribe(ctx);\n      void streamOutStringified(this._lc, downstream, ws);\n    } catch (err) {\n      closeWithError(this._lc, ws, err, PROTOCOL_ERROR);\n    }\n  };\n\n  #changeStreamerStarted = false;\n\n  #ensureChangeStreamerStarted(reason: string) {\n    if (!this.#changeStreamerStarted && this._state.shouldRun()) {\n      this.#lc.info?.(`starting ChangeStreamerService: ${reason}`);\n      void this.#changeStreamer\n        .run()\n        .catch(e =>\n          this.#lc.warn?.(`ChangeStreamerService ended with error`, e),\n        )\n        .finally(() => this.stop());\n\n      this.#changeStreamerStarted = true;\n    }\n  }\n\n  protected override _onStart(): void {\n    const {startupDelayMs} = this.#opts;\n    this._state.setTimeout(\n      () =>\n        this.#ensureChangeStreamerStarted(\n          `startup delay elapsed (${startupDelayMs} ms)`,\n        ),\n      startupDelayMs,\n    );\n  }\n\n  protected override async _onStop(): Promise<void> {\n    if (this.#changeStreamerStarted) {\n      await this.#changeStreamer.stop();\n    }\n  }\n}\n\nexport class ChangeStreamerHttpClient implements ChangeStreamer {\n  readonly #lc: LogContext;\n  readonly #shardID: ShardID;\n  readonly #changeDB: PostgresDB;\n  readonly #changeStreamerURI: string | undefined;\n\n  constructor(\n    lc: LogContext,\n    shardID: ShardID,\n    changeDB: string,\n    changeStreamerURI: string | undefined,\n  ) {\n    this.#lc = lc;\n    this.#shardID = shardID;\n    // Create a pg client with a single short-lived connection for the purpose\n    // of change-streamer discovery (i.e. ChangeDB as DNS).\n    this.#changeDB = pgClient(lc, changeDB, 'change-streamer-discovery', {\n      max: 1,\n      ['idle_timeout']: 15,\n    });\n    this.#changeStreamerURI = changeStreamerURI;\n  }\n\n  async #resolveChangeStreamer(path: string) {\n    let baseURL = this.#changeStreamerURI;\n    if (!baseURL) {\n      const address = await discoverChangeStreamerAddress(\n        this.#shardID,\n        this.#changeDB,\n      );\n      if (!address) {\n        throw new Error(`no change-streamer is running`);\n      }\n      baseURL = address.includes('://') ? `${address}/` : `ws://${address}/`;\n    }\n    const uri = new URL(path, baseURL);\n    this.#lc.info?.(`connecting to change-streamer@${uri}`);\n    return uri;\n  }\n\n  async reserveSnapshot(taskID: string): Promise<Source<SnapshotMessage>> {\n    const uri = await this.#resolveChangeStreamer(SNAPSHOT_PATH);\n\n    const params = new URLSearchParams({taskID});\n    const ws = new WebSocket(uri + `?${params.toString()}`);\n\n    return streamIn(this.#lc, ws, snapshotMessageSchema);\n  }\n\n  async subscribe(\n    ctx: SubscriberContext,\n  ): Promise<Source<SerializedDownstream>> {\n    const uri = await this.#resolveChangeStreamer(CHANGES_PATH);\n\n    const params = getParams(ctx);\n    const ws = new WebSocket(uri + `?${params.toString()}`);\n\n    return streamInStringified(this.#lc, ws, downstreamSchema);\n  }\n}\n\ntype RequestHeaders = Pick<IncomingMessage, 'url' | 'headers'>;\n\nexport function getSubscriberContext(req: RequestHeaders): SubscriberContext {\n  const url = new URL(req.url ?? '', req.headers.origin ?? 'http://localhost');\n  const protocolVersion = checkProtocolVersion(url.pathname);\n  const params = new URLParams(url);\n\n  return {\n    protocolVersion,\n    id: params.get('id', true),\n    taskID: params.get('taskID', true),\n    mode: params.get('mode', false) === 'backup' ? 'backup' : 'serving',\n    replicaVersion: params.get('replicaVersion', true),\n    watermark: params.get('watermark', true),\n    initial: params.getBoolean('initial'),\n    // Absent for subscribers that predate the parameter, which is the safe\n    // default: the barrier falls back to polling rather than waiting on an\n    // ACK that would never be attributed to a writer.\n    logsChangeStream: params.getBoolean('logsChangeStream'),\n  };\n}\n\nfunction checkProtocolVersion(pathname: string): number {\n  const match = PATH_REGEX.exec(pathname);\n  if (!match) {\n    throw new Error(`invalid path: ${pathname}`);\n  }\n  const v = Number(match.groups?.version);\n  if (\n    Number.isNaN(v) ||\n    v > PROTOCOL_VERSION ||\n    v < MIN_SUPPORTED_PROTOCOL_VERSION\n  ) {\n    throw new Error(\n      `Cannot service client at protocol v${v}. ` +\n        `Supported protocols: [v${MIN_SUPPORTED_PROTOCOL_VERSION} ... v${PROTOCOL_VERSION}]`,\n    );\n  }\n  return v;\n}\n\n// This is called from the client-side (i.e. the replicator).\nfunction getParams(ctx: SubscriberContext): URLSearchParams {\n  // The protocolVersion is hard-coded into the CHANGES_PATH.\n  const {protocolVersion, ...stringParams} = ctx;\n  assert(\n    protocolVersion === PROTOCOL_VERSION,\n    `replicator should be setting protocolVersion to ${PROTOCOL_VERSION}`,\n  );\n  return new URLSearchParams({\n    ...stringParams,\n    initial: ctx.initial ? 'true' : 'false',\n    logsChangeStream: ctx.logsChangeStream ? 'true' : 'false',\n  });\n}\n"],"mappings":"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"}