@milaboratories/pl-middle-layer 1.49.0 → 1.50.0

package/dist/mutator/project.cjs

@@ -121,6 +121,8 @@ const NoNewBlocks = (blockId) => {
 	throw new Error(`No new block info for ${blockId}`);
 };
 var ProjectMutator = class ProjectMutator {
+	/** Max number of blocks to render staging for in a single background refresh pass. */
+	static STAGING_REFRESH_MAX_BATCH = 10;
 	globalModCount = 0;
 	fieldsChanged = false;
 	lastModifiedChanged = false;
@@ -161,6 +163,12 @@ var ProjectMutator = class ProjectMutator {
 				this.setBlockFieldObj(blockInfo.id, "blockSettings", initialBlockSettings);
 			}
 		});
+		if ([...this.blockInfos.values()].some((info) => info.fields.prodChainCtx === void 0) && this.blockInfos.size > 0) {
+			this.rebuildProdChain(0);
+			this.blockInfos.forEach((blockInfo) => {
+				this.resetStaging(blockInfo.id);
+			});
+		}
 		this.blockInfos.forEach((info) => info.check());
 	}
 	get wasModified() {
@@ -438,7 +446,11 @@ var ProjectMutator = class ProjectMutator {
 				somethingChanged = true;
 			}
 		}
-		this.getStagingGraph().traverse("downstream", changedArgs, ({ id }) => this.resetStaging(id));
+		for (const blockId of changedArgs) try {
+			this.renderStagingFor(blockId);
+		} catch (e) {
+			this.projectHelper.logger.error(new Error(`[setStates] inline staging render failed for ${blockId}`, { cause: e }));
+		}
 		if (somethingChanged) this.updateLastModified();
 	}
 	setBlockSettings(blockId, newValue) {
@@ -454,15 +466,42 @@ var ProjectMutator = class ProjectMutator {
 		});
 		return require_render_block.createBContextFromUpstreams(this.tx, upstreamContexts);
 	}
