@rocicorp/zero 1.11.0-canary.4 → 1.11.0-canary.40

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

@@ -0,0 +1,268 @@
+import { unreachable } from "../../../../shared/src/asserts.js";
+import { deepEqual } from "../../../../shared/src/json.js";
+import { BigIntJSON } from "../../../../shared/src/bigint-json.js";
+import { schemaChangeTags } from "../change-source/protocol/current/schema-change-tags.js";
+import { cookieOps } from "../replicator/change-log-cookies.js";
+import { acceptBackfill, covers } from "../change-source/protocol/backfill-progress.js";
+//#region ../zero-cache/src/services/change-streamer/backfill-state.ts
+function tableKey({ schema, name }) {
+	return JSON.stringify([schema, name]);
+}
+function clone(state) {
+	return new Map(Array.from(state, ([key, { table, columns }]) => [key, {
+		table: { ...table },
+		columns: { ...columns }
+	}]));
+}
+/**
+* Tags of messages that affect the backfill state. Other messages need not be
+* parsed.
+*/
+var RELEVANT_TAGS = new Set(["backfill", ...schemaChangeTags.filter((t) => t !== "create-index" && t !== "drop-index")]);
+var lastParsed;
+function parse(json) {
+	if (lastParsed?.json !== json) lastParsed = {
+		json,
+		change: BigIntJSON.parse(json)
+	};
+	return lastParsed.change;
+}
+/**
+* Tracks the state of the pending backfills (and their progress) of a party
+* in the replication stream (e.g. a subscriber, or the change-log itself), by
+* applying the same policies that a subscriber applies to its replica:
+* schema changes are folded with the {@link cookieOps} shared by the
+* cookie jars, and `backfill` / `backfill-completed` messages are accepted
+* or ignored with the continuity policy of {@link acceptBackfill}.
+*
+* Changes are applied transactionally: the changes of a transaction are
+* discarded if it is rolled back, and {@link requests()} only reflects
+* committed transactions.
+*/
+var BackfillState = class {
+	#state;
+	#beforeTx = null;
+	constructor(requests = []) {
+		this.#state = new Map(requests.filter((req) => Object.keys(req.columns).length > 0).map(({ table, columns }) => [tableKey(table), {
+			table: { ...table },
+			columns: { ...columns }
+		}]));
+	}
+	get #committed() {
+		return this.#beforeTx ?? this.#state;
+	}
+	/** The (committed) pending backfills. */
+	requests() {
+		return [...clone(this.#committed).values()];
+	}
+	/**
+	* Returns the `requests` with the (committed) progress of this state
+	* applied to the columns that are pending in both, i.e. same table, column,
+	* and backfill ID. Other columns have no progress (i.e. from scratch).
+	*/
+	withProgress(requests) {
+		const state = this.#committed;
+		return requests.map(({ table, columns }) => {
+			const tracked = state.get(tableKey(table))?.columns;
+			return {
+				table,
+				columns: Object.fromEntries(Object.entries(columns).map(([name, { id }]) => {
+					const col = tracked?.[name];
+					return [name, col?.progress && deepEqual(col.id, id) ? {
+						id,
+						progress: col.progress
+					} : { id }];
+				}))
+			};
+		});
+	}
+	/** Whether there are no (committed) pending backfills. */
+	get empty() {
+		return this.#committed.size === 0;
+	}
+	/**
+	* Returns the columns (as `schema.table.column` strings) with (committed)
+	* pending backfills that are not covered by the (committed) progress of the
+	* `stream`, i.e. columns for which the `stream` will not deliver all of the
+	* necessary data.
+	*/
+	uncovered(stream) {
+		const uncovered = [];
+		const streamState = stream.#committed;
+		for (const [key, { table, columns }] of this.#committed) {
+			const streamColumns = streamState.get(key)?.columns;
+			for (const [name, { id, progress }] of Object.entries(columns)) {
+				const s = streamColumns?.[name];
+				if (!s || !deepEqual(s.id, id) || !covers(s.progress, progress)) uncovered.push(`${table.schema}.${table.name}.${name}`);
+			}
+		}
+		return uncovered;
+	}
+	/**
+	* Applies a serialized change, parsing it only if it is relevant.
+	*
+	* @returns The columns (as `schema.table.column` strings) of a backfill
+	*          message that were ignored due to the continuity policy.
+	*/
+	applySerialized([, tag, json]) {
+		switch (tag) {
+			case "begin":
+				this.#begin();
+				return [];
+			case "commit":
+				this.#commit();
+				return [];
+			case "rollback":
+				this.#rollback();
+				return [];
+		}
+		if (!RELEVANT_TAGS.has(tag)) return [];
+		return this.apply(parse(json));
+	}
+	/**
+	* Applies a change.
+	*
+	* @returns The columns (as `schema.table.column` strings) of a backfill
+	*          message that were ignored due to the continuity policy.
+	*/
+	apply(change) {
+		switch (change[0]) {
+			case "begin":
+				this.#begin();
+				return [];
+			case "commit":
+				this.#commit();
+				return [];
+			case "rollback":
+				this.#rollback();
+				return [];
+		}
+		const msg = change[1];
+		switch (msg.tag) {
+			case "backfill": {
+				const { relation, columns, progressMarks } = msg;
+				return this.#applyBackfill(relation, columns, (progress, col) => {
+					const result = acceptBackfill(progress, progressMarks);
+					if (result.accept) {
+						col.progress = result.progress;
+						if (col.progress === void 0) delete col.progress;
+					}
+					return result.accept;
+				});
+			}
+			case "backfill-completed": {
+				const { relation, columns, progressMarks } = msg;
+				const backfill = this.#state.get(tableKey(relation));
+				const ignored = this.#applyBackfill(relation, columns, (progress, _, name) => {
+					const { accept } = acceptBackfill(progress, progressMarks && { previous: progressMarks.previous });
+					if (accept && backfill) delete backfill.columns[name];
+					return accept;
+				});
+				if (backfill && Object.keys(backfill.columns).length === 0) this.#state.delete(tableKey(relation));
+				return ignored;
+			}
+			case "create-table":
+			case "rename-table":
+			case "update-table-metadata":
+			case "add-column":
+			case "update-column":
+			case "drop-column":
+			case "drop-table":
+				this.#applySchemaChange(msg);
+				return [];
+		}
+		return [];
+	}
+	#applyBackfill(relation, columns, apply) {
+		const backfill = this.#state.get(tableKey(relation));
+		if (!backfill) return [];
+		const ignored = [];
+		for (const name of [...relation.rowKey.columns, ...columns]) {
+			const col = backfill.columns[name];
+			if (!col) continue;
+			const updated = { ...col };
+			if (apply(col.progress, updated, name)) {
+				if (name in backfill.columns) backfill.columns[name] = updated;
+			} else ignored.push(`${relation.schema}.${relation.name}.${name}`);
+		}
+		return ignored;
+	}
+	#applySchemaChange(change) {
+		const metadata = /* @__PURE__ */ new Map();
+		for (const op of cookieOps(change)) switch (op.op) {
+			case "upsert-metadata": {
+				const key = tableKey(op.table);
+				metadata.set(key, op.metadata);
+				const backfill = this.#state.get(key);
+				if (backfill) backfill.table.metadata = op.metadata;
+				break;
+			}
+			case "upsert-backfill": {
+				const key = tableKey(op.table);
+				let backfill = this.#state.get(key);
+				if (!backfill) {
+					backfill = {
+						table: {
+							schema: op.table.schema,
+							name: op.table.name,
+							metadata: metadata.get(key) ?? null
+						},
+						columns: {}
+					};
+					this.#state.set(key, backfill);
+				}
+				backfill.columns[op.column] = { id: op.backfill };
+				break;
+			}
+			case "rename-table": {
+				const backfill = this.#state.get(tableKey(op.old));
+				if (backfill) {
+					this.#state.delete(tableKey(op.old));
+					backfill.table.schema = op.new.schema;
+					backfill.table.name = op.new.name;
+					this.#state.set(tableKey(op.new), backfill);
+				}
+				break;
+			}
+			case "drop-table":
+				this.#state.delete(tableKey(op.table));
+				break;
+			case "rename-column": {
+				const backfill = this.#state.get(tableKey(op.table));
+				const col = backfill?.columns[op.old];
+				if (backfill && col) {
+					delete backfill.columns[op.old];
+					backfill.columns[op.new] = col;
+				}
+				break;
+			}
+			case "drop-column": {
+				const key = tableKey(op.table);
+				const backfill = this.#state.get(key);
+				if (backfill) {
+					delete backfill.columns[op.column];
+					if (Object.keys(backfill.columns).length === 0) this.#state.delete(key);
+				}
+				break;
+			}
+			case "complete-backfill": throw new Error(`unexpected ${op.op} op`);
+			default: unreachable(op);
+		}
+	}
+	#begin() {
+		this.#beforeTx ??= clone(this.#state);
+	}
+	#commit() {
+		this.#beforeTx = null;
+	}
+	#rollback() {
+		if (this.#beforeTx) {
+			this.#state = this.#beforeTx;
+			this.#beforeTx = null;
+		}
+	}
+};
+//#endregion
+export { BackfillState };
+
+//# sourceMappingURL=backfill-state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"backfill-state.js","names":["#state","#committed","#beforeTx","#begin","#commit","#rollback","#applyBackfill","#applySchemaChange"],"sources":["../../../../../../zero-cache/src/services/change-streamer/backfill-state.ts"],"sourcesContent":["import {unreachable} from '../../../../shared/src/asserts.ts';\nimport {BigIntJSON} from '../../../../shared/src/bigint-json.ts';\nimport {deepEqual} from '../../../../shared/src/json.ts';\nimport {\n  acceptBackfill,\n  covers,\n} from '../change-source/protocol/backfill-progress.ts';\nimport type {\n  BackfillRequest,\n  ChangeStreamData,\n  Identifier,\n  SchemaChange,\n  TableMetadata,\n} from '../change-source/protocol/current.ts';\nimport {schemaChangeTags} from '../change-source/protocol/current/schema-change-tags.ts';\nimport {cookieOps} from '../replicator/change-log-cookies.ts';\nimport type {ChangeTag, WatermarkedChange} from './change-streamer.ts';\n\nfunction tableKey({schema, name}: Identifier) {\n  return JSON.stringify([schema, name]);\n}\n\ntype Column = BackfillRequest['columns'][string];\n\n/** A mutable BackfillRequest. */\ntype Backfill = {\n  table: {schema: string; name: string; metadata: TableMetadata | null};\n  columns: Record<string, Column>;\n};\n\ntype State = Map<string, Backfill>;\n\nfunction clone(state: State): State {\n  return new Map(\n    Array.from(state, ([key, {table, columns}]) => [\n      key,\n      {table: {...table}, columns: {...columns}},\n    ]),\n  );\n}\n\n/**\n * Tags of messages that affect the backfill state. Other messages need not be\n * parsed.\n */\nconst RELEVANT_TAGS = new Set<ChangeTag>([\n  'backfill',\n  ...schemaChangeTags.filter(t => t !== 'create-index' && t !== 'drop-index'),\n]);\n\n// Serialized changes are typically forwarded (as the same string) to every\n// subscriber, so a single entry cache avoids re-parsing the same message for\n// each subscriber.\nlet lastParsed: {json: string; change: ChangeStreamData} | undefined;\n\nfunction parse(json: string): ChangeStreamData {\n  if (lastParsed?.json !== json) {\n    lastParsed = {json, change: BigIntJSON.parse(json) as ChangeStreamData};\n  }\n  return lastParsed.change;\n}\n\n/**\n * Tracks the state of the pending backfills (and their progress) of a party\n * in the replication stream (e.g. a subscriber, or the change-log itself), by\n * applying the same policies that a subscriber applies to its replica:\n * schema changes are folded with the {@link cookieOps} shared by the\n * cookie jars, and `backfill` / `backfill-completed` messages are accepted\n * or ignored with the continuity policy of {@link acceptBackfill}.\n *\n * Changes are applied transactionally: the changes of a transaction are\n * discarded if it is rolled back, and {@link requests()} only reflects\n * committed transactions.\n */\nexport class BackfillState {\n  #state: State;\n  #beforeTx: State | null = null;\n\n  constructor(requests: readonly BackfillRequest[] = []) {\n    this.#state = new Map(\n      requests\n        .filter(req => Object.keys(req.columns).length > 0)\n        .map(({table, columns}) => [\n          tableKey(table),\n          {table: {...table}, columns: {...columns}},\n        ]),\n    );\n  }\n\n  get #committed(): State {\n    return this.#beforeTx ?? this.#state;\n  }\n\n  /** The (committed) pending backfills. */\n  requests(): BackfillRequest[] {\n    return [...clone(this.#committed).values()];\n  }\n\n  /**\n   * Returns the `requests` with the (committed) progress of this state\n   * applied to the columns that are pending in both, i.e. same table, column,\n   * and backfill ID. Other columns have no progress (i.e. from scratch).\n   */\n  withProgress(requests: readonly BackfillRequest[]): BackfillRequest[] {\n    const state = this.#committed;\n    return requests.map(({table, columns}) => {\n      const tracked = state.get(tableKey(table))?.columns;\n      return {\n        table,\n        columns: Object.fromEntries(\n          Object.entries(columns).map(([name, {id}]) => {\n            const col = tracked?.[name];\n            return [\n              name,\n              col?.progress && deepEqual(col.id, id)\n                ? {id, progress: col.progress}\n                : {id},\n            ];\n          }),\n        ),\n      };\n    });\n  }\n\n  /** Whether there are no (committed) pending backfills. */\n  get empty(): boolean {\n    return this.#committed.size === 0;\n  }\n\n  /**\n   * Returns the columns (as `schema.table.column` strings) with (committed)\n   * pending backfills that are not covered by the (committed) progress of the\n   * `stream`, i.e. columns for which the `stream` will not deliver all of the\n   * necessary data.\n   */\n  uncovered(stream: BackfillState): string[] {\n    const uncovered: string[] = [];\n    const streamState = stream.#committed;\n    for (const [key, {table, columns}] of this.#committed) {\n      const streamColumns = streamState.get(key)?.columns;\n      for (const [name, {id, progress}] of Object.entries(columns)) {\n        const s = streamColumns?.[name];\n        if (!s || !deepEqual(s.id, id) || !covers(s.progress, progress)) {\n          uncovered.push(`${table.schema}.${table.name}.${name}`);\n        }\n      }\n    }\n    return uncovered;\n  }\n\n  /**\n   * Applies a serialized change, parsing it only if it is relevant.\n   *\n   * @returns The columns (as `schema.table.column` strings) of a backfill\n   *          message that were ignored due to the continuity policy.\n   */\n  applySerialized([, tag, json]: WatermarkedChange): string[] {\n    switch (tag) {\n      case 'begin':\n        this.#begin();\n        return [];\n      case 'commit':\n        this.#commit();\n        return [];\n      case 'rollback':\n        this.#rollback();\n        return [];\n    }\n    if (!RELEVANT_TAGS.has(tag)) {\n      return [];\n    }\n    return this.apply(parse(json));\n  }\n\n  /**\n   * Applies a change.\n   *\n   * @returns The columns (as `schema.table.column` strings) of a backfill\n   *          message that were ignored due to the continuity policy.\n   */\n  apply(change: ChangeStreamData): string[] {\n    switch (change[0]) {\n      case 'begin':\n        this.#begin();\n        return [];\n      case 'commit':\n        this.#commit();\n        return [];\n      case 'rollback':\n        this.#rollback();\n        return [];\n    }\n    const msg = change[1];\n    switch (msg.tag) {\n      case 'backfill': {\n        const {relation, columns, progressMarks} = msg;\n        return this.#applyBackfill(relation, columns, (progress, col) => {\n          const result = acceptBackfill(progress, progressMarks);\n          if (result.accept) {\n            col.progress = result.progress;\n            if (col.progress === undefined) {\n              delete col.progress;\n            }\n          }\n          return result.accept;\n        });\n      }\n      case 'backfill-completed': {\n        const {relation, columns, progressMarks} = msg;\n        const backfill = this.#state.get(tableKey(relation));\n        const ignored = this.#applyBackfill(\n          relation,\n          columns,\n          (progress, _, name) => {\n            const {accept} = acceptBackfill(\n              progress,\n              progressMarks && {previous: progressMarks.previous},\n            );\n            if (accept && backfill) {\n              delete backfill.columns[name];\n            }\n            return accept;\n          },\n        );\n        if (backfill && Object.keys(backfill.columns).length === 0) {\n          this.#state.delete(tableKey(relation));\n        }\n        return ignored;\n      }\n      case 'create-table':\n      case 'rename-table':\n      case 'update-table-metadata':\n      case 'add-column':\n      case 'update-column':\n      case 'drop-column':\n      case 'drop-table':\n        this.#applySchemaChange(msg);\n        return [];\n    }\n    return [];\n  }\n\n  #applyBackfill(\n    relation: {schema: string; name: string; rowKey: {columns: string[]}},\n    columns: readonly string[],\n    apply: (progress: Column['progress'], col: Column, name: string) => boolean,\n  ): string[] {\n    const backfill = this.#state.get(tableKey(relation));\n    if (!backfill) {\n      return [];\n    }\n    const ignored: string[] = [];\n    // rowKey columns are excluded from `columns` but are backfilled with them\n    // (e.g. for a new table).\n    for (const name of [...relation.rowKey.columns, ...columns]) {\n      const col = backfill.columns[name];\n      if (!col) {\n        continue;\n      }\n      // Copy-on-write, since the column object may be shared with the\n      // pre-transaction state.\n      const updated = {...col};\n      if (apply(col.progress, updated, name)) {\n        if (name in backfill.columns) {\n          backfill.columns[name] = updated;\n        }\n      } else {\n        ignored.push(`${relation.schema}.${relation.name}.${name}`);\n      }\n    }\n    return ignored;\n  }\n\n  #applySchemaChange(change: SchemaChange) {\n    // Table metadata specified in the same change (e.g. a `create-table` or\n    // `add-column`), for backfills of tables that are not yet tracked.\n    const metadata = new Map<string, TableMetadata>();\n\n    for (const op of cookieOps(change)) {\n      switch (op.op) {\n        case 'upsert-metadata': {\n          const key = tableKey(op.table);\n          metadata.set(key, op.metadata);\n          const backfill = this.#state.get(key);\n          if (backfill) {\n            backfill.table.metadata = op.metadata;\n          }\n          break;\n        }\n        case 'upsert-backfill': {\n          const key = tableKey(op.table);\n          let backfill = this.#state.get(key);\n          if (!backfill) {\n            backfill = {\n              table: {\n                schema: op.table.schema,\n                name: op.table.name,\n                metadata: metadata.get(key) ?? null,\n              },\n              columns: {},\n            };\n            this.#state.set(key, backfill);\n          }\n          // A new backfill always starts from scratch.\n          backfill.columns[op.column] = {id: op.backfill};\n          break;\n        }\n        case 'rename-table': {\n          const backfill = this.#state.get(tableKey(op.old));\n          if (backfill) {\n            this.#state.delete(tableKey(op.old));\n            backfill.table.schema = op.new.schema;\n            backfill.table.name = op.new.name;\n            this.#state.set(tableKey(op.new), backfill);\n          }\n          break;\n        }\n        case 'drop-table':\n          this.#state.delete(tableKey(op.table));\n          break;\n        case 'rename-column': {\n          const backfill = this.#state.get(tableKey(op.table));\n          const col = backfill?.columns[op.old];\n          if (backfill && col) {\n            delete backfill.columns[op.old];\n            backfill.columns[op.new] = col;\n          }\n          break;\n        }\n        case 'drop-column': {\n          const key = tableKey(op.table);\n          const backfill = this.#state.get(key);\n          if (backfill) {\n            delete backfill.columns[op.column];\n            if (Object.keys(backfill.columns).length === 0) {\n              this.#state.delete(key);\n            }\n          }\n          break;\n        }\n        case 'complete-backfill':\n          // Only produced for `backfill-completed`, which is handled\n          // separately (with the continuity policy).\n          throw new Error(`unexpected ${op.op} op`);\n        default:\n          unreachable(op);\n      }\n    }\n  }\n\n  #begin() {\n    // Tolerate a missing commit/rollback, e.g. from an interrupted stream.\n    this.#beforeTx ??= clone(this.#state);\n  }\n\n  #commit() {\n    this.#beforeTx = null;\n  }\n\n  #rollback() {\n    if (this.#beforeTx) {\n      this.#state = this.#beforeTx;\n      this.#beforeTx = null;\n    }\n  }\n}\n"],"mappings":";;;;;;;AAkBA,SAAS,SAAS,EAAC,QAAQ,QAAmB;CAC5C,OAAO,KAAK,UAAU,CAAC,QAAQ,IAAI,CAAC;AACtC;AAYA,SAAS,MAAM,OAAqB;CAClC,OAAO,IAAI,IACT,MAAM,KAAK,QAAQ,CAAC,KAAK,EAAC,OAAO,eAAc,CAC7C,KACA;EAAC,OAAO,EAAC,GAAG,MAAK;EAAG,SAAS,EAAC,GAAG,QAAO;CAAC,CAC3C,CAAC,CACH;AACF;;;;;AAMA,IAAM,gBAAgB,IAAI,IAAe,CACvC,YACA,GAAG,iBAAiB,QAAO,MAAK,MAAM,kBAAkB,MAAM,YAAY,CAC5E,CAAC;AAKD,IAAI;AAEJ,SAAS,MAAM,MAAgC;CAC7C,IAAI,YAAY,SAAS,MACvB,aAAa;EAAC;EAAM,QAAQ,WAAW,MAAM,IAAI;CAAqB;CAExE,OAAO,WAAW;AACpB;;;;;;;;;;;;;AAcA,IAAa,gBAAb,MAA2B;CACzB;CACA,YAA0B;CAE1B,YAAY,WAAuC,CAAC,GAAG;EACrD,KAAKA,SAAS,IAAI,IAChB,SACG,QAAO,QAAO,OAAO,KAAK,IAAI,OAAO,EAAE,SAAS,CAAC,EACjD,KAAK,EAAC,OAAO,cAAa,CACzB,SAAS,KAAK,GACd;GAAC,OAAO,EAAC,GAAG,MAAK;GAAG,SAAS,EAAC,GAAG,QAAO;EAAC,CAC3C,CAAC,CACL;CACF;CAEA,IAAIC,aAAoB;EACtB,OAAO,KAAKC,aAAa,KAAKF;CAChC;;CAGA,WAA8B;EAC5B,OAAO,CAAC,GAAG,MAAM,KAAKC,UAAU,EAAE,OAAO,CAAC;CAC5C;;;;;;CAOA,aAAa,UAAyD;EACpE,MAAM,QAAQ,KAAKA;EACnB,OAAO,SAAS,KAAK,EAAC,OAAO,cAAa;GACxC,MAAM,UAAU,MAAM,IAAI,SAAS,KAAK,CAAC,GAAG;GAC5C,OAAO;IACL;IACA,SAAS,OAAO,YACd,OAAO,QAAQ,OAAO,EAAE,KAAK,CAAC,MAAM,EAAC,UAAS;KAC5C,MAAM,MAAM,UAAU;KACtB,OAAO,CACL,MACA,KAAK,YAAY,UAAU,IAAI,IAAI,EAAE,IACjC;MAAC;MAAI,UAAU,IAAI;KAAQ,IAC3B,EAAC,GAAE,CACT;IACF,CAAC,CACH;GACF;EACF,CAAC;CACH;;CAGA,IAAI,QAAiB;EACnB,OAAO,KAAKA,WAAW,SAAS;CAClC;;;;;;;CAQA,UAAU,QAAiC;EACzC,MAAM,YAAsB,CAAC;EAC7B,MAAM,cAAc,OAAOA;EAC3B,KAAK,MAAM,CAAC,KAAK,EAAC,OAAO,cAAa,KAAKA,YAAY;GACrD,MAAM,gBAAgB,YAAY,IAAI,GAAG,GAAG;GAC5C,KAAK,MAAM,CAAC,MAAM,EAAC,IAAI,eAAc,OAAO,QAAQ,OAAO,GAAG;IAC5D,MAAM,IAAI,gBAAgB;IAC1B,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,UAAU,QAAQ,GAC5D,UAAU,KAAK,GAAG,MAAM,OAAO,GAAG,MAAM,KAAK,GAAG,MAAM;GAE1D;EACF;EACA,OAAO;CACT;;;;;;;CAQA,gBAAgB,GAAG,KAAK,OAAoC;EAC1D,QAAQ,KAAR;GACE,KAAK;IACH,KAAKE,OAAO;IACZ,OAAO,CAAC;GACV,KAAK;IACH,KAAKC,QAAQ;IACb,OAAO,CAAC;GACV,KAAK;IACH,KAAKC,UAAU;IACf,OAAO,CAAC;EACZ;EACA,IAAI,CAAC,cAAc,IAAI,GAAG,GACxB,OAAO,CAAC;EAEV,OAAO,KAAK,MAAM,MAAM,IAAI,CAAC;CAC/B;;;;;;;CAQA,MAAM,QAAoC;EACxC,QAAQ,OAAO,IAAf;GACE,KAAK;IACH,KAAKF,OAAO;IACZ,OAAO,CAAC;GACV,KAAK;IACH,KAAKC,QAAQ;IACb,OAAO,CAAC;GACV,KAAK;IACH,KAAKC,UAAU;IACf,OAAO,CAAC;EACZ;EACA,MAAM,MAAM,OAAO;EACnB,QAAQ,IAAI,KAAZ;GACE,KAAK,YAAY;IACf,MAAM,EAAC,UAAU,SAAS,kBAAiB;IAC3C,OAAO,KAAKC,eAAe,UAAU,UAAU,UAAU,QAAQ;KAC/D,MAAM,SAAS,eAAe,UAAU,aAAa;KACrD,IAAI,OAAO,QAAQ;MACjB,IAAI,WAAW,OAAO;MACtB,IAAI,IAAI,aAAa,KAAA,GACnB,OAAO,IAAI;KAEf;KACA,OAAO,OAAO;IAChB,CAAC;GACH;GACA,KAAK,sBAAsB;IACzB,MAAM,EAAC,UAAU,SAAS,kBAAiB;IAC3C,MAAM,WAAW,KAAKN,OAAO,IAAI,SAAS,QAAQ,CAAC;IACnD,MAAM,UAAU,KAAKM,eACnB,UACA,UACC,UAAU,GAAG,SAAS;KACrB,MAAM,EAAC,WAAU,eACf,UACA,iBAAiB,EAAC,UAAU,cAAc,SAAQ,CACpD;KACA,IAAI,UAAU,UACZ,OAAO,SAAS,QAAQ;KAE1B,OAAO;IACT,CACF;IACA,IAAI,YAAY,OAAO,KAAK,SAAS,OAAO,EAAE,WAAW,GACvD,KAAKN,OAAO,OAAO,SAAS,QAAQ,CAAC;IAEvC,OAAO;GACT;GACA,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;IACH,KAAKO,mBAAmB,GAAG;IAC3B,OAAO,CAAC;EACZ;EACA,OAAO,CAAC;CACV;CAEA,eACE,UACA,SACA,OACU;EACV,MAAM,WAAW,KAAKP,OAAO,IAAI,SAAS,QAAQ,CAAC;EACnD,IAAI,CAAC,UACH,OAAO,CAAC;EAEV,MAAM,UAAoB,CAAC;EAG3B,KAAK,MAAM,QAAQ,CAAC,GAAG,SAAS,OAAO,SAAS,GAAG,OAAO,GAAG;GAC3D,MAAM,MAAM,SAAS,QAAQ;GAC7B,IAAI,CAAC,KACH;GAIF,MAAM,UAAU,EAAC,GAAG,IAAG;GACvB,IAAI,MAAM,IAAI,UAAU,SAAS,IAAI;QAC/B,QAAQ,SAAS,SACnB,SAAS,QAAQ,QAAQ;GAAA,OAG3B,QAAQ,KAAK,GAAG,SAAS,OAAO,GAAG,SAAS,KAAK,GAAG,MAAM;EAE9D;EACA,OAAO;CACT;CAEA,mBAAmB,QAAsB;EAGvC,MAAM,2BAAW,IAAI,IAA2B;EAEhD,KAAK,MAAM,MAAM,UAAU,MAAM,GAC/B,QAAQ,GAAG,IAAX;GACE,KAAK,mBAAmB;IACtB,MAAM,MAAM,SAAS,GAAG,KAAK;IAC7B,SAAS,IAAI,KAAK,GAAG,QAAQ;IAC7B,MAAM,WAAW,KAAKA,OAAO,IAAI,GAAG;IACpC,IAAI,UACF,SAAS,MAAM,WAAW,GAAG;IAE/B;GACF;GACA,KAAK,mBAAmB;IACtB,MAAM,MAAM,SAAS,GAAG,KAAK;IAC7B,IAAI,WAAW,KAAKA,OAAO,IAAI,GAAG;IAClC,IAAI,CAAC,UAAU;KACb,WAAW;MACT,OAAO;OACL,QAAQ,GAAG,MAAM;OACjB,MAAM,GAAG,MAAM;OACf,UAAU,SAAS,IAAI,GAAG,KAAK;MACjC;MACA,SAAS,CAAC;KACZ;KACA,KAAKA,OAAO,IAAI,KAAK,QAAQ;IAC/B;IAEA,SAAS,QAAQ,GAAG,UAAU,EAAC,IAAI,GAAG,SAAQ;IAC9C;GACF;GACA,KAAK,gBAAgB;IACnB,MAAM,WAAW,KAAKA,OAAO,IAAI,SAAS,GAAG,GAAG,CAAC;IACjD,IAAI,UAAU;KACZ,KAAKA,OAAO,OAAO,SAAS,GAAG,GAAG,CAAC;KACnC,SAAS,MAAM,SAAS,GAAG,IAAI;KAC/B,SAAS,MAAM,OAAO,GAAG,IAAI;KAC7B,KAAKA,OAAO,IAAI,SAAS,GAAG,GAAG,GAAG,QAAQ;IAC5C;IACA;GACF;GACA,KAAK;IACH,KAAKA,OAAO,OAAO,SAAS,GAAG,KAAK,CAAC;IACrC;GACF,KAAK,iBAAiB;IACpB,MAAM,WAAW,KAAKA,OAAO,IAAI,SAAS,GAAG,KAAK,CAAC;IACnD,MAAM,MAAM,UAAU,QAAQ,GAAG;IACjC,IAAI,YAAY,KAAK;KACnB,OAAO,SAAS,QAAQ,GAAG;KAC3B,SAAS,QAAQ,GAAG,OAAO;IAC7B;IACA;GACF;GACA,KAAK,eAAe;IAClB,MAAM,MAAM,SAAS,GAAG,KAAK;IAC7B,MAAM,WAAW,KAAKA,OAAO,IAAI,GAAG;IACpC,IAAI,UAAU;KACZ,OAAO,SAAS,QAAQ,GAAG;KAC3B,IAAI,OAAO,KAAK,SAAS,OAAO,EAAE,WAAW,GAC3C,KAAKA,OAAO,OAAO,GAAG;IAE1B;IACA;GACF;GACA,KAAK,qBAGH,MAAM,IAAI,MAAM,cAAc,GAAG,GAAG,IAAI;GAC1C,SACE,YAAY,EAAE;EAClB;CAEJ;CAEA,SAAS;EAEP,KAAKE,cAAc,MAAM,KAAKF,MAAM;CACtC;CAEA,UAAU;EACR,KAAKE,YAAY;CACnB;CAEA,YAAY;EACV,IAAI,KAAKA,WAAW;GAClB,KAAKF,SAAS,KAAKE;GACnB,KAAKA,YAAY;EACnB;CACF;AACF"}

