@rocicorp/zero 1.11.0-canary.35 → 1.11.0-canary.37

package/out/zero-cache/src/services/view-syncer/batch-pacer.d.ts

@@ -0,0 +1,79 @@
+import type { LogContext } from '@rocicorp/logger';
+export type BatchPacerOptions = {
+    /**
+     * The largest share of the worker's time that it may be busy before its
+     * client groups are paced.
+     */
+    readonly shareTarget: number;
+    /** The longest a client group waits between batches. */
+    readonly maxIntervalMs: number;
+    readonly now?: (() => number) | undefined;
+    /**
+     * The share of the time since the previous call that the worker was busy.
+     * By default, the utilization of the event loop.
+     */
+    readonly utilization?: (() => number) | undefined;
+    /** Where the worker says that it is pacing its client groups. */
+    readonly lc?: LogContext | undefined;
+};
+/**
+ * Paces the batches (advancements, including the queries they hydrate
+ * again) of the client groups of a sync worker, so that the worker is left
+ * with time for new hydrations and connections, and gives the hydrations of
+ * new queries priority over the batches.
+ *
+ * **Pacing.** After each batch, a client group waits {@link waitMs} before
+ * it starts the next. The wait is a multiple of the batch's processing
+ * time, so a client group that always has changes waiting is busy at most
+ * `1 / (1 + k)` of the time, where `k` is the {@link multiplier}. Because
+ * the wait is in proportion to a client group's own processing time, those
+ * that cause the load are slowed the most, and cheap ones barely at all.
+ *
+ * The multiplier is shared by the client groups of the worker. Once per
+ * second, it is scaled by how far the share of its time that the worker was
+ * busy, smoothed over a few seconds, is from the target, and by more while
+ * the worker has no time to spare. It never goes below 0, where no client
+ * group waits. The share is the utilization of the worker's event loop, i.e. all
+ * of what the worker does: what a batch costs is spread over the pipelines,
+ * the CVR, the pokes and garbage collection, and is not measurable batch by
+ * batch.
+ *
+ * **Priority of new hydrations.** The worker's time slices are handed out
+ * by the pacer (see {@link yieldSlice}), and while the hydration of new
+ * queries is waiting for one, most of them go to it rather than to batches.
+ */
+export declare class BatchPacer {
+    #private;
+    constructor({ shareTarget, maxIntervalMs, now, utilization, lc, }: BatchPacerOptions);
+    /**
+     * How long a client group should wait before its next batch, after one
+     * that took `processingMs` to process. The multiplier changes while a
+     * client group waits, so a long wait should be taken in steps, asking
+     * again after each.
+     */
+    waitMs(processingMs: number): number;
+    /** `k`: a client group waits `k` times the processing time of a batch. */
+    get multiplier(): number;
+    /**
+     * The share of its time that the worker was busy, smoothed over the last
+     * few seconds, as of the last update of the multiplier.
+     */
+    get share(): number;
+    /**
+     * Yields the worker to the other work that is waiting for a time slice,
+     * and resolves when it is the caller's turn again. One piece of work runs
+     * per turn of the event loop, as when the work of a worker's client groups
+     * simply takes turns, except that the hydration of new queries goes first:
+     * while both kinds of work are waiting, `HYDRATION_PRIORITY` slices go to
+     * hydrations for each one that goes to a batch.
+     *
+     * Batches are never made to wait for anything but a slice. If no
+     * hydration is waiting for one (because none is running, or because those
+     * that are running are waiting for I/O), batches get every slice. And
+     * however many hydrations there are, batches keep a share of the slices,
+     * so they keep moving, and so do the snapshots of the replica that they
+     * hold.
+     */
+    yieldSlice(kind: 'hydration' | 'batch'): Promise<void>;
+}
+//# sourceMappingURL=batch-pacer.d.ts.map

package/out/zero-cache/src/services/view-syncer/batch-pacer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-pacer.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/batch-pacer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAyDjD,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAClD,iEAAiE;IACjE,QAAQ,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACtC,CAAC;AAYF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,UAAU;;IA8BrB,YAAY,EACV,WAAW,EACX,aAAa,EACb,GAAG,EACH,WAAW,EACX,EAAE,GACH,EAAE,iBAAiB,EAOnB;IAED;;;;;OAKG;IACH,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CASnC;IAED,0EAA0E;IAC1E,IAAI,UAAU,IAAI,MAAM,CAGvB;IAED;;;OAGG;IACH,IAAI,KAAK,IAAI,MAAM,CAGlB;IA+FD;;;;;;;;;;;;;;OAcG;IACH,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAQrD;CAuBF"}

package/out/zero-cache/src/services/view-syncer/batch-pacer.js

