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

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

@@ -22,6 +22,8 @@ import "../../types/row-key.js";
 import { getSubscriptionState } from "../replicator/schema/replication-state.js";
 import { checkClientSchema } from "./client-schema.js";
 import { planWarningMessage } from "./plan-warnings.js";
+import { PushCutoff } from "./push-cutoff.js";
+import { PushCostEstimator, ReadCostEstimator, shouldRebuildInsteadOfReading, shouldStartOnRebuild } from "./push-cost.js";
 import { queryShape } from "./query-shape.js";
 import { rowIDSignatureUnit } from "./row-set-signature.js";
 import { ResetPipelinesSignal } from "./snapshotter.js";
@@ -114,6 +116,22 @@ var PipelineDriver = class {
 	#pushedRowChanges = null;
 	#hydrateContext = null;
 	#advanceContext = null;
+	/**
+	* Whether a {@link CostBasedAdvance} has been set up and has not
+	* completed. It may already have removed pipelines, but the sources only
+	* move to the new snapshot when the iteration over its changes completes,
+	* so nothing can be hydrated until then. If the iteration is given up on
+	* or throws, they never do, and nothing can be hydrated until the
+	* pipelines are {@link reset()}.
+	*/
+	#costBasedAdvanceIncomplete = false;
+	/**
+	* The queries abandoned by a {@link CostBasedAdvance} that have not been
+	* added again since.
+	*/
+	#abandoned = /* @__PURE__ */ new Map();
+	#pushCosts = new PushCostEstimator();
+	#readCosts = new ReadCostEstimator();
 	#replicaVersion = null;
 	#primaryKeys = null;
 	#permissions = null;
@@ -175,6 +193,8 @@ var PipelineDriver = class {
 			this.#pipelines.delete(queryID);
 			this.#destroyPipeline(queryID, pipeline, "reset");
 		}
+		this.#abandoned.clear();
+		this.#costBasedAdvanceIncomplete = false;
 		this.#tables.clear();
 		this.#allTableNames.clear();
 		this.#rowSetSignatures.clear();
@@ -230,11 +250,16 @@ var PipelineDriver = class {
 	* {@link reset()} before hydrating. ({@link advance()} detects this when
 	* the diff encounters the RESET op; this path skips the diff and so must
 	* check explicitly.)
+	*
+	* @param releasePreviousSnapshot Whether to release the snapshot that the
+	*        driver was at, which is otherwise left open until the next
+	*        advance (see `Snapshotter.releasePrevious()`).
 	*/
-	advanceWithoutDiff() {
+	advanceWithoutDiff(releasePreviousSnapshot = false) {
 		const { prev, curr } = this.#snapshotter.advanceWithoutDiff();
 		if (curr.schemaChangedSince(prev.version)) throw new ResetPipelinesSignal(`schema changed between ${prev.version} and ${curr.version}`, "schema-change");
 		for (const table of this.#tables.values()) table.setDB(curr.db.db);
+		if (releasePreviousSnapshot) this.#snapshotter.releasePrevious();
 		return curr.version;
 	}
 	#ensureCostModelExistsIfEnabled(db) {
@@ -266,6 +291,15 @@ var PipelineDriver = class {
 		return this.#pipelines;
 	}
 	/**
+	* The queries whose pipelines a {@link CostBasedAdvance} removed and that
+	* have not been hydrated again since, by query ID. They are not in
+	* {@link queries()}. A query whose hydration is started but does not
+	* finish is still one of them.
+	*/
+	abandonedQueries() {
+		return this.#abandoned;
+	}
+	/**
 	* Stats from the hydration of the pipeline for `queryID`, or `undefined` if
 	* the query has no pipeline.
 	*/
@@ -327,7 +361,7 @@ var PipelineDriver = class {
 		for (const source of this.#tables.values()) total += source.pendingBytes;
 		return total;
 	}
-	#logQueryPipelineLifecycle({ zeroEvent, pipelineRunID, queryHash, transformationHash, queryName, hydrationReason, stopReason, hydrationTimeMs, hydrationRowCount, hydrationRowsRead, pipelineLifetimeMs }) {
+	#logQueryPipelineLifecycle({ zeroEvent, pipelineRunID, queryHash, transformationHash, queryName, hydrationReason, stopReason, hydrationTimeMs, hydrationRowCount, hydrationRowsRead, pipelineLifetimeMs, abandonReason, estimatedPushMs, pushTimeMs, pushedChanges, level = "info" }) {
 		let lc = this.#lc.withContext("zeroEvent", zeroEvent).withContext("pipelineRunID", pipelineRunID).withContext("queryHash", queryHash).withContext("transformationHash", transformationHash);
 		if (queryName !== void 0) lc = lc.withContext("queryName", queryName);
 		if (hydrationReason !== void 0) lc = lc.withContext("hydrationReason", hydrationReason);
@@ -336,7 +370,11 @@ var PipelineDriver = class {
 		if (hydrationRowCount !== void 0) lc = lc.withContext("hydrationRowCount", hydrationRowCount);
 		if (hydrationRowsRead !== void 0) lc = lc.withContext("hydrationRowsRead", hydrationRowsRead);
 		if (pipelineLifetimeMs !== void 0) lc = lc.withContext("pipelineLifetimeMs", pipelineLifetimeMs);
-		lc.info?.("query pipeline lifecycle");
+		if (abandonReason !== void 0) lc = lc.withContext("abandonReason", abandonReason);
+		if (estimatedPushMs !== void 0) lc = lc.withContext("estimatedPushMs", estimatedPushMs);
+		if (pushTimeMs !== void 0) lc = lc.withContext("pushTimeMs", pushTimeMs);
+		if (pushedChanges !== void 0) lc = lc.withContext("pushedChanges", pushedChanges);
+		lc[level]?.("query pipeline lifecycle");
 	}
 	/**
 	* A `{scalar: true}` that cannot be honored degrades silently to a plain
@@ -354,13 +392,16 @@ var PipelineDriver = class {
 	#disableCorrelatedPredicatePushdown() {
 		return this.#config?.enableCorrelatedPredicatePushdown === false;
 	}
-	#resolveScalarSubqueries(ast) {
+	#resolveScalarSubqueries(ast, tables) {
 		const companionInputs = [];
 		const executor = (subqueryAST, childField) => {
 			const input = buildPipeline(subqueryAST, {
 				enableNotExists: true,
 				disableCorrelatedPredicatePushdown: this.#disableCorrelatedPredicatePushdown(),
-				getSource: (name) => this.#getSource(name),
+				getSource: (name) => {
+					tables.add(name);
+					return this.#getSource(name);
+				},
 				createStorage: () => this.#createStorage(),
 				decorateSourceInput: (input) => input,
 				decorateInput: (input) => input,
@@ -409,17 +450,20 @@ var PipelineDriver = class {
 		this.removeQuery(queryID, "replace-query");
 		const pipelineRunID = randomID();
 		const shape = queryShape(query);
+		const level = this.#abandoned.has(queryID) ? "debug" : "info";
 		this.#logQueryPipelineLifecycle({
 			zeroEvent: "query-pipeline-hydrate-start",
 			pipelineRunID,
 			queryHash: queryID,
 			transformationHash,
 			queryName,
-			hydrationReason
+			hydrationReason,
+			level
 		});
 		const debugDelegate = runtimeDebugFlags.trackRowsVended ? new Debug(true) : void 0;
 		const costModel = this.#ensureCostModelExistsIfEnabled(this.#snapshotter.current().db.db);
 		assert(this.#advanceContext === null, "Cannot hydrate while advance is in progress");
+		assert(!this.#costBasedAdvanceIncomplete, "Cannot hydrate before the advance has completed");
 		this.#hydrateContext = { timer };
 		const rowsReadAtStart = this.#totalRowsRead();
 		let hydrationFinished = false;
@@ -428,10 +472,11 @@ var PipelineDriver = class {
 		let planWarnings = [];
 		const planWarningThresholds = this.#planWarningThresholds;
 		let builtInputs = [];
+		const tables = /* @__PURE__ */ new Set();
 		try {
 			this.#rowSetSignatures.set(queryID, 0n);
 			this.#changedRowSetSignatures.add(queryID);
-			const { ast: resolvedQuery, companions: companionMeta, companionInputs, ignoredScalarHints } = this.#resolveScalarSubqueries(query);
+			const { ast: resolvedQuery, companions: companionMeta, companionInputs, ignoredScalarHints } = this.#resolveScalarSubqueries(query, tables);
 			builtInputs = [...companionInputs];
 			this.#warnIgnoredScalarHints(queryID, ignoredScalarHints);
 			const input = buildPipeline(resolvedQuery, {
@@ -439,7 +484,10 @@ var PipelineDriver = class {
 				enableNotExists: true,
 				disableCorrelatedPredicatePushdown: this.#disableCorrelatedPredicatePushdown(),
 				enablePlannerAwarePushdown: this.#config?.enablePlannerAwarePushdown !== false,
-				getSource: (name) => this.#getSource(name),
+				getSource: (name) => {
+					tables.add(name);
+					return this.#getSource(name);
+				},
 				createStorage: () => this.#createStorage(),
 				decorateSourceInput: (input, _queryID) => new MeasurePushOperator(new QueryFailureLoggingOperator(this.#lc, input, queryID, transformationHash, queryName), queryID, this.#metricsDelegate, "query-update-server"),
 				decorateInput: (input) => input,
@@ -524,8 +572,10 @@ var PipelineDriver = class {
 				shape,
 				transformationHash,
 				...queryName !== void 0 && { queryName },
-				companions: liveCompanions
+				companions: liveCompanions,
+				tables
 			});
+			this.#abandoned.delete(queryID);
 			hydrationFinished = true;
 			this.#queryStats?.recordHydration({
 				queryName,
@@ -546,7 +596,8 @@ var PipelineDriver = class {
 				hydrationReason,
 				hydrationTimeMs,
 				hydrationRowCount,
-				hydrationRowsRead
+				hydrationRowsRead,
+				level
 			});
 		} catch (e) {
 			hydrationFailed = true;
@@ -606,15 +657,24 @@ var PipelineDriver = class {
 	* was not added.
 	*/
 	removeQuery(queryID, stopReason = "remove-query") {
+		this.#removeQuery(queryID, stopReason);
+	}
+	/**
+	* @param abandoned If an advancement is abandoning the query's pipeline,
+	*        the record of that, which is logged.
+	*/
+	#removeQuery(queryID, stopReason, abandoned) {
 		const pipeline = this.#pipelines.get(queryID);
 		if (pipeline) {
 			this.#pipelines.delete(queryID);
-			this.#destroyPipeline(queryID, pipeline, stopReason);
+			this.#destroyPipeline(queryID, pipeline, stopReason, abandoned);
 		}
 		this.#rowSetSignatures.delete(queryID);
 		this.#changedRowSetSignatures.delete(queryID);
+		if (stopReason !== "replace-query") this.#abandoned.delete(queryID);
+		if (stopReason === "remove-query") this.#pushCosts.forget(queryID);
 	}
-	#destroyPipeline(queryID, pipeline, stopReason) {
+	#destroyPipeline(queryID, pipeline, stopReason, abandoned) {
 		this.#logQueryPipelineLifecycle({
 			zeroEvent: "query-pipeline-stop",
 			pipelineRunID: pipeline.pipelineRunID,
@@ -625,7 +685,14 @@ var PipelineDriver = class {
 			stopReason,
 			hydrationTimeMs: pipeline.hydrationTimeMs,
 			hydrationRowCount: pipeline.hydrationRowCount,
-			pipelineLifetimeMs: Date.now() - pipeline.pipelineReadyAtMs
+			pipelineLifetimeMs: Date.now() - pipeline.pipelineReadyAtMs,
+			...abandoned && {
+				abandonReason: abandoned.reason,
+				estimatedPushMs: abandoned.estimatedPushMs,
+				pushTimeMs: abandoned.pushTimeMs,
+				pushedChanges: abandoned.changes,
+				level: "debug"
+			}
 		});
 		pipeline.input.destroy();
 		for (const companion of pipeline.companions) companion.input.destroy();
@@ -689,20 +756,41 @@ var PipelineDriver = class {
 	*        measure the progress of the advancement and abort with a
 	*        {@link ResetPipelinesSignal} if it is estimated to take longer
 	*        than a hydration.
+	* @param costBased If given, the advancement is bounded query by query
+	*        instead (see {@link CostBasedAdvance}).
 	* @return The resulting row changes for all added queries. Note that the
 	*         `changes` must be iterated over in their entirety in order to
 	*         advance the database snapshot.
+	* @throws A {@link ResetPipelinesSignal} if `costBased` is given and the
+	*         changes include a schema change, a truncation or a change of
+	*         the permissions. It is thrown before any change is pushed or
+	*         any pipeline is removed, as the caller resets the pipelines
+	*         either way. Without `costBased`, it is iterating over the
+	*         `changes` that throws it, on getting to that change.
 	*/
-	advance(timer) {
+	advance(timer, costBased) {
 		assert(this.initialized(), "Pipeline driver must be initialized before advancing");
-		const diff = this.#snapshotter.advance(this.#tableSpecs, this.#allTableNames, this.#tables, "divergent");
+		let diff;
+		let context;
+		if (costBased === void 0) diff = this.#snapshotter.advance(this.#tableSpecs, this.#allTableNames, this.#tables, "divergent");
+		else {
+			const { prev, curr } = this.#snapshotter.advanceWithoutDiff();
+			const counts = curr.countChangesSince(prev.version);
+			const reset = this.#snapshotter.pendingReset(this.#tableSpecs, counts);
+			if (reset) throw reset;
+			context = this.#startCostBasedAdvance(costBased, curr.version > prev.version, counts);
+			diff = this.#snapshotter.diff(this.#tableSpecs, this.#allTableNames, this.#tables, "divergent", counts, context.abandoned.length > 0 ? this.#tablesRead() : void 0);
+			this.#costBasedAdvanceIncomplete = true;
+		}
 		const { prev, curr, changes } = diff;
 		this.#lc.debug?.(`advance ${prev.version} => ${curr.version}: ${changes} changes`);
 		const progress = { changesProcessed: 0 };
 		return {
 			version: curr.version,
 			numChanges: changes,
-			changes: this.#trackRowSetSignatures(this.#advance(diff, timer, changes, progress)),
+			changes: this.#trackRowSetSignatures(this.#advance(diff, timer, changes, progress, context)),
+			abandoned: () => context?.abandoned ?? [],
+			estimates: () => context?.estimates ?? [],
 			progress: () => ({
 				changesScanned: diff.changesScanned,
 				changesProcessed: progress.changesProcessed,
@@ -710,7 +798,109 @@ var PipelineDriver = class {
 			})
 		};
 	}
-	*#advance(diff, timer, numChanges, progress) {
+	/** The tables that the pipelines read. */
+	#tablesRead() {
+		const tables = /* @__PURE__ */ new Set();
+		for (const pipeline of this.#pipelines.values()) for (const table of pipeline.tables) tables.add(table);
+		return tables;
+	}
+	/**
+	* Removes the pipelines of the queries that are estimated to be cheaper to
+	* hydrate again than to push the advancement's changes to: first each
+	* query for what pushing costs it, and then the ones that are left for
+	* what reading the changes costs them together.
+	*
+	* @param canAbandon Whether pipelines can be removed, by this or by the
+	*        cutoff.
+	* @param counts The rows that changed since the previous snapshot.
+	*/
+	#startCostBasedAdvance({ shouldCutOff, rebuildMargin }, canAbandon, counts) {
+		const changes = counts.byTable;
+		const estimatedPushMs = /* @__PURE__ */ new Map();
+		const abandoned = [];
+		if (canAbandon) {
+			for (const [queryID, pipeline] of this.#pipelines) {
+				const estimate = this.#pushCosts.estimate(queryID, pipeline.tables, changes);
+				if (estimate === void 0) continue;
+				if (shouldStartOnRebuild(estimate, pipeline.hydrationTimeMs, rebuildMargin)) this.#abandon(abandoned, "estimate", pipeline, {
+					queryID,
+					pushTimeMs: 0,
+					changes: 0,
+					hydrationTimeMs: pipeline.hydrationTimeMs,
+					estimatedPushMs: estimate
+				});
+				else estimatedPushMs.set(queryID, estimate);
+			}
+			this.#abandonInsteadOfReading(counts, rebuildMargin, estimatedPushMs, abandoned);
+		}
+		return {
+			cutoff: new PushCutoff(canAbandon ? shouldCutOff : () => false),
+			entries: counts.total,
+			estimatedPushMs,
+			abandoned,
+			estimates: []
+		};
+	}
+	/**
+	* Removes the pipelines that are left, if reading the advancement's
+	* changes and pushing them to those is estimated to cost more than
+	* hydrating them again. The changes are then not read at all.
+	*/
+	#abandonInsteadOfReading(counts, rebuildMargin, estimatedPushMs, abandoned) {
+		if (this.#pipelines.size === 0) return;
+		let entriesOfTablesRead = 0;
+		for (const table of this.#tablesRead()) entriesOfTablesRead += counts.byTable.get(table) ?? 0;
+		const queries = Array.from(this.#pipelines, ([queryID, pipeline]) => ({
+			queryID,
+			pipeline,
+			estimatedPushMs: estimatedPushMs.get(queryID),
+			hydrationTimeMs: pipeline.hydrationTimeMs
+		}));
+		const estimatedReadMs = this.#readCosts.estimate({
+			walk: counts.total,
+			parse: abandoned.length > 0 ? entriesOfTablesRead : counts.total,
+			lookup: entriesOfTablesRead
+		});
+		if (!shouldRebuildInsteadOfReading(estimatedReadMs, queries, rebuildMargin)) return;
+		let pushMs = 0;
+		let hydrationMs = 0;
+		for (const query of queries) {
+			pushMs += query.estimatedPushMs ?? 0;
+			hydrationMs += query.hydrationTimeMs;
+		}
+		this.#lc.debug?.("Not reading a batch of changes: hydrating its queries again is estimated to cost less", {
+			entries: counts.total,
+			entriesOfTablesRead,
+			estimatedReadMs,
+			estimatedPushMs: pushMs,
+			hydrationTimeMs: hydrationMs,
+			rebuildMargin,
+			queries: queries.length
+		});
+		for (const { queryID, pipeline, ...estimate } of queries) this.#abandon(abandoned, "read", pipeline, {
+			queryID,
+			pushTimeMs: 0,
+			changes: 0,
+			...estimate
+		});
+		estimatedPushMs.clear();
+	}
+	#abandon(abandoned, reason, pipeline, progress) {
+		const { transformationHash, transformedAst, originalAst, queryName } = pipeline;
+		const query = {
+			...progress,
+			reason,
+			transformationHash,
+			transformedAst,
+			originalAst,
+			...queryName !== void 0 && { queryName }
+		};
+		this.#removeQuery(progress.queryID, "abandon-advance", query);
+		this.#abandoned.set(progress.queryID, query);
+		abandoned.push(query);
+		this.#queryStats?.recordAbandoned(pipeline, reason);
+	}
+	*#advance(diff, timer, numChanges, progress, costBased) {
 		assert(this.#hydrateContext === null, "Cannot advance while hydration is in progress");
 		const totalHydrationTimeMs = this.totalHydrationTimeMs();
 		const advanceContext = {
@@ -726,11 +916,13 @@ var PipelineDriver = class {
 			pos: 0,
 			currentTable: void 0,
 			queryStats: /* @__PURE__ */ new Map(),
+			costBased,
 			pushTimeMs: 0,
 			stage: "diff"
 		};
 		this.#advanceContext = advanceContext;
 		let timedOut = false;
+		let readToEnd = true;
 		try {
 			advanceContext.reservedRows = this.#reserveDeferredWrites(numChanges);
 			const deferWrites = advanceContext.reservedRows !== void 0;
@@ -740,7 +932,14 @@ var PipelineDriver = class {
 			for (const { table, prevValues: probedPrevValues, nextValue, rowKey } of diff) {
 				advanceContext.stage = "between";
 				advanceContext.completedChanges = diff.changesScanned - 1;
-				if (this.#shouldAdvanceYieldMaybeAbortAdvance()) yield "yield";
+				if (this.#checkAdvance(advanceContext)) yield "yield";
+				if (costBased) {
+					this.#cutOffQueries(advanceContext, costBased, diff, table);
+					if (this.#pipelines.size === 0) {
+						readToEnd = false;
+						break;
+					}
+				}
 				const start = timer.totalElapsed();
 				advanceContext.currentChangeStartMs = start;
 				advanceContext.currentTable = table;
@@ -779,7 +978,7 @@ var PipelineDriver = class {
 							advanceContext.completedChanges = diff.changesScanned;
 						}
 					}
-					this.#shouldAdvanceYieldMaybeAbortAdvance(false);
+					this.#checkAdvance(advanceContext, false);
 					if (holds === "fits") holds = this.#holdPendingRows(advanceContext);
 				} finally {
 					advanceContext.pushTimeMs += timer.totalElapsed() - start;
@@ -793,9 +992,26 @@ var PipelineDriver = class {
 			advanceContext.completedChanges = diff.changesScanned;
 			const { curr } = diff;
 			for (const table of this.#tables.values()) table.setDB(curr.db.db);
+			this.#costBasedAdvanceIncomplete = false;
 			this.#ensureCostModelExistsIfEnabled(curr.db.db);
 			this.#lc.debug?.(`Advanced to ${curr.version}`);
 			this.#logSlowAdvances(advanceContext);
+			if (costBased) {
+				this.#recordPushCosts(advanceContext, costBased, diff.changesScannedByTable);
+				if (readToEnd && diff.changes > 0 && diff.stats) {
+					const { changeLogReadMs, parseMs, rowReadMs } = diff.stats;
+					this.#readCosts.record({
+						walk: changeLogReadMs,
+						parse: parseMs,
+						lookup: rowReadMs
+					}, {
+						walk: costBased.entries,
+						parse: diff.changesScanned,
+						lookup: diff.changesLookedUp
+					});
+				}
+				this.#snapshotter.releasePrevious();
+			}
 		} catch (e) {
 			if (e instanceof ResetPipelinesSignal && e.reason === "advancement-timeout") {
 				timedOut = true;
@@ -809,6 +1025,70 @@ var PipelineDriver = class {
 			this.#recordAdvanceStats(advanceContext, timedOut);
 		}
 	}
+	/**
+	* Checks the progress of the advancement. Returns whether it should yield.
+	*
+	* An advancement is bounded in one of two ways, never both. A
+	* {@link CostBasedAdvance} cuts queries off one by one between changes
+	* (see {@link #cutOffQueries}) and always runs to completion.
+	* Without one, {@link #shouldAdvanceYieldMaybeAbortAdvance} aborts the
+	* advancement with a {@link ResetPipelinesSignal} if it takes too long.
+	*/
+	#checkAdvance(advanceContext, checkYield = true) {
+		if (advanceContext.costBased === void 0) return this.#shouldAdvanceYieldMaybeAbortAdvance(checkYield);
+		return checkYield && advanceContext.timer.elapsedLap() > this.#yieldThresholdMs();
+	}
+	/**
+	* Removes the pipelines of the queries that the cutoff says to.
+	*
+	* @param nextTable The table of the change that `diff` has just yielded,
+	*        which has not been pushed yet.
+	*/
+	#cutOffQueries({ queryStats }, costBased, diff, nextTable) {
+		const cutOff = costBased.cutoff.takeCutOff((queryID) => {
+			const pipeline = this.#pipelines.get(queryID);
+			const stats = queryStats.get(queryID);
+			return pipeline === void 0 || stats === void 0 ? void 0 : {
+				queryID,
+				pushTimeMs: stats.timeMs,
+				changes: stats.changes,
+				hydrationTimeMs: pipeline.hydrationTimeMs
+			};
+		});
+		if (cutOff.length === 0) return;
+		const entriesByTable = new Map(diff.changesScannedByTable);
+		entriesByTable.set(nextTable, (entriesByTable.get(nextTable) ?? 1) - 1);
+		for (const progress of cutOff) {
+			const { queryID } = progress;
+			const pipeline = must(this.#pipelines.get(queryID));
+			this.#pushCosts.record(queryID, pipeline.tables, queryStats.get(queryID)?.timeMsByTable, entriesByTable);
+			this.#queryStats?.recordAdvance(pipeline, {
+				timeMs: progress.pushTimeMs,
+				changes: progress.changes,
+				timedOut: false
+			});
+			this.#abandon(costBased.abandoned, "cutoff", pipeline, {
+				...progress,
+				estimatedPushMs: costBased.estimatedPushMs.get(queryID)
+			});
+		}
+	}
+	/**
+	* Learns from a completed advancement what its changes cost the queries
+	* that were pushed all of them.
+	*/
+	#recordPushCosts({ queryStats }, { estimatedPushMs, estimates }, entriesByTable) {
+		for (const [queryID, pipeline] of this.#pipelines) {
+			const stats = queryStats.get(queryID);
+			this.#pushCosts.record(queryID, pipeline.tables, stats?.timeMsByTable, entriesByTable);
+			const estimate = estimatedPushMs.get(queryID);
+			if (estimate !== void 0) estimates.push({
+				queryID,
+				estimatedPushMs: estimate,
+				pushTimeMs: stats?.timeMs ?? 0
+			});
+		}
+	}
 	/** Accounts the time each query took in an advancement to its shape. */
 	#recordAdvanceStats({ queryStats }, timedOut) {
 		if (this.#queryStats === void 0) return;
@@ -883,6 +1163,7 @@ var PipelineDriver = class {
 			timeMsByTable: /* @__PURE__ */ new Map()
 		}));
 		stats.timeMs += timeMs;
+		advance.costBased?.cutoff.recordPush(queryID);
 		if (stats.lastPos !== advance.pos) {
 			stats.lastPos = advance.pos;
 			stats.changes++;
@@ -1000,7 +1281,7 @@ var PipelineDriver = class {
 	}
 	#shouldYield() {
 		if (this.#hydrateContext) return this.#hydrateContext.timer.elapsedLap() > this.#yieldThresholdMs();
-		if (this.#advanceContext) return this.#shouldAdvanceYieldMaybeAbortAdvance();
+		if (this.#advanceContext) return this.#checkAdvance(this.#advanceContext);
 		throw new Error("shouldYield called outside of hydration or advancement");
 	}
 	/**