package/out/zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backup-cleanup-monitor-factory.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAGpE,OAAO,EAAyB,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,sBAAsB,CAAC;AAChE,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,oCAAoC,CAAC;AAI5C,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,UAAU,CAAC;IACf,MAAM,EAAE,oBAAoB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,qBAAqB,CAAC;IACtC,iBAAiB,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACrD,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,EACzC,EAAE,EACF,MAAM,EACN,WAAW,EACX,cAAc,EACd,iBAAiB,GAClB,EAAE,kCAAkC,GAAG,aAAa,CAyCpD"}
+{"version":3,"file":"backup-cleanup-monitor-factory.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAMpE,OAAO,EAAyB,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,sBAAsB,CAAC;AAEhE,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,oCAAoC,CAAC;AAG5C,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,UAAU,CAAC;IACf,MAAM,EAAE,oBAAoB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,qBAAqB,CAAC;IACtC,iBAAiB,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACrD,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,EACzC,EAAE,EACF,MAAM,EACN,WAAW,EACX,cAAc,EACd,iBAAiB,GAClB,EAAE,kCAAkC,GAAG,aAAa,CAyBpD"}

package/out/zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.js

@@ -1,27 +1,16 @@
-import { must } from "../../../../shared/src/must.js";
-import { getLastBackupTime } from "../litestream/commands.js";
+import { backupDestinationURL, getLastBackupTime } from "../litestream/commands.js";
 import { BackupMonitor } from "./backup-monitor.js";