@@ -0,0 +1,249 @@
+import { performance } from "node:perf_hooks";
+//#region ../zero-cache/src/services/view-syncer/batch-pacer.ts
+/** How often the multiplier is updated. */
+var UPDATE_INTERVAL_MS = 1e3;
+/**
+* The weight of the latest second in the worker's smoothed busy share.
+* Client groups that wait for seconds between batches make the share of
+* any one second jump between idle and saturated, and a worker that keeps
+* up has the odd busy second. Neither says what the load is.
+*/
+var SHARE_SMOOTHING = .3;
+/**
+* How much of the difference between the smoothed busy share and the target
+* each update corrects for. The smoothed share only shows part of what the
+* previous updates did, so correcting for all of the difference each time
+* would overshoot and oscillate.
+*/
+var CORRECTION_EXPONENT = .3;
+/**
+* The share of its time above which a worker has no time to spare. A share
+* target has to stay well clear of this to be held, which is why
+* `syncUpdateShareTarget` is at most 0.9 (or 1, which no worker is over).
+*/
+var SATURATED_SHARE = .95;
+/** The seconds that a worker has to be saturated for to be treated as such. */
+var SATURATED_SECONDS = 2;
+/**
+* How much `1 + k` is scaled by each second that the worker is saturated.
+* A saturated worker does not show how much more its client groups would
+* use, which can be many times what it has, so the multiplier is raised by
+* more than the difference from the target calls for until it does.
+*/
+var SATURATED_CORRECTION = 1.3;
+/**
+* How often a worker that is pacing its client groups says so in its log,
+* and how long it has to have stopped for to say that it has.
+*/
+var PACING_LOG_INTERVAL_MS = 6e4;
+/**
+* The most updates that are made up for when nothing has asked the pacer
+* for a wait in a while, which is enough for the multiplier to get to 0.
+*/
+var MAX_CATCH_UP_UPDATES = 60;
+/**
+* Bounds the multiplier, which otherwise has no limit while a worker stays
+* over the target however long its client groups wait.
+*/
+var MAX_MULTIPLIER = 1e6;
+function eventLoopUtilization() {
+	let last = performance.eventLoopUtilization();
+	return () => {
+		const current = performance.eventLoopUtilization();
+		const { utilization } = performance.eventLoopUtilization(current, last);
+		last = current;
+		return utilization;
+	};
+}
+/**
+* Paces the batches (advancements, including the queries they hydrate
+* again) of the client groups of a sync worker, so that the worker is left
+* with time for new hydrations and connections, and gives the hydrations of
+* new queries priority over the batches.
+*
+* **Pacing.** After each batch, a client group waits {@link waitMs} before
+* it starts the next. The wait is a multiple of the batch's processing
+* time, so a client group that always has changes waiting is busy at most
+* `1 / (1 + k)` of the time, where `k` is the {@link multiplier}. Because
+* the wait is in proportion to a client group's own processing time, those
+* that cause the load are slowed the most, and cheap ones barely at all.
+*
+* The multiplier is shared by the client groups of the worker. Once per
+* second, it is scaled by how far the share of its time that the worker was
+* busy, smoothed over a few seconds, is from the target, and by more while
+* the worker has no time to spare. It never goes below 0, where no client
+* group waits. The share is the utilization of the worker's event loop, i.e. all
+* of what the worker does: what a batch costs is spread over the pipelines,
+* the CVR, the pokes and garbage collection, and is not measurable batch by
+* batch.
+*
+* **Priority of new hydrations.** The worker's time slices are handed out
+* by the pacer (see {@link yieldSlice}), and while the hydration of new
+* queries is waiting for one, most of them go to it rather than to batches.
+*/
+var BatchPacer = class {
+	#shareTarget;
+	#maxIntervalMs;
+	#now;
+	#utilization;
+	#lc;
+	/** When the worker last logged that it is pacing, while it still is. */
+	#pacingLoggedAt;
+	/** Since when the worker has not been pacing, after it logged that it was. */
+	#notPacingSince;
+	#intervalStart;
+	#multiplier = 0;
+	/** The smoothed share of its time that the worker was busy. */
+	#share = 0;
+	#saturatedSeconds = 0;
+	/** The waits handed out since the last update, by whether at the cap. */
+	#waitsBelowMax = 0;
+	#waitsAtMax = 0;
+	/** The work that is waiting for a time slice, in the order it yielded. */
+	#waiting = {
+		hydration: [],
+		batch: []
+	};
+	#handingOutSlices = false;
+	/** The slices that have gone to hydrations since one went to a batch. */
+	#hydrationSlices = 0;
+	constructor({ shareTarget, maxIntervalMs, now, utilization, lc }) {
+		this.#shareTarget = shareTarget;
+		this.#maxIntervalMs = maxIntervalMs;
+		this.#now = now ?? (() => performance.now());
+		this.#utilization = utilization ?? eventLoopUtilization();
+		this.#lc = lc;
+		this.#intervalStart = this.#now();
+	}
+	/**
+	* How long a client group should wait before its next batch, after one
+	* that took `processingMs` to process. The multiplier changes while a
+	* client group waits, so a long wait should be taken in steps, asking
+	* again after each.
+	*/
+	waitMs(processingMs) {
+		this.#update();
+		const wait = this.#multiplier * processingMs;
+		if (wait < this.#maxIntervalMs) {
+			this.#waitsBelowMax++;
+			return wait;
+		}
+		this.#waitsAtMax++;
+		return this.#maxIntervalMs;
+	}
+	/** `k`: a client group waits `k` times the processing time of a batch. */
+	get multiplier() {
+		this.#update();
+		return this.#multiplier;
+	}
+	/**
+	* The share of its time that the worker was busy, smoothed over the last
+	* few seconds, as of the last update of the multiplier.
+	*/
+	get share() {
+		this.#update();
+		return this.#share;
+	}
+	/** Updates the multiplier for each interval that has ended. */
+	#update() {
+		const now = this.#now();
+		const ended = Math.floor((now - this.#intervalStart) / UPDATE_INTERVAL_MS);
+		if (ended <= 0) return;
+		this.#intervalStart += ended * UPDATE_INTERVAL_MS;
+		const latest = this.#utilization();
+		const allAtMax = this.#waitsAtMax > 0 && this.#waitsBelowMax === 0;
+		this.#waitsAtMax = 0;
+		this.#waitsBelowMax = 0;
+		for (let i = Math.min(ended, MAX_CATCH_UP_UPDATES); i > 0; i--) {
+			this.#share += SHARE_SMOOTHING * (latest - this.#share);
+			this.#saturatedSeconds = latest >= SATURATED_SHARE && latest > this.#shareTarget ? this.#saturatedSeconds + 1 : 0;
+			let correction = this.#saturatedSeconds >= SATURATED_SECONDS ? SATURATED_CORRECTION : (this.#share / this.#shareTarget) ** CORRECTION_EXPONENT;
+			if (allAtMax && correction > 1) correction = 1;
+			this.#multiplier = Math.min(Math.max((1 + this.#multiplier) * correction - 1, 0), MAX_MULTIPLIER);
+		}
+		this.#logPacing(now, allAtMax);
+	}
+	/**
+	* Says in the worker's log when it starts to pace its client groups, once
+	* a minute while it does, and when it has stopped. The pacing of a client
+	* group is logged by its view syncer.
+	*/
+	#logPacing(now, allAtMax) {
+		const lc = this.#lc;
+		if (lc === void 0) return;
+		const state = {
+			busyShare: this.#share,
+			shareTarget: this.#shareTarget,
+			waitMultiplier: this.#multiplier,
+			maxBatchIntervalMs: this.#maxIntervalMs
+		};
+		if (this.#multiplier > 0) {
+			this.#notPacingSince = void 0;
+			if (this.#pacingLoggedAt === void 0) {
+				lc.info?.("Sync worker is over its share target: its client groups wait between batches", state);
+				this.#pacingLoggedAt = now;
+			} else if (now - this.#pacingLoggedAt >= PACING_LOG_INTERVAL_MS) {
+				if (allAtMax && this.#share > this.#shareTarget) lc.warn?.("Sync worker is over its share target although every client group waits the longest it may", state);
+				else lc.info?.("Sync worker is pacing its client groups", state);
+				this.#pacingLoggedAt = now;
+			}
+		} else if (this.#pacingLoggedAt !== void 0) {
+			this.#notPacingSince ??= now;
+			if (now - this.#notPacingSince >= PACING_LOG_INTERVAL_MS) {
+				lc.info?.("Sync worker is under its share target: its client groups no longer wait", state);
+				this.#pacingLoggedAt = void 0;
+				this.#notPacingSince = void 0;
+			}
+		}
+	}
+	/**
+	* Yields the worker to the other work that is waiting for a time slice,
+	* and resolves when it is the caller's turn again. One piece of work runs
+	* per turn of the event loop, as when the work of a worker's client groups
+	* simply takes turns, except that the hydration of new queries goes first:
+	* while both kinds of work are waiting, `HYDRATION_PRIORITY` slices go to
+	* hydrations for each one that goes to a batch.
+	*
+	* Batches are never made to wait for anything but a slice. If no
+	* hydration is waiting for one (because none is running, or because those
+	* that are running are waiting for I/O), batches get every slice. And
+	* however many hydrations there are, batches keep a share of the slices,
+	* so they keep moving, and so do the snapshots of the replica that they
+	* hold.
+	*/
+	yieldSlice(kind) {
+		return new Promise((resolve) => {
+			this.#waiting[kind].push(resolve);
+			if (!this.#handingOutSlices) {
+				this.#handingOutSlices = true;
+				setImmediate(this.#nextSlice);
+			}
+		});
+	}
+	#nextSlice = () => {
+		const { hydration, batch } = this.#waiting;
+		let next;
+		if (hydration.length > 0 && (batch.length === 0 || this.#hydrationSlices < HYDRATION_PRIORITY)) {
+			next = hydration.shift();
+			this.#hydrationSlices++;
+		} else if (batch.length > 0) {
+			next = batch.shift();
+			this.#hydrationSlices = 0;
+		}
+		if (next === void 0) {
+			this.#handingOutSlices = false;
+			return;
+		}
+		next();
+		setImmediate(this.#nextSlice);
+	};
+};
+/**
+* How many time slices go to the hydration of new queries for each one that
+* goes to a batch, while both are waiting for one.
+*/
+var HYDRATION_PRIORITY = 9;
+//#endregion
+export { BatchPacer };
+
+//# sourceMappingURL=batch-pacer.js.map

package/out/zero-cache/src/services/view-syncer/batch-pacer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-pacer.js","names":["#shareTarget","#maxIntervalMs","#now","#utilization","#lc","#waiting","#intervalStart","#update","#multiplier","#waitsBelowMax","#waitsAtMax","#share","#saturatedSeconds","#logPacing","#notPacingSince","#pacingLoggedAt","#handingOutSlices","#nextSlice","#hydrationSlices"],"sources":["../../../../../../zero-cache/src/services/view-syncer/batch-pacer.ts"],"sourcesContent":["import {performance} from 'node:perf_hooks';\nimport type {LogContext} from '@rocicorp/logger';\n\n/** How often the multiplier is updated. */\nconst UPDATE_INTERVAL_MS = 1000;\n\n/**\n * The weight of the latest second in the worker's smoothed busy share.\n * Client groups that wait for seconds between batches make the share of\n * any one second jump between idle and saturated, and a worker that keeps\n * up has the odd busy second. Neither says what the load is.\n */\nconst SHARE_SMOOTHING = 0.3;\n\n/**\n * How much of the difference between the smoothed busy share and the target\n * each update corrects for. The smoothed share only shows part of what the\n * previous updates did, so correcting for all of the difference each time\n * would overshoot and oscillate.\n */\nconst CORRECTION_EXPONENT = 0.3;\n\n/**\n * The share of its time above which a worker has no time to spare. A share\n * target has to stay well clear of this to be held, which is why\n * `syncUpdateShareTarget` is at most 0.9 (or 1, which no worker is over).\n */\nconst SATURATED_SHARE = 0.95;\n\n/** The seconds that a worker has to be saturated for to be treated as such. */\nconst SATURATED_SECONDS = 2;\n\n/**\n * How much `1 + k` is scaled by each second that the worker is saturated.\n * A saturated worker does not show how much more its client groups would\n * use, which can be many times what it has, so the multiplier is raised by\n * more than the difference from the target calls for until it does.\n */\nconst SATURATED_CORRECTION = 1.3;\n\n/**\n * How often a worker that is pacing its client groups says so in its log,\n * and how long it has to have stopped for to say that it has.\n */\nconst PACING_LOG_INTERVAL_MS = 60_000;\n\n/**\n * The most updates that are made up for when nothing has asked the pacer\n * for a wait in a while, which is enough for the multiplier to get to 0.\n */\nconst MAX_CATCH_UP_UPDATES = 60;\n\n/**\n * Bounds the multiplier, which otherwise has no limit while a worker stays\n * over the target however long its client groups wait.\n */\nconst MAX_MULTIPLIER = 1_000_000;\n\nexport type BatchPacerOptions = {\n  /**\n   * The largest share of the worker's time that it may be busy before its\n   * client groups are paced.\n   */\n  readonly shareTarget: number;\n  /** The longest a client group waits between batches. */\n  readonly maxIntervalMs: number;\n  readonly now?: (() => number) | undefined;\n  /**\n   * The share of the time since the previous call that the worker was busy.\n   * By default, the utilization of the event loop.\n   */\n  readonly utilization?: (() => number) | undefined;\n  /** Where the worker says that it is pacing its client groups. */\n  readonly lc?: LogContext | undefined;\n};\n\nfunction eventLoopUtilization(): () => number {\n  let last = performance.eventLoopUtilization();\n  return () => {\n    const current = performance.eventLoopUtilization();\n    const {utilization} = performance.eventLoopUtilization(current, last);\n    last = current;\n    return utilization;\n  };\n}\n\n/**\n * Paces the batches (advancements, including the queries they hydrate\n * again) of the client groups of a sync worker, so that the worker is left\n * with time for new hydrations and connections, and gives the hydrations of\n * new queries priority over the batches.\n *\n * **Pacing.** After each batch, a client group waits {@link waitMs} before\n * it starts the next. The wait is a multiple of the batch's processing\n * time, so a client group that always has changes waiting is busy at most\n * `1 / (1 + k)` of the time, where `k` is the {@link multiplier}. Because\n * the wait is in proportion to a client group's own processing time, those\n * that cause the load are slowed the most, and cheap ones barely at all.\n *\n * The multiplier is shared by the client groups of the worker. Once per\n * second, it is scaled by how far the share of its time that the worker was\n * busy, smoothed over a few seconds, is from the target, and by more while\n * the worker has no time to spare. It never goes below 0, where no client\n * group waits. The share is the utilization of the worker's event loop, i.e. all\n * of what the worker does: what a batch costs is spread over the pipelines,\n * the CVR, the pokes and garbage collection, and is not measurable batch by\n * batch.\n *\n * **Priority of new hydrations.** The worker's time slices are handed out\n * by the pacer (see {@link yieldSlice}), and while the hydration of new\n * queries is waiting for one, most of them go to it rather than to batches.\n */\nexport class BatchPacer {\n  readonly #shareTarget: number;\n  readonly #maxIntervalMs: number;\n  readonly #now: () => number;\n  readonly #utilization: () => number;\n  readonly #lc: LogContext | undefined;\n\n  /** When the worker last logged that it is pacing, while it still is. */\n  #pacingLoggedAt: number | undefined;\n  /** Since when the worker has not been pacing, after it logged that it was. */\n  #notPacingSince: number | undefined;\n\n  #intervalStart: number;\n  #multiplier = 0;\n  /** The smoothed share of its time that the worker was busy. */\n  #share = 0;\n  #saturatedSeconds = 0;\n  /** The waits handed out since the last update, by whether at the cap. */\n  #waitsBelowMax = 0;\n  #waitsAtMax = 0;\n\n  /** The work that is waiting for a time slice, in the order it yielded. */\n  readonly #waiting = {\n    hydration: [] as (() => void)[],\n    batch: [] as (() => void)[],\n  };\n  #handingOutSlices = false;\n  /** The slices that have gone to hydrations since one went to a batch. */\n  #hydrationSlices = 0;\n\n  constructor({\n    shareTarget,\n    maxIntervalMs,\n    now,\n    utilization,\n    lc,\n  }: BatchPacerOptions) {\n    this.#shareTarget = shareTarget;\n    this.#maxIntervalMs = maxIntervalMs;\n    this.#now = now ?? (() => performance.now());\n    this.#utilization = utilization ?? eventLoopUtilization();\n    this.#lc = lc;\n    this.#intervalStart = this.#now();\n  }\n\n  /**\n   * How long a client group should wait before its next batch, after one\n   * that took `processingMs` to process. The multiplier changes while a\n   * client group waits, so a long wait should be taken in steps, asking\n   * again after each.\n   */\n  waitMs(processingMs: number): number {\n    this.#update();\n    const wait = this.#multiplier * processingMs;\n    if (wait < this.#maxIntervalMs) {\n      this.#waitsBelowMax++;\n      return wait;\n    }\n    this.#waitsAtMax++;\n    return this.#maxIntervalMs;\n  }\n\n  /** `k`: a client group waits `k` times the processing time of a batch. */\n  get multiplier(): number {\n    this.#update();\n    return this.#multiplier;\n  }\n\n  /**\n   * The share of its time that the worker was busy, smoothed over the last\n   * few seconds, as of the last update of the multiplier.\n   */\n  get share(): number {\n    this.#update();\n    return this.#share;\n  }\n\n  /** Updates the multiplier for each interval that has ended. */\n  #update(): void {\n    const now = this.#now();\n    const ended = Math.floor((now - this.#intervalStart) / UPDATE_INTERVAL_MS);\n    if (ended <= 0) {\n      return;\n    }\n    this.#intervalStart += ended * UPDATE_INTERVAL_MS;\n    // If more than one interval has ended, nothing asked the pacer for a\n    // wait in the meantime, and the utilization since then is that of each.\n    const latest = this.#utilization();\n    // Once every client group is told to wait the longest it can, raising\n    // the multiplier changes nothing, and only makes it take longer to come\n    // back down. A worker that is still over its target then is busy with\n    // something that making its client groups wait does not relieve.\n    const allAtMax = this.#waitsAtMax > 0 && this.#waitsBelowMax === 0;\n    this.#waitsAtMax = 0;\n    this.#waitsBelowMax = 0;\n    for (let i = Math.min(ended, MAX_CATCH_UP_UPDATES); i > 0; i--) {\n      this.#share += SHARE_SMOOTHING * (latest - this.#share);\n      // A worker that is allowed to be this busy is only raised the\n      // multiplier for what it is over its target by.\n      this.#saturatedSeconds =\n        latest >= SATURATED_SHARE && latest > this.#shareTarget\n          ? this.#saturatedSeconds + 1\n          : 0;\n      let correction =\n        this.#saturatedSeconds >= SATURATED_SECONDS\n          ? SATURATED_CORRECTION\n          : (this.#share / this.#shareTarget) ** CORRECTION_EXPONENT;\n      if (allAtMax && correction > 1) {\n        correction = 1;\n      }\n      this.#multiplier = Math.min(\n        Math.max((1 + this.#multiplier) * correction - 1, 0),\n        MAX_MULTIPLIER,\n      );\n    }\n    this.#logPacing(now, allAtMax);\n  }\n\n  /**\n   * Says in the worker's log when it starts to pace its client groups, once\n   * a minute while it does, and when it has stopped. The pacing of a client\n   * group is logged by its view syncer.\n   */\n  #logPacing(now: number, allAtMax: boolean): void {\n    const lc = this.#lc;\n    if (lc === undefined) {\n      return;\n    }\n    const state = {\n      busyShare: this.#share,\n      shareTarget: this.#shareTarget,\n      waitMultiplier: this.#multiplier,\n      maxBatchIntervalMs: this.#maxIntervalMs,\n    };\n    if (this.#multiplier > 0) {\n      this.#notPacingSince = undefined;\n      if (this.#pacingLoggedAt === undefined) {\n        lc.info?.(\n          'Sync worker is over its share target: its client groups wait between batches',\n          state,\n        );\n        this.#pacingLoggedAt = now;\n      } else if (now - this.#pacingLoggedAt >= PACING_LOG_INTERVAL_MS) {\n        if (allAtMax && this.#share > this.#shareTarget) {\n          // Waiting longer is not an option, so pacing cannot bring the\n          // worker to its target: it has more to do than it has time for.\n          lc.warn?.(\n            'Sync worker is over its share target although every client group waits the longest it may',\n            state,\n          );\n        } else {\n          lc.info?.('Sync worker is pacing its client groups', state);\n        }\n        this.#pacingLoggedAt = now;\n      }\n    } else if (this.#pacingLoggedAt !== undefined) {\n      // A worker around its target goes in and out of pacing. It only says\n      // that it has stopped once it has stayed out.\n      this.#notPacingSince ??= now;\n      if (now - this.#notPacingSince >= PACING_LOG_INTERVAL_MS) {\n        lc.info?.(\n          'Sync worker is under its share target: its client groups no longer wait',\n          state,\n        );\n        this.#pacingLoggedAt = undefined;\n        this.#notPacingSince = undefined;\n      }\n    }\n  }\n\n  /**\n   * Yields the worker to the other work that is waiting for a time slice,\n   * and resolves when it is the caller's turn again. One piece of work runs\n   * per turn of the event loop, as when the work of a worker's client groups\n   * simply takes turns, except that the hydration of new queries goes first:\n   * while both kinds of work are waiting, `HYDRATION_PRIORITY` slices go to\n   * hydrations for each one that goes to a batch.\n   *\n   * Batches are never made to wait for anything but a slice. If no\n   * hydration is waiting for one (because none is running, or because those\n   * that are running are waiting for I/O), batches get every slice. And\n   * however many hydrations there are, batches keep a share of the slices,\n   * so they keep moving, and so do the snapshots of the replica that they\n   * hold.\n   */\n  yieldSlice(kind: 'hydration' | 'batch'): Promise<void> {\n    return new Promise(resolve => {\n      this.#waiting[kind].push(resolve);\n      if (!this.#handingOutSlices) {\n        this.#handingOutSlices = true;\n        setImmediate(this.#nextSlice);\n      }\n    });\n  }\n\n  readonly #nextSlice = () => {\n    const {hydration, batch} = this.#waiting;\n    let next: (() => void) | undefined;\n    if (\n      hydration.length > 0 &&\n      (batch.length === 0 || this.#hydrationSlices < HYDRATION_PRIORITY)\n    ) {\n      next = hydration.shift();\n      this.#hydrationSlices++;\n    } else if (batch.length > 0) {\n      next = batch.shift();\n      this.#hydrationSlices = 0;\n    }\n    if (next === undefined) {\n      this.#handingOutSlices = false;\n      return;\n    }\n    next();\n    // After the work that was just resumed has run its slice.\n    setImmediate(this.#nextSlice);\n  };\n}\n\n/**\n * How many time slices go to the hydration of new queries for each one that\n * goes to a batch, while both are waiting for one.\n */\nconst HYDRATION_PRIORITY = 9;\n"],"mappings":"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"}

package/out/zero-cache/src/services/view-syncer/cvr.d.ts

@@ -204,6 +204,32 @@ export declare class CVRQueryDrivenUpdater extends CVRUpdater {
      * rows of the aborted queries have been {@link received}.
      */
     abortExecutedQueries(lc: LogContext, queryIDs: readonly string[]): Promise<PatchToVersion[]>;
+    /**
+     * Retracts what queries have contributed to this update, so that they can
+     * be executed again from scratch in the same update. This is for a query
+     * whose changes were being received incrementally (see
+     * `PipelineDriver.advance()`) until its pipeline was abandoned in favor of
+     * hydrating it again.
+     *
+     * Rows received so far in this update have the queries' references
+     * stripped, as in {@link abortExecutedQueries}, except that a row left
+     * with no references is only deleted by {@link deleteUnreferencedRows}, if
+     * it is still unreferenced by then. Until then the clients keep the row
+     * and the patches they received for it in this update, so a row that is
+     * received again unchanged needs no patch at all. The queries are then
+     * tracked as executed, without changing them in the CVR: the references
+     * they held before this update are replaced, rather than adjusted, by the
+     * rows subsequently {@link received} for them, and
+     * {@link deleteUnreferencedRows} drops the references of rows that are not
+     * received again.
+     *
+     * Unlike {@link trackQueries}, this can be called on an updater that has
+     * not tracked any queries, and after rows have been received. All rows
+     * that the queries' pipelines have output must have been {@link received}
+     * first, and {@link deleteUnreferencedRows} must be called once the
+     * queries' rows have been received again.
+     */
+    retractQueries(lc: LogContext, queryIDs: readonly string[]): Promise<PatchToVersion[]>;
     updatedVersion(): CVRVersion;
     /**
      * Public alias for {@link _ensureNewVersion}. Forces a `configVersion` bump
@@ -221,7 +247,7 @@ export declare class CVRQueryDrivenUpdater extends CVRUpdater {
      * returns (put) patches to be returned to update their state, versioned by
      * patchVersion so that only the patches new to the clients are sent.
      */
-    received(_lc: LogContext, rows: Map<RowID, RowUpdate>): Promise<PatchToVersion[]>;
+    received(lc: LogContext, rows: Map<RowID, RowUpdate>): Promise<PatchToVersion[]>;
     /**
      * Computes and updates the row records based on:
      * * The {@link #executed} queries

package/out/zero-cache/src/services/view-syncer/cvr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cvr.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/cvr.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cvr.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/cvr.ts"],"names":[],"mappings":"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"}

package/out/zero-cache/src/services/view-syncer/cvr.js

@@ -365,6 +365,13 @@ var CVRQueryDrivenUpdater = class extends CVRUpdater {
 	#executedQueryIDs = /* @__PURE__ */ new Set();
 	#receivedRows = new CustomKeyMap(rowIDString);
 	#lastPatches = new CustomKeyMap(rowIDString);
+	/**
+	* Rows that {@link retractQueries} left without references, and the patch
+	* version of their deletion. The 'del' patches are held back until
+	* {@link deleteUnreferencedRows}, because the retracted queries are
+	* executed again and usually reference most of these rows again.
+	*/
+	#retractedRows = new CustomKeyMap(rowIDString);
 	#rowSetSignature;
 	#existingRows = void 0;
 	/**
@@ -398,7 +405,7 @@ var CVRQueryDrivenUpdater = class extends CVRUpdater {
 			assert(this.#existingRows === void 0, `trackQueries already called`);
 			const queryPatches = [executed.map((q) => this.#trackExecuted(q.id, q.transformationHash)), removed.map((q) => this.#trackRemoved(q.id))].flat(2);
 			this.#existingRows = this.#lookupRowsForExecutedAndRemovedQueries(lc);
-			this.#existingRows.then(() => {});
+			this.#existingRows.catch(() => {});
 			const versionBumped = cmpVersions(this._orig.version, this._cvr.version) < 0;
 			lc.info?.(`trackQueries: ${executed.length} executed, ${removed.length} removed, version ${versionBumped ? "bumped" : "unchanged"}`);
 			return {
@@ -518,12 +525,37 @@ var CVRQueryDrivenUpdater = class extends CVRUpdater {
 			assert(this.#executedQueryIDs.has(queryID), `Query ${queryID} was not tracked as executed`);
 			assertNotInternal(must(this._cvr.queries[queryID]));
 		}
+		const patches = await this.#unrefReceivedRows(lc, aborted);
+		for (const queryID of aborted) {
+			delete this._mutableQueries()[queryID];
+			const patch = {
+				type: "query",
+				op: "del",
+				id: queryID
+			};
+			this._cvrStore.markQueryAsDeleted(this._cvr.version, patch);
+			patches.push({
+				patch,
+				toVersion: this._cvr.version
+			});
+		}
+		return patches;
+	}
+	/**
+	* Strips the references of `queryIDs` from every row received so far in
+	* this update. A row left with no references is deleted, and the 'del'
+	* patch cancels the 'put' the client has already received in this poke. The
+	* version of each unref is the version the row currently has in this
+	* update, so a row that stays referenced does not get a spurious patch
+	* version bump.
+	*/
+	async #unrefReceivedRows(lc, queryIDs, holdDeletes = false) {
 		const existingRows = await this._cvrStore.getRowRecords();
 		const unrefs = new CustomKeyMap(rowIDString);
 		for (const [id, refCounts] of this.#receivedRows) {
 			if (refCounts === null) continue;
 			let unref;
-			for (const queryID of aborted) {
+			for (const queryID of queryIDs) {
 				const count = refCounts[queryID];
 				if (!count) continue;
 				if (!unref) {
@@ -537,19 +569,50 @@ var CVRQueryDrivenUpdater = class extends CVRUpdater {
 				unref.refCounts[queryID] = -count;
 			}
 		}
-		const patches = unrefs.size > 0 ? await this.received(lc, unrefs) : [];
-		for (const queryID of aborted) {
-			delete this._mutableQueries()[queryID];
-			const patch = {
-				type: "query",
-				op: "del",
-				id: queryID
-			};
-			this._cvrStore.markQueryAsDeleted(this._cvr.version, patch);
-			patches.push({
-				patch,
-				toVersion: this._cvr.version
-			});
+		return unrefs.size > 0 ? this.#receive(lc, unrefs, holdDeletes) : [];
+	}
+	/**
+	* Retracts what queries have contributed to this update, so that they can
+	* be executed again from scratch in the same update. This is for a query
+	* whose changes were being received incrementally (see
+	* `PipelineDriver.advance()`) until its pipeline was abandoned in favor of
+	* hydrating it again.
+	*
+	* Rows received so far in this update have the queries' references
+	* stripped, as in {@link abortExecutedQueries}, except that a row left
+	* with no references is only deleted by {@link deleteUnreferencedRows}, if
+	* it is still unreferenced by then. Until then the clients keep the row
+	* and the patches they received for it in this update, so a row that is
+	* received again unchanged needs no patch at all. The queries are then
+	* tracked as executed, without changing them in the CVR: the references
+	* they held before this update are replaced, rather than adjusted, by the
+	* rows subsequently {@link received} for them, and
+	* {@link deleteUnreferencedRows} drops the references of rows that are not
+	* received again.
+	*
+	* Unlike {@link trackQueries}, this can be called on an updater that has
+	* not tracked any queries, and after rows have been received. All rows
+	* that the queries' pipelines have output must have been {@link received}
+	* first, and {@link deleteUnreferencedRows} must be called once the
+	* queries' rows have been received again.
+	*/
+	async retractQueries(lc, queryIDs) {
+		assert(cmpVersions(this._orig.version, this._cvr.version) < 0, "A final CVR version must be set before retracting queries");
+		const retracted = new Set(queryIDs);
+		for (const queryID of retracted) {
+			assert(this._cvr.queries[queryID] !== void 0, () => `Query ${queryID} is not in the CVR`);
+			assert(this.#executedQueryIDs.has(queryID) || !this.#removedOrExecutedQueryIDs.has(queryID), () => `Query ${queryID} was tracked as removed`);
+		}
+		const patches = await this.#unrefReceivedRows(lc, retracted, true);
+		let tracked = false;
+		for (const queryID of retracted) if (!this.#executedQueryIDs.has(queryID)) {
+			this.#removedOrExecutedQueryIDs.add(queryID);
+			this.#executedQueryIDs.add(queryID);
+			tracked = true;
+		}
+		if (tracked) {
+			this.#existingRows = this.#lookupRowsForExecutedAndRemovedQueries(lc);
+			this.#existingRows.then(() => {});
 		}
 		return patches;
 	}
@@ -622,7 +685,14 @@ var CVRQueryDrivenUpdater = class extends CVRUpdater {
 	* returns (put) patches to be returned to update their state, versioned by
 	* patchVersion so that only the patches new to the clients are sent.
 	*/
-	received(_lc, rows) {
+	received(lc, rows) {
+		return this.#receive(lc, rows, false);
+	}
+	/**
+	* @param holdDeletes Whether to hold back the 'del' patches of rows that
+	*        are left without references until {@link deleteUnreferencedRows}.
+	*/
+	#receive(_lc, rows, holdDeletes) {
 		return startAsyncSpan(tracer, "CVRQueryDrivenUpdater.received", async () => {
 			const patches = [];
 			const existingRows = await this._cvrStore.getRowRecords();
@@ -632,6 +702,7 @@ var CVRQueryDrivenUpdater = class extends CVRUpdater {
 				const previouslyReceived = this.#receivedRows.get(id);
 				const merged = previouslyReceived !== void 0 ? mergeRefCounts(previouslyReceived, refCounts) : mergeRefCounts(existing?.refCounts, refCounts, this.#removedOrExecutedQueryIDs);
 				this.#receivedRows.set(id, merged);
+				if (merged !== null) this.#retractedRows.delete(id);
 				const newRowVersion = merged === null ? void 0 : version;
 				const patchVersion = existing && existing.rowVersion === newRowVersion ? existing.patchVersion : this.#assertNewVersion(id, existing?.rowVersion, newRowVersion, refCounts);
 				const rowVersion = version ?? existing?.rowVersion;
@@ -646,7 +717,8 @@ var CVRQueryDrivenUpdater = class extends CVRUpdater {
 				const toVersion = maxVersion(patchVersion, lastPatch?.toVersion);
 				if (merged === null) {
 					if (existing || previouslyReceived) {
-						if (lastPatch?.rowVersion !== null) {
+						if (holdDeletes) this.#retractedRows.set(id, toVersion);
+						else if (lastPatch?.rowVersion !== null) {
 							patches.push({
 								patch: {
 									type: "row",
@@ -704,6 +776,24 @@ var CVRQueryDrivenUpdater = class extends CVRUpdater {
 			const patches = [];
 			const start = Date.now();
 			assert(this.#existingRows, `trackQueries() was not called`);
+			for (const [id, deletedVersion] of this.#retractedRows) {
+				const lastPatch = this.#lastPatches.get(id);
+				if (lastPatch?.rowVersion === null) continue;
+				const toVersion = maxVersion(deletedVersion, lastPatch?.toVersion);
+				patches.push({
+					toVersion,
+					patch: {
+						type: "row",
+						op: "del",
+						id
+					}
+				});
+				this.#lastPatches.set(id, {
+					rowVersion: null,
+					toVersion
+				});
+			}
+			this.#retractedRows.clear();
 			for (const existing of await this.#existingRows) {
 				const deletedID = this.#deleteUnreferencedRow(existing);
 				if (deletedID === null) continue;