@milaboratories/pl-middle-layer 1.66.4 → 1.66.6

package/dist/mutator/project.js

@@ -9,10 +9,19 @@ import { BLOCK_STORAGE_FACADE_VERSION, UiError, extractConfig } from "@platforma
 import { InitialBlockSettings } from "@milaboratories/pl-model-middle-layer";
 import { ConsoleLoggerAdapter, cachedDecode, cachedDeserialize, canonicalJsonBytes, notEmpty } from "@milaboratories/ts-helpers";
 import { gzipSync } from "node:zlib";
-import { Pl, PlClient, ensureSignedResourceIdNotNull, field, isNotNullSignedResourceId, isNullSignedResourceId, isResource, isResourceId, isResourceRef } from "@milaboratories/pl-client";
+import { Pl, PlClient, ensureSignedResourceIdNotNull, field, isNotNullSignedResourceId, isNullSignedResourceId, isResource, isResourceId, isResourceRef, readyOrDuplicateOrError } from "@milaboratories/pl-client";
 import { ModelAPIVersionMismatchError } from "@milaboratories/pl-errors";
 import Denque from "denque";
 //#region src/mutator/project.ts
+/**
+* A production core field is "settled" once its result is immutable — `Ready` or a finished
+* `Error`. `NotReady` (still computing) is the only unsettled status; a missing field is unsettled.
+* Settled production is safe to keep/share; only running production is dropped. The resource-level
+* equivalent is {@link readyOrDuplicateOrError}.
+*/
+function isProductionFieldSettled(status) {
+	return status === "Ready" || status === "Error";
+}
 function cached(modIdCb, valueCb) {
 	let initialized = false;
 	let lastModId = void 0;
@@ -240,6 +249,32 @@ var ProjectMutator = class ProjectMutator {
 		if (this.actualProductionGraph === void 0) this.actualProductionGraph = productionGraph(this.struct, (blockId) => this.getProductionGraphBlockInfo(blockId, true));
 		return this.actualProductionGraph;
 	}
+	/**
+	* Blocks whose production must NOT be shared with a copy of the project: those still computing
+	* ("NotReady"), plus their downstream closure. Settled production — `Ready` or a finished
+	* `Error` — is kept: it is immutable, so sharing by reference is safe, and sharing an errored
+	* project (to show it failed) is a valid use-case. Only running production would tie the copy to
+	* the source's live computation.
+	*
+	* The closure keeps the chain consistent: a finished block's `prodCtx` is built from its
+	* upstreams' `prodCtx` (see {@link createProdCtx}), so keeping it while dropping a running
+	* upstream would leave it referencing an absent context — a break {@link check} misses. Settled
+	* blocks are never seeds, so their downstream is retained.
+	*
+	* Blocks without production are ignored. Returns empty when nothing is running.
+	*/
+	productionBlocksToDropForCopy() {
+		const dropSet = /* @__PURE__ */ new Set();
+		for (const [blockId, info] of this.blockInfos) {
+			if (!(info.fields.prodOutput !== void 0 || info.fields.prodCtx !== void 0)) continue;
+			if (!isProductionFieldSettled(info.fields.prodOutput?.status) || !isProductionFieldSettled(info.fields.prodCtx?.status)) dropSet.add(blockId);
+		}
+		if (dropSet.size === 0) return dropSet;
+		const graph = this.getActualProductionGraph();
+		const seeds = [...dropSet].filter((id) => graph.nodes.has(id));
+		for (const id of graph.traverseIds("downstream", ...seeds)) dropSet.add(id);
+		return dropSet;
+	}
 	getBlockInfo(blockId) {
 		const info = this.blockInfos.get(blockId);
 		if (info === void 0) throw new Error(`No such block: ${blockId}`);
@@ -354,12 +389,12 @@ var ProjectMutator = class ProjectMutator {
 		}
 		this.deleteBlockFields(blockId, "prodOutput", "prodCtx", "prodUiCtx", "prodArgs");
 	}
-	/** Running blocks are reset, already computed moved to limbo. Returns if
+	/** Running blocks are reset, settled ones (Ready or finished Error) moved to limbo. Returns if
 	* either of the actions were actually performed.
 	* This method ensures the block is left in a consistent state that passes check() constraints. */
 	resetOrLimboProduction(blockId) {
 		const fields = this.getBlockInfo(blockId).fields;
-		if (fields.prodOutput?.status === "Ready" && fields.prodCtx?.status === "Ready") {
+		if (isProductionFieldSettled(fields.prodOutput?.status) && isProductionFieldSettled(fields.prodCtx?.status)) {
 			if (this.blocksInLimbo.has(blockId)) return false;
 			this.blocksInLimbo.add(blockId);
 			this.renderingStateChanged = true;
@@ -592,7 +627,7 @@ var ProjectMutator = class ProjectMutator {
 	getFieldNamesToDuplicate(blockId) {
 		const fields = this.getBlockInfo(blockId).fields;
 		const diff = (setA, setB) => new Set([...setA].filter((x) => !setB.has(x)));
-		if (fields.prodOutput?.status === "Ready" && fields.prodCtx?.status === "Ready") {
+		if (isProductionFieldSettled(fields.prodOutput?.status) && isProductionFieldSettled(fields.prodCtx?.status)) {
 			if (this.blocksInLimbo.has(blockId)) return FieldsToDuplicate;
 			return diff(FieldsToDuplicate, /* @__PURE__ */ new Set([
 				"prodOutputPrevious",
@@ -1007,7 +1042,7 @@ async function createProject(tx, meta = InitialBlockMeta) {
 * @param sourceRid - resource id of the project to duplicate
 * @param options.label - optional label override for the new project; if omitted, copies the source label
 */
-async function duplicateProject(tx, sourceRid, options) {
+async function duplicateProject(tx, sourceRid, options, projectHelper) {
 	const sourceDataP = tx.getResourceData(sourceRid, true);
 	const sourceKVsP = tx.listKeyValuesString(sourceRid);
 	const sourceData = await sourceDataP;
@@ -1017,6 +1052,36 @@ async function duplicateProject(tx, sourceRid, options) {
 	if (schema !== "4" && schema !== "3") throw new UiError(`Cannot duplicate project with schema version ${schema ?? "unknown"}. Only schema versions 3 and 4 are supported. Try opening the project first to trigger migration.`);
 	const newPrj = tx.createEphemeral(ProjectResourceType);
 	tx.lock(newPrj);
+	const prodFields = /* @__PURE__ */ new Set([
+		"prodOutput",
+		"prodCtx",
+		"prodUiCtx",
+		"prodArgs"
+	]);
+	const isTargetSettled = async (rid) => {
+		if (rid === void 0 || isNullSignedResourceId(rid)) return false;
+		try {
+			return readyOrDuplicateOrError(await tx.getResourceData(rid, false));
+		} catch {
+			return false;
+		}
+	};
+	const prodCoreByBlock = /* @__PURE__ */ new Map();
+	for (const f of sourceData.fields) {
+		if (isNullSignedResourceId(f.value)) continue;
+		const parsed = parseProjectField(f.name);
+		if (parsed === void 0) continue;
+		if (parsed.fieldName === "prodOutput" || parsed.fieldName === "prodCtx") {
+			const core = prodCoreByBlock.get(parsed.blockId) ?? {};
+			core[parsed.fieldName] = f.value;
+			prodCoreByBlock.set(parsed.blockId, core);
+		}
+	}
+	const anyRunning = (await Promise.all([...prodCoreByBlock.values()].map(async (core) => !(await isTargetSettled(core.prodOutput) && await isTargetSettled(core.prodCtx))))).some((running) => running);
+	let dropProduction;
+	if (!anyRunning) dropProduction = /* @__PURE__ */ new Set();
+	else if (projectHelper !== void 0 && schema === "4") dropProduction = (await ProjectMutator.load(projectHelper, tx, sourceRid)).productionBlocksToDropForCopy();
+	else dropProduction = new Set(prodCoreByBlock.keys());
 	const ts = String(Date.now());
 	const kvSkipPrefixes = [BlockArgsAuthorKeyPrefix];
 	const kvSkipKeys = /* @__PURE__ */ new Set([
@@ -1041,6 +1106,7 @@ async function duplicateProject(tx, sourceRid, options) {
 		if (isNullSignedResourceId(f.value)) continue;
 		const parsed = parseProjectField(f.name);
 		if (parsed !== void 0 && !FieldsToDuplicate.has(parsed.fieldName)) continue;
+		if (parsed !== void 0 && prodFields.has(parsed.fieldName) && dropProduction.has(parsed.blockId)) continue;
 		tx.createField(field(newPrj, f.name), "Dynamic", f.value);
 	}
 	return newPrj;