+import { LitestreamSyncRequester } from "./litestream-sync-requester.js";
 import { Litestream3PrometheusPoller } from "./litestream3-prometheus-poller.js";
 import { ReplicaPoller } from "./replica-poller.js";
-import { VfsWatermarkPoller } from "./vfs-watermark-poller.js";
 //#region ../zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.ts
 function createBackupCleanupMonitor({ lc, config, replicaFile, changeStreamer, verifyBackupState }) {
-	const { log, litestream, replica } = config;
-	const { backupURL } = litestream;
+	const { litestream, replica } = config;
+	const backupURL = backupDestinationURL(litestream);
 	let stream;
 	if (!backupURL) stream = new ReplicaPoller(lc, replicaFile).start();
-	else if (config.litestream.backupUsingV5) {
-		const { logLevel, endpoint, region, vfsQueryExecutable, vfsPollIntervalMs: remotePollIntervalMs } = litestream;
-		stream = new VfsWatermarkPoller(lc, replicaFile, {
-			executable: must(vfsQueryExecutable, `litestream-vfs-query-executable must be defined`),
-			remotePollIntervalMs,
-			backupURL,
-			region,
-			endpoint,
-			logLevel,
-			logFormat: log.format
-		}).start();
-	} else {
+	else if (config.litestream.backupUsingV5) stream = new LitestreamSyncRequester(lc, replicaFile, { intervalMs: litestream.incrementalBackupIntervalSeconds * 1e3 }).start();
+	else {
 		const { port: metricsPort } = litestream;
 		stream = new Litestream3PrometheusPoller(lc, replicaFile, backupURL, `http://localhost:${metricsPort}/metrics`, verifyBackupState ?? (() => getLastBackupTime(lc, litestream, replica.file))).start();
 	}

package/out/zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"backup-cleanup-monitor-factory.js","names":[],"sources":["../../../../../../zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {must} from '../../../../shared/src/must.ts';\nimport type {NormalizedZeroConfig} from '../../config/normalize.ts';\nimport type {Source} from '../../types/streams.ts';\nimport {getLastBackupTime} from '../litestream/commands.ts';\nimport {type BackedUpWatermark, BackupMonitor} from './backup-monitor.ts';\nimport type {ChangeStreamerService} from './change-streamer.ts';\nimport {\n  type BackupStateVerifier,\n  Litestream3PrometheusPoller,\n} from './litestream3-prometheus-poller.ts';\nimport {ReplicaPoller} from './replica-poller.ts';\nimport {VfsWatermarkPoller} from './vfs-watermark-poller.ts';\n\nexport type BackupCleanupMonitorFactoryOptions = {\n  lc: LogContext;\n  config: NormalizedZeroConfig;\n  replicaFile: string;\n  changeStreamer: ChangeStreamerService;\n  verifyBackupState?: BackupStateVerifier | undefined;\n};\n\nexport function createBackupCleanupMonitor({\n  lc,\n  config,\n  replicaFile,\n  changeStreamer,\n  verifyBackupState,\n}: BackupCleanupMonitorFactoryOptions): BackupMonitor {\n  const {log, litestream, replica} = config;\n  const {backupURL} = litestream;\n\n  let stream: Source<BackedUpWatermark>;\n\n  if (!backupURL) {\n    stream = new ReplicaPoller(lc, replicaFile).start();\n  } else if (config.litestream.backupUsingV5) {\n    const {\n      logLevel,\n      endpoint,\n      region,\n      vfsQueryExecutable,\n      vfsPollIntervalMs: remotePollIntervalMs,\n    } = litestream;\n    stream = new VfsWatermarkPoller(lc, replicaFile, {\n      executable: must(\n        vfsQueryExecutable,\n        `litestream-vfs-query-executable must be defined`,\n      ),\n      remotePollIntervalMs,\n      backupURL,\n      region,\n      endpoint,\n      logLevel,\n      logFormat: log.format,\n    }).start();\n  } else {\n    const {port: metricsPort} = litestream;\n    stream = new Litestream3PrometheusPoller(\n      lc,\n      replicaFile,\n      backupURL,\n      `http://localhost:${metricsPort}/metrics`,\n      verifyBackupState ??\n        (() => getLastBackupTime(lc, litestream, replica.file)),\n    ).start();\n  }\n\n  return new BackupMonitor(lc, stream, changeStreamer, replicaFile);\n}\n"],"mappings":";;;;;;;AAsBA,SAAgB,2BAA2B,EACzC,IACA,QACA,aACA,gBACA,qBACoD;CACpD,MAAM,EAAC,KAAK,YAAY,YAAW;CACnC,MAAM,EAAC,cAAa;CAEpB,IAAI;CAEJ,IAAI,CAAC,WACH,SAAS,IAAI,cAAc,IAAI,WAAW,EAAE,MAAM;MAC7C,IAAI,OAAO,WAAW,eAAe;EAC1C,MAAM,EACJ,UACA,UACA,QACA,oBACA,mBAAmB,yBACjB;EACJ,SAAS,IAAI,mBAAmB,IAAI,aAAa;GAC/C,YAAY,KACV,oBACA,iDACF;GACA;GACA;GACA;GACA;GACA;GACA,WAAW,IAAI;EACjB,CAAC,EAAE,MAAM;CACX,OAAO;EACL,MAAM,EAAC,MAAM,gBAAe;EAC5B,SAAS,IAAI,4BACX,IACA,aACA,WACA,oBAAoB,YAAY,WAChC,4BACS,kBAAkB,IAAI,YAAY,QAAQ,IAAI,EACzD,EAAE,MAAM;CACV;CAEA,OAAO,IAAI,cAAc,IAAI,QAAQ,gBAAgB,WAAW;AAClE"}
+{"version":3,"file":"backup-cleanup-monitor-factory.js","names":[],"sources":["../../../../../../zero-cache/src/services/change-streamer/backup-cleanup-monitor-factory.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {NormalizedZeroConfig} from '../../config/normalize.ts';\nimport type {Source} from '../../types/streams.ts';\nimport {\n  backupDestinationURL,\n  getLastBackupTime,\n} from '../litestream/commands.ts';\nimport {type BackedUpWatermark, BackupMonitor} from './backup-monitor.ts';\nimport type {ChangeStreamerService} from './change-streamer.ts';\nimport {LitestreamSyncRequester} from './litestream-sync-requester.ts';\nimport {\n  type BackupStateVerifier,\n  Litestream3PrometheusPoller,\n} from './litestream3-prometheus-poller.ts';\nimport {ReplicaPoller} from './replica-poller.ts';\n\nexport type BackupCleanupMonitorFactoryOptions = {\n  lc: LogContext;\n  config: NormalizedZeroConfig;\n  replicaFile: string;\n  changeStreamer: ChangeStreamerService;\n  verifyBackupState?: BackupStateVerifier | undefined;\n};\n\nexport function createBackupCleanupMonitor({\n  lc,\n  config,\n  replicaFile,\n  changeStreamer,\n  verifyBackupState,\n}: BackupCleanupMonitorFactoryOptions): BackupMonitor {\n  const {litestream, replica} = config;\n  const backupURL = backupDestinationURL(litestream);\n\n  let stream: Source<BackedUpWatermark>;\n\n  if (!backupURL) {\n    stream = new ReplicaPoller(lc, replicaFile).start();\n  } else if (config.litestream.backupUsingV5) {\n    stream = new LitestreamSyncRequester(lc, replicaFile, {\n      intervalMs: litestream.incrementalBackupIntervalSeconds * 1000,\n    }).start();\n  } else {\n    const {port: metricsPort} = litestream;\n    stream = new Litestream3PrometheusPoller(\n      lc,\n      replicaFile,\n      backupURL,\n      `http://localhost:${metricsPort}/metrics`,\n      verifyBackupState ??\n        (() => getLastBackupTime(lc, litestream, replica.file)),\n    ).start();\n  }\n\n  return new BackupMonitor(lc, stream, changeStreamer, replicaFile);\n}\n"],"mappings":";;;;;;AAwBA,SAAgB,2BAA2B,EACzC,IACA,QACA,aACA,gBACA,qBACoD;CACpD,MAAM,EAAC,YAAY,YAAW;CAC9B,MAAM,YAAY,qBAAqB,UAAU;CAEjD,IAAI;CAEJ,IAAI,CAAC,WACH,SAAS,IAAI,cAAc,IAAI,WAAW,EAAE,MAAM;MAC7C,IAAI,OAAO,WAAW,eAC3B,SAAS,IAAI,wBAAwB,IAAI,aAAa,EACpD,YAAY,WAAW,mCAAmC,IAC5D,CAAC,EAAE,MAAM;MACJ;EACL,MAAM,EAAC,MAAM,gBAAe;EAC5B,SAAS,IAAI,4BACX,IACA,aACA,WACA,oBAAoB,YAAY,WAChC,4BACS,kBAAkB,IAAI,YAAY,QAAQ,IAAI,EACzD,EAAE,MAAM;CACV;CAEA,OAAO,IAAI,cAAc,IAAI,QAAQ,gBAAgB,WAAW;AAClE"}

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

@@ -1 +1 @@
-{"version":3,"file":"backup-monitor.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backup-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAKjD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,sBAAsB,CAAC;AAEhE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,qBAAa,aAAc,YAAW,gBAAgB;;IACpD,QAAQ,CAAC,EAAE,oBAAoB;IAS/B,YACE,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,MAAM,CAAC,iBAAiB,CAAC,EACrC,cAAc,EAAE,qBAAqB,EACrC,WAAW,EAAE,MAAM,EAMpB;IAED,mBAAmB,kBAElB;IAEK,GAAG,kBAmBR;IAED,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAGpB;CA+BF"}
+{"version":3,"file":"backup-monitor.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/backup-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAKjD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,sBAAsB,CAAC;AAEhE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,qBAAa,aAAc,YAAW,gBAAgB;;IACpD,QAAQ,CAAC,EAAE,oBAAoB;IAiB/B,YACE,EAAE,EAAE,UAAU,EACd,UAAU,EAAE,MAAM,CAAC,iBAAiB,CAAC,EACrC,cAAc,EAAE,qBAAqB,EACrC,WAAW,EAAE,MAAM,EAMpB;IAED,mBAAmB,kBAElB;IAEK,GAAG,kBA8BR;IAqDD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAGpB;CA+BF"}

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

@@ -11,6 +11,14 @@ var BackupMonitor = class {
 	#replicaFile;
 	#firstBackupReceived = resolver();
 	#latestBackup;
+	#firstBackupResolved = false;
+	/**
+	* The replica's `stateVersion` when the monitor started, i.e. the point the
+	* backup has to reach before it covers what this task is about to serve.
+	* `undefined` when the replica could not be read, which degrades the gate to
+	* "any watermark" rather than hanging startup forever.
+	*/
+	#coverageTarget;
 	constructor(lc, watermarks, changeStreamer, replicaFile) {
 		this.#lc = lc;
 		this.#watermarks = watermarks;
@@ -23,21 +31,64 @@ var BackupMonitor = class {
 	async run() {
 		this.#lc.info?.("starting backup monitor");
 		this.#initBackupLagMetric();
+		this.#coverageTarget = this.#readReplicaStateVersion();
 		for await (const backedUp of this.#watermarks) {
-			if (!this.#latestBackup) this.#firstBackupReceived.resolve();
-			else if (backedUp.watermark < this.#latestBackup.watermark) {
-				this.#lc.warn?.(`ignoring earlier backup watermark`, { backedUp });
-				continue;
-			} else if (backedUp.watermark === this.#latestBackup.watermark) {
-				this.#lc.debug?.(`ignoring redundant backup watermark`, { backedUp });
-				continue;
+			if (this.#latestBackup) {
+				if (backedUp.watermark < this.#latestBackup.watermark) {
+					this.#lc.warn?.(`ignoring earlier backup watermark ${backedUp.watermark}`, { backedUp });
+					continue;
+				}
+				if (backedUp.watermark === this.#latestBackup.watermark) {
+					this.#lc.debug?.(`ignoring redundant backup watermark ${backedUp.watermark}`, { backedUp });
+					continue;
+				}
 			}
-			this.#lc.info?.(`received backup watermark`, { backedUp });
+			this.#lc.info?.(`received backup watermark ${backedUp.watermark}`, { backedUp });
 			this.#latestBackup = backedUp;
 			this.#changeStreamer.trackBackupWatermark(backedUp.watermark);
+			this.#checkFirstBackupCovers(backedUp);
 		}
 		this.#lc.info?.("watermark stream closed. BackupMonitor stopped.");
 	}
+	/**
+	* Resolves {@link firstBackupReceived} once the backup actually covers the
+	* replica, rather than on the first watermark of any value.
+	*
+	* A new backup destination starts empty and is filled by re-uploading the
+	* local LTX chain, so the first watermarks read back out of it are real but
+	* far behind the replica. Releasing the readiness gate on one of those lets
+	* the task serve against a backup that does not yet cover it, which is what
+	* demotes a restoring view-syncer to Postgres catchup.
+	*
+	* The target is pinned at startup rather than compared against the replica's
+	* current position, which keeps the gate satisfiable under sustained writes.
+	*/
+	#checkFirstBackupCovers(backedUp) {
+		if (this.#firstBackupResolved) return;
+		const target = this.#coverageTarget;
+		if (target !== void 0 && backedUp.watermark < target) {
+			this.#lc.info?.(`backup does not yet cover the replica`, {
+				backedUp,
+				coverageTarget: target
+			});
+			return;
+		}
+		this.#firstBackupResolved = true;
+		this.#firstBackupReceived.resolve();
+	}
+	#readReplicaStateVersion() {
+		let db;
+		try {
+			db = new Database(this.#lc, this.#replicaFile, { readonly: true });
+			const { stateVersion } = db.prepare(`SELECT stateVersion FROM "_zero.replicationState"`).get();
+			return stateVersion;
+		} catch (e) {
+			this.#lc.warn?.("unable to read the replica's stateVersion; the initial backup gate will accept the first watermark", e);
+			return;
+		} finally {
+			db?.close();
+		}
+	}
 	stop() {
 		this.#watermarks.cancel();
 		return promiseVoid;

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

@@ -1 +1 @@
-{"version":3,"file":"backup-monitor.js","names":["#lc","#watermarks","#changeStreamer","#replicaFile","#firstBackupReceived","#initBackupLagMetric","#latestBackup"],"sources":["../../../../../../zero-cache/src/services/change-streamer/backup-monitor.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport {promiseVoid} from '../../../../shared/src/resolved-promises.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {getOrCreateGauge} from '../../observability/metrics.ts';\nimport type {Source} from '../../types/streams.ts';\nimport type {SingletonService} from '../service.ts';\nimport type {ChangeStreamerService} from './change-streamer.ts';\n\nexport type BackedUpWatermark = {\n  watermark: string;\n  writeTimeMs?: number | undefined; // optional for debuggin; available on v5\n  backupTimeMs: number;\n};\n\nexport class BackupMonitor implements SingletonService {\n  readonly id = 'backup-monitor';\n  readonly #lc: LogContext;\n  readonly #watermarks: Source<BackedUpWatermark>;\n  readonly #changeStreamer: ChangeStreamerService;\n  readonly #replicaFile: string;\n  readonly #firstBackupReceived = resolver();\n\n  #latestBackup: BackedUpWatermark | undefined;\n\n  constructor(\n    lc: LogContext,\n    watermarks: Source<BackedUpWatermark>,\n    changeStreamer: ChangeStreamerService,\n    replicaFile: string,\n  ) {\n    this.#lc = lc;\n    this.#watermarks = watermarks;\n    this.#changeStreamer = changeStreamer;\n    this.#replicaFile = replicaFile;\n  }\n\n  firstBackupReceived() {\n    return this.#firstBackupReceived.promise;\n  }\n\n  async run() {\n    this.#lc.info?.('starting backup monitor');\n    this.#initBackupLagMetric();\n\n    for await (const backedUp of this.#watermarks) {\n      if (!this.#latestBackup) {\n        this.#firstBackupReceived.resolve();\n      } else if (backedUp.watermark < this.#latestBackup.watermark) {\n        this.#lc.warn?.(`ignoring earlier backup watermark`, {backedUp});\n        continue;\n      } else if (backedUp.watermark === this.#latestBackup.watermark) {\n        this.#lc.debug?.(`ignoring redundant backup watermark`, {backedUp});\n        continue;\n      }\n      this.#lc.info?.(`received backup watermark`, {backedUp});\n      this.#latestBackup = backedUp;\n      this.#changeStreamer.trackBackupWatermark(backedUp.watermark);\n    }\n    this.#lc.info?.('watermark stream closed. BackupMonitor stopped.');\n  }\n\n  stop(): Promise<void> {\n    this.#watermarks.cancel();\n    return promiseVoid;\n  }\n\n  #initBackupLagMetric() {\n    getOrCreateGauge('replica', 'backup_lag', {\n      description:\n        'Latency from when a change is written to the replica ' +\n        'to when it is backed up to litestream. It is expected to create a saw ' +\n        'pattern from 0 to the configured ZERO_LITESTREAM_INCREMENTAL_BACKUP_INTERVAL_MINUTES.',\n      unit: 'millisecond',\n    }).addCallback(o => {\n      const latestBackup = this.#latestBackup;\n      if (!latestBackup) {\n        this.#lc.warn?.(\n          `no backed up watermarks. unable to report replica.backup_lag`,\n        );\n        return;\n      }\n      const db = new Database(this.#lc, this.#replicaFile, {readonly: true});\n      try {\n        const {writeTimeMs} = db\n          .prepare(/*sql*/ `SELECT writeTimeMs FROM \"_zero.replicationState\"`)\n          .get<{writeTimeMs: number}>();\n        const backupLag = Math.max(0, writeTimeMs - latestBackup.backupTimeMs);\n        o.observe(backupLag);\n      } catch (e) {\n        this.#lc.warn?.(`error measuring replica.backup_lag metric`, e);\n      } finally {\n        db.close();\n      }\n    });\n  }\n}\n"],"mappings":";;;;;AAeA,IAAa,gBAAb,MAAuD;CACrD,KAAc;CACd;CACA;CACA;CACA;CACA,uBAAgC,SAAS;CAEzC;CAEA,YACE,IACA,YACA,gBACA,aACA;EACA,KAAKA,MAAM;EACX,KAAKC,cAAc;EACnB,KAAKC,kBAAkB;EACvB,KAAKC,eAAe;CACtB;CAEA,sBAAsB;EACpB,OAAO,KAAKC,qBAAqB;CACnC;CAEA,MAAM,MAAM;EACV,KAAKJ,IAAI,OAAO,yBAAyB;EACzC,KAAKK,qBAAqB;EAE1B,WAAW,MAAM,YAAY,KAAKJ,aAAa;GAC7C,IAAI,CAAC,KAAKK,eACR,KAAKF,qBAAqB,QAAQ;QAC7B,IAAI,SAAS,YAAY,KAAKE,cAAc,WAAW;IAC5D,KAAKN,IAAI,OAAO,qCAAqC,EAAC,SAAQ,CAAC;IAC/D;GACF,OAAO,IAAI,SAAS,cAAc,KAAKM,cAAc,WAAW;IAC9D,KAAKN,IAAI,QAAQ,uCAAuC,EAAC,SAAQ,CAAC;IAClE;GACF;GACA,KAAKA,IAAI,OAAO,6BAA6B,EAAC,SAAQ,CAAC;GACvD,KAAKM,gBAAgB;GACrB,KAAKJ,gBAAgB,qBAAqB,SAAS,SAAS;EAC9D;EACA,KAAKF,IAAI,OAAO,iDAAiD;CACnE;CAEA,OAAsB;EACpB,KAAKC,YAAY,OAAO;EACxB,OAAO;CACT;CAEA,uBAAuB;EACrB,iBAAiB,WAAW,cAAc;GACxC,aACE;GAGF,MAAM;EACR,CAAC,EAAE,aAAY,MAAK;GAClB,MAAM,eAAe,KAAKK;GAC1B,IAAI,CAAC,cAAc;IACjB,KAAKN,IAAI,OACP,8DACF;IACA;GACF;GACA,MAAM,KAAK,IAAI,SAAS,KAAKA,KAAK,KAAKG,cAAc,EAAC,UAAU,KAAI,CAAC;GACrE,IAAI;IACF,MAAM,EAAC,gBAAe,GACnB,QAAgB,kDAAkD,EAClE,IAA2B;IAC9B,MAAM,YAAY,KAAK,IAAI,GAAG,cAAc,aAAa,YAAY;IACrE,EAAE,QAAQ,SAAS;GACrB,SAAS,GAAG;IACV,KAAKH,IAAI,OAAO,6CAA6C,CAAC;GAChE,UAAU;IACR,GAAG,MAAM;GACX;EACF,CAAC;CACH;AACF"}
+{"version":3,"file":"backup-monitor.js","names":["#lc","#watermarks","#changeStreamer","#replicaFile","#firstBackupReceived","#initBackupLagMetric","#coverageTarget","#readReplicaStateVersion","#latestBackup","#checkFirstBackupCovers","#firstBackupResolved"],"sources":["../../../../../../zero-cache/src/services/change-streamer/backup-monitor.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport {promiseVoid} from '../../../../shared/src/resolved-promises.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {getOrCreateGauge} from '../../observability/metrics.ts';\nimport type {Source} from '../../types/streams.ts';\nimport type {SingletonService} from '../service.ts';\nimport type {ChangeStreamerService} from './change-streamer.ts';\n\nexport type BackedUpWatermark = {\n  watermark: string;\n  writeTimeMs?: number | undefined; // optional for debugging; available on v5\n  backupTimeMs: number;\n};\n\nexport class BackupMonitor implements SingletonService {\n  readonly id = 'backup-monitor';\n  readonly #lc: LogContext;\n  readonly #watermarks: Source<BackedUpWatermark>;\n  readonly #changeStreamer: ChangeStreamerService;\n  readonly #replicaFile: string;\n  readonly #firstBackupReceived = resolver();\n\n  #latestBackup: BackedUpWatermark | undefined;\n  #firstBackupResolved = false;\n  /**\n   * The replica's `stateVersion` when the monitor started, i.e. the point the\n   * backup has to reach before it covers what this task is about to serve.\n   * `undefined` when the replica could not be read, which degrades the gate to\n   * \"any watermark\" rather than hanging startup forever.\n   */\n  #coverageTarget: string | undefined;\n\n  constructor(\n    lc: LogContext,\n    watermarks: Source<BackedUpWatermark>,\n    changeStreamer: ChangeStreamerService,\n    replicaFile: string,\n  ) {\n    this.#lc = lc;\n    this.#watermarks = watermarks;\n    this.#changeStreamer = changeStreamer;\n    this.#replicaFile = replicaFile;\n  }\n\n  firstBackupReceived() {\n    return this.#firstBackupReceived.promise;\n  }\n\n  async run() {\n    this.#lc.info?.('starting backup monitor');\n    this.#initBackupLagMetric();\n    this.#coverageTarget = this.#readReplicaStateVersion();\n\n    for await (const backedUp of this.#watermarks) {\n      if (this.#latestBackup) {\n        if (backedUp.watermark < this.#latestBackup.watermark) {\n          this.#lc.warn?.(\n            `ignoring earlier backup watermark ${backedUp.watermark}`,\n            {backedUp},\n          );\n          continue;\n        }\n        if (backedUp.watermark === this.#latestBackup.watermark) {\n          this.#lc.debug?.(\n            `ignoring redundant backup watermark ${backedUp.watermark}`,\n            {backedUp},\n          );\n          continue;\n        }\n      }\n      this.#lc.info?.(`received backup watermark ${backedUp.watermark}`, {\n        backedUp,\n      });\n      this.#latestBackup = backedUp;\n      this.#changeStreamer.trackBackupWatermark(backedUp.watermark);\n      this.#checkFirstBackupCovers(backedUp);\n    }\n    this.#lc.info?.('watermark stream closed. BackupMonitor stopped.');\n  }\n\n  /**\n   * Resolves {@link firstBackupReceived} once the backup actually covers the\n   * replica, rather than on the first watermark of any value.\n   *\n   * A new backup destination starts empty and is filled by re-uploading the\n   * local LTX chain, so the first watermarks read back out of it are real but\n   * far behind the replica. Releasing the readiness gate on one of those lets\n   * the task serve against a backup that does not yet cover it, which is what\n   * demotes a restoring view-syncer to Postgres catchup.\n   *\n   * The target is pinned at startup rather than compared against the replica's\n   * current position, which keeps the gate satisfiable under sustained writes.\n   */\n  #checkFirstBackupCovers(backedUp: BackedUpWatermark) {\n    if (this.#firstBackupResolved) {\n      return;\n    }\n    const target = this.#coverageTarget;\n    if (target !== undefined && backedUp.watermark < target) {\n      this.#lc.info?.(`backup does not yet cover the replica`, {\n        backedUp,\n        coverageTarget: target,\n      });\n      return;\n    }\n    this.#firstBackupResolved = true;\n    this.#firstBackupReceived.resolve();\n  }\n\n  #readReplicaStateVersion(): string | undefined {\n    let db;\n    try {\n      db = new Database(this.#lc, this.#replicaFile, {readonly: true});\n      const {stateVersion} = db\n        .prepare(/*sql*/ `SELECT stateVersion FROM \"_zero.replicationState\"`)\n        .get<{stateVersion: string}>();\n      return stateVersion;\n    } catch (e) {\n      // Without a target the gate degrades to its previous behavior. That is\n      // strictly better than blocking startup on a replica we cannot read.\n      this.#lc.warn?.(\n        `unable to read the replica's stateVersion; ` +\n          `the initial backup gate will accept the first watermark`,\n        e,\n      );\n      return undefined;\n    } finally {\n      db?.close();\n    }\n  }\n\n  stop(): Promise<void> {\n    this.#watermarks.cancel();\n    return promiseVoid;\n  }\n\n  #initBackupLagMetric() {\n    getOrCreateGauge('replica', 'backup_lag', {\n      description:\n        'Latency from when a change is written to the replica ' +\n        'to when it is backed up to litestream. It is expected to create a saw ' +\n        'pattern from 0 to the configured ZERO_LITESTREAM_INCREMENTAL_BACKUP_INTERVAL_MINUTES.',\n      unit: 'millisecond',\n    }).addCallback(o => {\n      const latestBackup = this.#latestBackup;\n      if (!latestBackup) {\n        this.#lc.warn?.(\n          `no backed up watermarks. unable to report replica.backup_lag`,\n        );\n        return;\n      }\n      const db = new Database(this.#lc, this.#replicaFile, {readonly: true});\n      try {\n        const {writeTimeMs} = db\n          .prepare(/*sql*/ `SELECT writeTimeMs FROM \"_zero.replicationState\"`)\n          .get<{writeTimeMs: number}>();\n        const backupLag = Math.max(0, writeTimeMs - latestBackup.backupTimeMs);\n        o.observe(backupLag);\n      } catch (e) {\n        this.#lc.warn?.(`error measuring replica.backup_lag metric`, e);\n      } finally {\n        db.close();\n      }\n    });\n  }\n}\n"],"mappings":";;;;;AAeA,IAAa,gBAAb,MAAuD;CACrD,KAAc;CACd;CACA;CACA;CACA;CACA,uBAAgC,SAAS;CAEzC;CACA,uBAAuB;;;;;;;CAOvB;CAEA,YACE,IACA,YACA,gBACA,aACA;EACA,KAAKA,MAAM;EACX,KAAKC,cAAc;EACnB,KAAKC,kBAAkB;EACvB,KAAKC,eAAe;CACtB;CAEA,sBAAsB;EACpB,OAAO,KAAKC,qBAAqB;CACnC;CAEA,MAAM,MAAM;EACV,KAAKJ,IAAI,OAAO,yBAAyB;EACzC,KAAKK,qBAAqB;EAC1B,KAAKC,kBAAkB,KAAKC,yBAAyB;EAErD,WAAW,MAAM,YAAY,KAAKN,aAAa;GAC7C,IAAI,KAAKO,eAAe;IACtB,IAAI,SAAS,YAAY,KAAKA,cAAc,WAAW;KACrD,KAAKR,IAAI,OACP,qCAAqC,SAAS,aAC9C,EAAC,SAAQ,CACX;KACA;IACF;IACA,IAAI,SAAS,cAAc,KAAKQ,cAAc,WAAW;KACvD,KAAKR,IAAI,QACP,uCAAuC,SAAS,aAChD,EAAC,SAAQ,CACX;KACA;IACF;GACF;GACA,KAAKA,IAAI,OAAO,6BAA6B,SAAS,aAAa,EACjE,SACF,CAAC;GACD,KAAKQ,gBAAgB;GACrB,KAAKN,gBAAgB,qBAAqB,SAAS,SAAS;GAC5D,KAAKO,wBAAwB,QAAQ;EACvC;EACA,KAAKT,IAAI,OAAO,iDAAiD;CACnE;;;;;;;;;;;;;;CAeA,wBAAwB,UAA6B;EACnD,IAAI,KAAKU,sBACP;EAEF,MAAM,SAAS,KAAKJ;EACpB,IAAI,WAAW,KAAA,KAAa,SAAS,YAAY,QAAQ;GACvD,KAAKN,IAAI,OAAO,yCAAyC;IACvD;IACA,gBAAgB;GAClB,CAAC;GACD;EACF;EACA,KAAKU,uBAAuB;EAC5B,KAAKN,qBAAqB,QAAQ;CACpC;CAEA,2BAA+C;EAC7C,IAAI;EACJ,IAAI;GACF,KAAK,IAAI,SAAS,KAAKJ,KAAK,KAAKG,cAAc,EAAC,UAAU,KAAI,CAAC;GAC/D,MAAM,EAAC,iBAAgB,GACpB,QAAgB,mDAAmD,EACnE,IAA4B;GAC/B,OAAO;EACT,SAAS,GAAG;GAGV,KAAKH,IAAI,OACP,sGAEA,CACF;GACA;EACF,UAAU;GACR,IAAI,MAAM;EACZ;CACF;CAEA,OAAsB;EACpB,KAAKC,YAAY,OAAO;EACxB,OAAO;CACT;CAEA,uBAAuB;EACrB,iBAAiB,WAAW,cAAc;GACxC,aACE;GAGF,MAAM;EACR,CAAC,EAAE,aAAY,MAAK;GAClB,MAAM,eAAe,KAAKO;GAC1B,IAAI,CAAC,cAAc;IACjB,KAAKR,IAAI,OACP,8DACF;IACA;GACF;GACA,MAAM,KAAK,IAAI,SAAS,KAAKA,KAAK,KAAKG,cAAc,EAAC,UAAU,KAAI,CAAC;GACrE,IAAI;IACF,MAAM,EAAC,gBAAe,GACnB,QAAgB,kDAAkD,EAClE,IAA2B;IAC9B,MAAM,YAAY,KAAK,IAAI,GAAG,cAAc,aAAa,YAAY;IACrE,EAAE,QAAQ,SAAS;GACrB,SAAS,GAAG;IACV,KAAKH,IAAI,OAAO,6CAA6C,CAAC;GAChE,UAAU;IACR,GAAG,MAAM;GACX;EACF,CAAC;CACH;AACF"}

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

@@ -1,7 +1,13 @@
 import type { LogContext } from '@rocicorp/logger';
+import { type PreSerialized } from '../../types/streams.ts';
 import type { WatermarkedChange } from './change-streamer.ts';
 import type { Subscriber } from './subscriber.ts';
 export type BroadcastReleaseMode = 'all-subscribers' | 'consensus-timeout';
+export type PreSerializedBatch = PreSerialized & {
+    readonly changes: readonly WatermarkedChange[];
+};
+export declare function isPreSerializedBatch(val: unknown): val is PreSerializedBatch;
+export declare function preSerializeBatch(changes: readonly WatermarkedChange[]): PreSerializedBatch;
 /**
  * Enables event-driven early release of a {@link Broadcast}. When provided and a
  * majority has acked, the broadcast schedules its own consensus-timeout release
@@ -78,12 +84,12 @@ export declare class Broadcast {
      * Sends the change to the subscribers without the tracking machinery.
      * This is suitable for fire-and-forget (i.e. pipelined) sends.
      */
-    static withoutTracking(subscribers: Iterable<Subscriber>, change: WatermarkedChange): void;
+    static withoutTracking(subscribers: Iterable<Subscriber>, change: WatermarkedChange | readonly WatermarkedChange[]): void;
     /**
      * Broadcasts the `change` to the `subscribers` and tracks their
      * completion.
      */
-    constructor(lc: LogContext, subscribers: Iterable<Subscriber>, change: WatermarkedChange, earlyRelease?: EarlyReleaseOptions);
+    constructor(lc: LogContext, subscribers: Iterable<Subscriber>, change: WatermarkedChange | readonly WatermarkedChange[], earlyRelease?: EarlyReleaseOptions);
     get isDone(): boolean;
     get done(): Promise<void>;
     get releaseMode(): BroadcastReleaseMode;

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

@@ -1 +1 @@
-{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/broadcast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAEhD,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG,mBAAmB,CAAC;AAE3E;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,2EAA2E;IAC3E,0BAA0B,EAAE,MAAM,CAAC;IACnC,mDAAmD;IACnD,YAAY,CAAC,EAAE,OAAO,UAAU,CAAC;IACjC,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,YAAY,CAAC;CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,qBAAa,SAAS;;IACpB;;;OAGG;IACH,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EACjC,MAAM,EAAE,iBAAiB,QAK1B;IA0BD;;;OAGG;IACH,YACE,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EACjC,MAAM,EAAE,iBAAiB,EACzB,YAAY,CAAC,EAAE,mBAAmB,EA6BnC;IAwDD,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAExB;IAED,IAAI,WAAW,IAAI,oBAAoB,CAEtC;IAED,eAAe,CAAC,GAAG,EAAE,MAAM,QAa1B;CAiBF"}
+{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/broadcast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAAkB,KAAK,aAAa,EAAC,MAAM,wBAAwB,CAAC;AAC3E,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAEhD,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG,mBAAmB,CAAC;AAE3E,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,QAAQ,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAChD,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAE5E;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,iBAAiB,EAAE,GACpC,kBAAkB,CAYpB;AAED;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,2EAA2E;IAC3E,0BAA0B,EAAE,MAAM,CAAC;IACnC,mDAAmD;IACnD,YAAY,CAAC,EAAE,OAAO,UAAU,CAAC;IACjC,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,YAAY,CAAC;CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,qBAAa,SAAS;;IACpB;;;OAGG;IACH,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EACjC,MAAM,EAAE,iBAAiB,GAAG,SAAS,iBAAiB,EAAE,QAOzD;IA0BD;;;OAGG;IACH,YACE,EAAE,EAAE,UAAU,EACd,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,EACjC,MAAM,EAAE,iBAAiB,GAAG,SAAS,iBAAiB,EAAE,EACxD,YAAY,CAAC,EAAE,mBAAmB,EA+BnC;IAwDD,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAExB;IAED,IAAI,WAAW,IAAI,oBAAoB,CAEtC;IAED,eAAe,CAAC,GAAG,EAAE,MAAM,QAa1B;CAiBF"}

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

@@ -1,5 +1,17 @@
+import { must } from "../../../../shared/src/must.js";
+import "../../types/streams.js";
 import { resolver } from "@rocicorp/resolver";
 //#region ../zero-cache/src/services/change-streamer/broadcast.ts
+function preSerializeBatch(changes) {
+	const jsonList = changes.map((c) => c[2]);
+	const joined = jsonList.join(",");
+	const payload = Buffer.from(changes.length === 1 ? `,"msg":${jsonList[0]}}` : `,"batch":[${joined}]}`, "utf8");
+	return {
+		changes,
+		payload,
+		byteLength: payload.length
+	};
+}
 /**
 * Initiates and tracks the progress of a change broadcasted to
 * a set of subscribers, implementing **consensus-based timeouts**
@@ -62,7 +74,9 @@ var Broadcast = class {
 	* This is suitable for fire-and-forget (i.e. pipelined) sends.
 	*/
 	static withoutTracking(subscribers, change) {
-		for (const sub of subscribers) sub.send(change);
+		const changes = toBatch(change);
+		const preSerialized = preSerializeBatch(changes);
+		for (const sub of subscribers) sub.sendBatch(changes, preSerialized);
 	}
 	#lc;
 	#pending;
@@ -83,18 +97,20 @@ var Broadcast = class {
 	* completion.
 	*/
 	constructor(lc, subscribers, change, earlyRelease) {
+		const changes = toBatch(change);
+		const preSerialized = preSerializeBatch(changes);
 		this.#lc = lc;
 		this.#pending = new Set(subscribers);
 		this.#completed = [];
-		this.#watermark = change[0];
+		this.#watermark = must(changes.at(-1))[0];
 		this.#majority = Math.floor(this.#pending.size / 2) + 1;
 		this.#earlyReleaseTimeoutProportion = earlyRelease?.consensusTimeoutProportion;
 		this.#setTimeout = earlyRelease?.setTimeoutFn ?? setTimeout;
 		this.#clearTimeout = earlyRelease?.clearTimeoutFn ?? clearTimeout;
 		for (const sub of this.#pending) {
-			const changes = sub.numPending + 1;
+			const totalChanges = sub.numPending + changes.length;
 			if (sub.mode === "backup") this.#needsBackupResponse ||= !sub.isBacklogged();
-			sub.send(change).catch(() => {}).finally(() => this.#markCompleted(sub, changes));
+			sub.sendBatch(changes, preSerialized).catch(() => {}).finally(() => this.#markCompleted(sub, totalChanges));
 		}
 		if (this.#pending.size === 0) this.#setDone("all-subscribers");
 	}
@@ -161,6 +177,10 @@ var Broadcast = class {
 		});
 	}
 };
+function toBatch(change) {
+	if (change.length === 0) return [];
+	return Array.isArray(change[0]) ? change : [change];
+}
 //#endregion
 export { Broadcast };