-	createStagingCtx(upstream) {
-		const upstreamContexts = [];
-		upstream.forEach((id) => {
-			const info = this.getBlockInfo(id);
-			if (info.fields["stagingCtx"]?.ref !== void 0) upstreamContexts.push(_milaboratories_pl_client.Pl.unwrapHolder(this.tx, info.fields["stagingCtx"].ref));
-			else if (info.fields.currentPrerunArgs !== void 0) throw new Error(`Upstream ${id} staging is not rendered but has currentPrerunArgs set.`);
-			if (info.fields["prodCtx"]?.ref !== void 0) upstreamContexts.push(_milaboratories_pl_client.Pl.unwrapHolder(this.tx, info.fields["prodCtx"].ref));
-		});
-		return require_render_block.createBContextFromUpstreams(this.tx, upstreamContexts);
+	/**
+	* Rebuilds the production context chain from `fromBlockIndex` to the end.
+	* Each block gets a `prodChainCtx` field containing the accumulated production
+	* contexts from all blocks above it in project order.
+	*
+	* Construction rule for block at position K:
+	* - If block K-1 has prodCtx: chainNode[K] = BContext(chainNode[K-1], K-1.prodCtx)
+	* - If block K-1 has no prodCtx: chainNode[K] = chainNode[K-1] (passthrough)
+	* - Block 0: chainNode[0] = BContextEnd
+	*/
+	rebuildProdChain(fromBlockIndex = 0) {
+		const blocks = [...require_project_model_util.allBlocks(this.struct)];
+		if (fromBlockIndex >= blocks.length) return;
+		let prevChainCtx;
+		if (fromBlockIndex > 0) {
+			const prevHolder = this.getBlockInfo(blocks[fromBlockIndex - 1].id).fields.prodChainCtx?.ref;
+			if (prevHolder === void 0) throw new Error(`rebuildProdChain(${fromBlockIndex}): block ${blocks[fromBlockIndex - 1].id} at position ${fromBlockIndex - 1} has no prodChainCtx — chain must be built from 0 first`);
+			prevChainCtx = _milaboratories_pl_client.Pl.unwrapHolder(this.tx, prevHolder);
+		}
+		for (let i = fromBlockIndex; i < blocks.length; i++) {
+			const blockId = blocks[i].id;
+			let newChainCtx;
+			if (i === 0) newChainCtx = require_render_block.createBContextEnd(this.tx);
+			else {
+				const prevBlockId = blocks[i - 1].id;
+				const prevProdCtxHolder = this.getBlockInfo(prevBlockId).fields.prodCtx?.ref;
+				if (prevProdCtxHolder !== void 0) {
+					const upstreams = [];
+					upstreams.push(prevChainCtx);
+					upstreams.push(_milaboratories_pl_client.Pl.unwrapHolder(this.tx, prevProdCtxHolder));
+					newChainCtx = require_render_block.createBContextFromUpstreams(this.tx, upstreams);
+				} else newChainCtx = prevChainCtx;
+			}
+			this.setBlockField(blockId, "prodChainCtx", _milaboratories_pl_client.Pl.wrapInEphHolder(this.tx, newChainCtx), "NotReady");
+			prevChainCtx = newChainCtx;
+		}
 	}
 	exportCtx(ctx) {
 		return require_context_export.exportContext(this.tx, _milaboratories_pl_client.Pl.unwrapHolder(this.tx, this.ctxExportTplHolder), ctx);
@@ -476,7 +515,9 @@ var ProjectMutator = class ProjectMutator {
 		const prerunArgsRef = info.fields.currentPrerunArgs?.ref;
 		if (prerunArgsRef === void 0) return;
 		this.resetStaging(blockId);
-		const ctx = this.createStagingCtx(this.getStagingGraph().nodes.get(blockId).upstream);
+		const chainCtxHolder = info.fields.prodChainCtx?.ref;
+		if (chainCtxHolder === void 0) throw new Error(`[renderStagingFor] block ${blockId} has no prodChainCtx — chain must be built before staging render`);
+		const ctx = _milaboratories_pl_client.Pl.unwrapHolder(this.tx, chainCtxHolder);
 		if (this.getBlock(blockId).renderingMode !== "Heavy") throw new Error("not supported yet");
 		const tpl = info.getTemplate(this.tx);
 		const results = require_render_block.createRenderHeavyBlock(this.tx, tpl, {
@@ -594,6 +635,12 @@ var ProjectMutator = class ProjectMutator {
 		this.stagingGraph = void 0;
 		this.pendingProductionGraph = void 0;
 		this.actualProductionGraph = void 0;
+		const newBlocks = [...require_project_model_util.allBlocks(newStructure)];
+		const oldBlocks = [...currentStagingGraph.nodes.keys()];
+		const n = Math.min(newBlocks.length, oldBlocks.length);
+		let firstChangedIdx = 0;
+		while (firstChangedIdx < n && newBlocks[firstChangedIdx].id === oldBlocks[firstChangedIdx]) firstChangedIdx++;
+		if (firstChangedIdx < newBlocks.length) this.rebuildProdChain(firstChangedIdx);
 		this.updateLastModified();
 	}
 	addBlock(block, spec, before) {
@@ -706,9 +753,14 @@ var ProjectMutator = class ProjectMutator {
 				if (info.fields.currentArgs !== void 0) this.setBlockFieldObj(blockId, "currentPrerunArgs", info.fields.currentArgs);
 			}
 			this.blocksWithChangedInputs.add(blockId);
-			this.getStagingGraph().traverse("downstream", [blockId], ({ id }) => this.resetStaging(id));
 		}
 		if (info.productionRendered) this.getActualProductionGraph().traverse("downstream", [blockId], ({ id }) => this.resetOrLimboProduction(id));
+		const blocksList = [...require_project_model_util.allBlocks(this.struct)];
+		const blockIdx = blocksList.findIndex((b) => b.id === blockId);
+		if (blockIdx >= 0) {
+			this.rebuildProdChain(blockIdx + 1);
+			for (let i = blockIdx; i < blocksList.length; i++) this.resetStaging(blocksList[i].id);
+		}
 		this.updateLastModified();
 	}
 	renderProduction(blockIds, addUpstreams = false) {
@@ -742,9 +794,14 @@ var ProjectMutator = class ProjectMutator {
 			if (rendered.has(node.id)) return;
 			this.resetOrLimboProduction(node.id);
 		});
-		this.getStagingGraph().traverse("downstream", renderedArray, ({ id }) => {
-			if (renderedArray[0] !== id) this.resetStaging(id);
-		});
+		if (rendered.size > 0) {
+			const blocksList = [...require_project_model_util.allBlocks(this.struct)];
+			const firstRenderedIdx = blocksList.findIndex((b) => rendered.has(b.id));
+			if (firstRenderedIdx >= 0) {
+				this.rebuildProdChain(firstRenderedIdx + 1);
+				for (let i = firstRenderedIdx + 1; i < blocksList.length; i++) this.resetStaging(blocksList[i].id);
+			}
+		}
 		if (rendered.size > 0) this.updateLastModified();
 		return rendered;
 	}
@@ -769,38 +826,29 @@ var ProjectMutator = class ProjectMutator {
 			}
 		}
 		for (const blockId of activeProdGraph.traverseIdsExcludingRoots("downstream", ...stopped)) this.resetOrLimboProduction(blockId);
-		this.getStagingGraph().traverse("downstream", stopped, ({ id }) => this.resetStaging(id));
-	}
-	traverseWithStagingLag(cb) {
-		const lags = /* @__PURE__ */ new Map();
-		this.getStagingGraph().nodes.forEach((node) => {
-			const info = this.getBlockInfo(node.id);
-			const requiresRendering = info.requireStagingRendering;
-			let lag = requiresRendering ? 1 : 0;
-			node.upstream.forEach((upstream) => {
-				const upstreamLag = lags.get(upstream);
-				if (upstreamLag === 0) return;
-				lag = Math.max(upstreamLag + 1, lag);
-			});
-			if (!requiresRendering && info.stagingRendered) {}
-			cb(node.id, lag);
-			lags.set(node.id, lag);
-		});
+		if (stopped.length > 0) {
+			const blocksList = [...require_project_model_util.allBlocks(this.struct)];
+			const stoppedSet = new Set(stopped);
+			const firstStoppedIdx = blocksList.findIndex((b) => stoppedSet.has(b.id));
+			if (firstStoppedIdx >= 0) {
+				this.rebuildProdChain(firstStoppedIdx + 1);
+				for (let i = firstStoppedIdx; i < blocksList.length; i++) this.resetStaging(blocksList[i].id);
+			}
+		}
 	}
-	/** @param stagingRenderingRate rate in blocks per second */
-	refreshStagings(stagingRenderingRate) {
-		const elapsed = Date.now() - this.renderingState.stagingRefreshTimestamp;
-		const lagThreshold = stagingRenderingRate === void 0 ? void 0 : 1 + Math.max(0, elapsed * stagingRenderingRate / 1e3);
+	/** Renders staging for blocks that need it (have currentPrerunArgs but no staging). */
+	refreshStagings() {
+		const maxBatch = ProjectMutator.STAGING_REFRESH_MAX_BATCH;
 		let rendered = 0;
-		this.traverseWithStagingLag((blockId, lag) => {
-			if (lag === 0) return;
-			if (lagThreshold === void 0 || lag <= lagThreshold) try {
-				this.renderStagingFor(blockId);
+		for (const block of require_project_model_util.allBlocks(this.struct)) {
+			if (rendered >= maxBatch) break;
+			if (this.getBlockInfo(block.id).requireStagingRendering) try {
+				this.renderStagingFor(block.id);
 				rendered++;
 			} catch (e) {
-				this.projectHelper.logger.error(new Error(`[refreshStagings] renderStagingFor failed for ${blockId}`, { cause: e }));
+				this.projectHelper.logger.error(new Error(`[refreshStagings] renderStagingFor failed for ${block.id}`, { cause: e }));
 			}
-		});
+		}
 		if (rendered > 0) this.resetStagingRefreshTimestamp();
 	}
 	/** Updates project metadata */
@@ -809,9 +857,9 @@ var ProjectMutator = class ProjectMutator {
 		this.metaChanged = true;
 		this.updateLastModified();
 	}
-	/** @param stagingRenderingRate rate in blocks per second */
-	doRefresh(stagingRenderingRate) {
-		this.refreshStagings(stagingRenderingRate);
+	/** Background maintenance: render pending stagings + GC of Previous fields. */
+	doRefresh() {
+		this.refreshStagings();
 		this.blockInfos.forEach((blockInfo) => {
 			if (blockInfo.fields.prodCtx?.status === "Ready" && blockInfo.fields.prodOutput?.status === "Ready") this.deleteBlockFields(blockInfo.id, "prodOutputPrevious", "prodCtxPrevious", "prodUiCtxPrevious");
 			if (blockInfo.fields.stagingCtx?.status === "Ready" && blockInfo.fields.stagingOutput?.status === "Ready") this.deleteBlockFields(blockInfo.id, "stagingOutputPrevious", "stagingCtxPrevious", "stagingUiCtxPrevious");
@@ -961,7 +1009,7 @@ async function duplicateProject(tx, sourceRid, options) {
 	const sourceKVs = await sourceKVsP;
 	const schemaKV = sourceKVs.find((kv) => kv.key === require_project_model.SchemaVersionKey);
 	const schema = schemaKV ? JSON.parse(schemaKV.value) : void 0;
-	if (schema !== require_project_model.SchemaVersionCurrent) throw new _platforma_sdk_model.UiError(`Cannot duplicate project with schema version ${schema ?? "unknown"}. Only schema version ${require_project_model.SchemaVersionCurrent} is supported. Try opening the project first to trigger migration.`);
+	if (schema !== require_project_model.SchemaVersionCurrent && schema !== require_project_model.SchemaVersionV3) throw new _platforma_sdk_model.UiError(`Cannot duplicate project with schema version ${schema ?? "unknown"}. Only schema versions ${require_project_model.SchemaVersionV3} and ${require_project_model.SchemaVersionCurrent} are supported. Try opening the project first to trigger migration.`);
 	const newPrj = tx.createEphemeral(require_project_model.ProjectResourceType);
 	tx.lock(newPrj);
 	const ts = String(Date.now());