@milaboratories/pl-middle-layer 1.46.20 → 1.46.22

package/dist/mutator/project.js

@@ -44,19 +44,19 @@ class BlockInfo {
     check() {
         // state assertions
         if ((this.fields.prodOutput === undefined) !== (this.fields.prodCtx === undefined))
-            throw new Error('inconsistent prod fields');
+            throw new Error("inconsistent prod fields");
         if ((this.fields.stagingOutput === undefined) !== (this.fields.stagingCtx === undefined))
-            throw new Error('inconsistent stage fields');
-        if ((this.fields.prodOutputPrevious === undefined)
-            !== (this.fields.prodCtxPrevious === undefined))
-            throw new Error('inconsistent prod cache fields');
-        if ((this.fields.stagingOutputPrevious === undefined)
-            !== (this.fields.stagingCtxPrevious === undefined))
-            throw new Error('inconsistent stage cache fields');
+            throw new Error("inconsistent stage fields");
+        if ((this.fields.prodOutputPrevious === undefined) !==
+            (this.fields.prodCtxPrevious === undefined))
+            throw new Error("inconsistent prod cache fields");
+        if ((this.fields.stagingOutputPrevious === undefined) !==
+            (this.fields.stagingCtxPrevious === undefined))
+            throw new Error("inconsistent stage cache fields");
         if (this.fields.blockPack === undefined)
-            throw new Error('no block pack field');
+            throw new Error("no block pack field");
         if (this.fields.blockStorage === undefined)
-            throw new Error('no block storage field');
+            throw new Error("no block storage field");
     }
     currentArgsC = cached(() => this.fields.currentArgs?.modCount, () => {
         const bin = this.fields.currentArgs?.value;
@@ -96,7 +96,7 @@ class BlockInfo {
             return this.blockStorageC();
         }
         catch (e) {
-            console.error('Error getting blockStorage:', e);
+            console.error("Error getting blockStorage:", e);
             return undefined;
         }
     }
@@ -113,10 +113,10 @@ class BlockInfo {
         return this.fields.prodCtx !== undefined;
     }
     get productionHasErrors() {
-        return this.fields.prodUiCtx?.status === 'Error';
+        return this.fields.prodUiCtx?.status === "Error";
     }
-    productionStaleC = cached(() => `${this.fields.currentArgs.modCount}_${this.fields.prodArgs?.modCount}`, () => this.fields.prodArgs === undefined
-        || Buffer.compare(this.fields.currentArgs.value, this.fields.prodArgs.value) !== 0);
+    productionStaleC = cached(() => `${this.fields.currentArgs.modCount}_${this.fields.prodArgs?.modCount}`, () => this.fields.prodArgs === undefined ||
+        Buffer.compare(this.fields.currentArgs.value, this.fields.prodArgs.value) !== 0);
     get requireProductionRendering() {
         return !this.productionRendered || this.productionStaleC() || this.productionHasErrors;
     }
@@ -131,7 +131,7 @@ class BlockInfo {
         return this.prodArgsC();
     }
     getTemplate(tx) {
-        return tx.getFutureFieldValue(Pl.unwrapHolder(tx, this.fields.blockPack.ref), BlockPackTemplateField, 'Input');
+        return tx.getFutureFieldValue(Pl.unwrapHolder(tx, this.fields.blockPack.ref), BlockPackTemplateField, "Input");
     }
 }
 const NoNewBlocks = (blockId) => {
@@ -178,10 +178,10 @@ class ProjectMutator {
     fixProblemsAndMigrate() {
         // Fixing problems introduced by old code
         this.blockInfos.forEach((blockInfo) => {
-            if (blockInfo.fields.prodArgs === undefined
-                || blockInfo.fields.prodOutput === undefined
-                || blockInfo.fields.prodCtx === undefined)
-                this.deleteBlockFields(blockInfo.id, 'prodArgs', 'prodOutput', 'prodCtx');
+            if (blockInfo.fields.prodArgs === undefined ||
+                blockInfo.fields.prodOutput === undefined ||
+                blockInfo.fields.prodCtx === undefined)
+                this.deleteBlockFields(blockInfo.id, "prodArgs", "prodOutput", "prodCtx");
         });
         // Migration for addition of block settings field
         let initialBlockSettings;
@@ -189,16 +189,16 @@ class ProjectMutator {
             if (blockInfo.fields.blockSettings === undefined) {
                 if (initialBlockSettings === undefined)
                     initialBlockSettings = this.createJsonFieldValue(InitialBlockSettings);
-                this.setBlockFieldObj(blockInfo.id, 'blockSettings', initialBlockSettings);
+                this.setBlockFieldObj(blockInfo.id, "blockSettings", initialBlockSettings);
             }
         });
     }
     get wasModified() {
-        return (this.lastModifiedChanged
-            || this.structureChanged
-            || this.fieldsChanged
-            || this.metaChanged
-            || this.renderingStateChanged);
+        return (this.lastModifiedChanged ||
+            this.structureChanged ||
+            this.fieldsChanged ||
+            this.metaChanged ||
+            this.renderingStateChanged);
     }
     get structure() {
         return JSON.parse(JSON.stringify(this.struct));
@@ -265,10 +265,10 @@ class ProjectMutator {
     }
     createJsonFieldValueByContent(content) {
         if (content === undefined)
-            throw new Error('content is undefined');
+            throw new Error("content is undefined");
         const value = Buffer.from(content);
         const ref = this.tx.createValue(Pl.JsonObject, value);
-        return { ref, value, status: 'Ready' };
+        return { ref, value, status: "Ready" };
     }
     createJsonFieldValue(obj) {
         return this.createJsonFieldValueByContent(JSON.stringify(obj));
@@ -277,14 +277,14 @@ class ProjectMutator {
         for (const block of allBlocks(this.struct))
             if (block.id === blockId)
                 return block;
-        throw new Error('block not found');
+        throw new Error("block not found");
     }
     setBlockFieldObj(blockId, fieldName, state) {
         const fid = field(this.rid, projectFieldName(blockId, fieldName));
         if (state.ref === undefined)
-            throw new Error('Can\'t set value with empty ref');
+            throw new Error("Can't set value with empty ref");
         if (this.getBlockInfo(blockId).fields[fieldName] === undefined)
-            this.tx.createField(fid, 'Dynamic', state.ref);
+            this.tx.createField(fid, "Dynamic", state.ref);
         else
             this.tx.setField(fid, state.ref);
         this.getBlockInfo(blockId).fields[fieldName] = {
@@ -323,26 +323,26 @@ class ProjectMutator {
     }
     resetStaging(blockId) {
         const fields = this.getBlockInfo(blockId).fields;
-        if (fields.stagingOutput?.status === 'Ready'
-            && fields.stagingCtx?.status === 'Ready'
-            && fields.stagingUiCtx?.status === 'Ready') {
-            this.setBlockFieldObj(blockId, 'stagingOutputPrevious', fields.stagingOutput);
-            this.setBlockFieldObj(blockId, 'stagingCtxPrevious', fields.stagingCtx);
-            this.setBlockFieldObj(blockId, 'stagingUiCtxPrevious', fields.stagingUiCtx);
+        if (fields.stagingOutput?.status === "Ready" &&
+            fields.stagingCtx?.status === "Ready" &&
+            fields.stagingUiCtx?.status === "Ready") {
+            this.setBlockFieldObj(blockId, "stagingOutputPrevious", fields.stagingOutput);
+            this.setBlockFieldObj(blockId, "stagingCtxPrevious", fields.stagingCtx);
+            this.setBlockFieldObj(blockId, "stagingUiCtxPrevious", fields.stagingUiCtx);
         }
-        if (this.deleteBlockFields(blockId, 'stagingOutput', 'stagingCtx', 'stagingUiCtx'))
+        if (this.deleteBlockFields(blockId, "stagingOutput", "stagingCtx", "stagingUiCtx"))
             this.resetStagingRefreshTimestamp();
     }
     resetProduction(blockId) {
         const fields = this.getBlockInfo(blockId).fields;
-        if (fields.prodOutput?.status === 'Ready'
-            && fields.prodCtx?.status === 'Ready'
-            && fields.prodUiCtx?.status === 'Ready') {
-            this.setBlockFieldObj(blockId, 'prodOutputPrevious', fields.prodOutput);
-            this.setBlockFieldObj(blockId, 'prodCtxPrevious', fields.prodCtx);
-            this.setBlockFieldObj(blockId, 'prodUiCtxPrevious', fields.prodUiCtx);
+        if (fields.prodOutput?.status === "Ready" &&
+            fields.prodCtx?.status === "Ready" &&
+            fields.prodUiCtx?.status === "Ready") {
+            this.setBlockFieldObj(blockId, "prodOutputPrevious", fields.prodOutput);
+            this.setBlockFieldObj(blockId, "prodCtxPrevious", fields.prodCtx);
+            this.setBlockFieldObj(blockId, "prodUiCtxPrevious", fields.prodUiCtx);
         }
-        this.deleteBlockFields(blockId, 'prodOutput', 'prodCtx', 'prodUiCtx', 'prodArgs');
+        this.deleteBlockFields(blockId, "prodOutput", "prodCtx", "prodUiCtx", "prodArgs");
     }
     /** Running blocks are reset, already computed moved to limbo. Returns if
      * either of the actions were actually performed.
@@ -350,7 +350,7 @@ class ProjectMutator {
     resetOrLimboProduction(blockId) {
         const fields = this.getBlockInfo(blockId).fields;
         // Check if we can safely move to limbo (both core production fields are ready)
-        if (fields.prodOutput?.status === 'Ready' && fields.prodCtx?.status === 'Ready') {
+        if (fields.prodOutput?.status === "Ready" && fields.prodCtx?.status === "Ready") {
             if (this.blocksInLimbo.has(blockId))
                 // we are already in limbo
                 return false;
@@ -358,12 +358,12 @@ class ProjectMutator {
             this.blocksInLimbo.add(blockId);
             this.renderingStateChanged = true;
             // doing some gc - clean up previous cache fields
-            this.deleteBlockFields(blockId, 'prodOutputPrevious', 'prodCtxPrevious', 'prodUiCtxPrevious');
+            this.deleteBlockFields(blockId, "prodOutputPrevious", "prodCtxPrevious", "prodUiCtxPrevious");
             return true;
         }
         else {
             // reset - clean up any partial/inconsistent production stat
-            return this.deleteBlockFields(blockId, 'prodOutput', 'prodCtx', 'prodUiCtx', 'prodArgs', 'prodOutputPrevious', 'prodCtxPrevious', 'prodUiCtxPrevious');
+            return this.deleteBlockFields(blockId, "prodOutput", "prodCtx", "prodUiCtx", "prodArgs", "prodOutputPrevious", "prodCtxPrevious", "prodUiCtxPrevious");
         }
     }
     /**
@@ -387,7 +387,7 @@ class ProjectMutator {
      * @param rawStorageJson Raw storage as JSON string
      */
     setBlockStorageRaw(blockId, rawStorageJson) {
-        this.setBlockFieldObj(blockId, 'blockStorage', this.createJsonFieldValueByContent(rawStorageJson));
+        this.setBlockFieldObj(blockId, "blockStorage", this.createJsonFieldValueByContent(rawStorageJson));
         this.blocksWithChangedInputs.add(blockId);
         this.updateLastModified();
     }
@@ -403,7 +403,7 @@ class ProjectMutator {
         const info = this.getBlockInfo(blockId);
         const blockConfig = info.config;
         if (blockConfig.modelAPIVersion !== 2) {
-            throw new Error('resetToInitialStorage is only supported for model API version 2');
+            throw new Error("resetToInitialStorage is only supported for model API version 2");
         }
         // Get initial storage from VM
         const initialStorageJson = this.projectHelper.getInitialStorageInVM(blockConfig);
@@ -411,15 +411,15 @@ class ProjectMutator {
         // Derive args from storage - set or clear currentArgs based on derivation result
         const deriveArgsResult = this.projectHelper.deriveArgsFromStorage(blockConfig, initialStorageJson);
         if (!deriveArgsResult.error) {
-            this.setBlockFieldObj(blockId, 'currentArgs', this.createJsonFieldValue(deriveArgsResult.value));
+            this.setBlockFieldObj(blockId, "currentArgs", this.createJsonFieldValue(deriveArgsResult.value));
             // Derive prerunArgs from storage
             const prerunArgs = this.projectHelper.derivePrerunArgsFromStorage(blockConfig, initialStorageJson);
             if (prerunArgs !== undefined) {
-                this.setBlockFieldObj(blockId, 'currentPrerunArgs', this.createJsonFieldValue(prerunArgs));
+                this.setBlockFieldObj(blockId, "currentPrerunArgs", this.createJsonFieldValue(prerunArgs));
             }
         }
         else {
-            this.deleteBlockFields(blockId, 'currentArgs');
+            this.deleteBlockFields(blockId, "currentArgs");
         }
     }
     /** Optimally sets inputs for multiple blocks in one go */
@@ -444,7 +444,7 @@ class ProjectMutator {
                 }
                 // Apply the state update to storage
                 const updatedStorageJson = this.projectHelper.applyStorageUpdateInVM(blockConfig, currentStorageJson, req.payload);
-                this.setBlockFieldObj(req.blockId, 'blockStorage', this.createJsonFieldValueByContent(updatedStorageJson));
+                this.setBlockFieldObj(req.blockId, "blockStorage", this.createJsonFieldValueByContent(updatedStorageJson));
                 // Derive args directly from storage (VM extracts data internally)
                 const derivedArgsResult = this.projectHelper.deriveArgsFromStorage(blockConfig, updatedStorageJson);
                 if (derivedArgsResult.error) {
@@ -458,8 +458,8 @@ class ProjectMutator {
                 }
             }
             else {
-                this.setBlockFieldObj(req.blockId, 'blockStorage', this.createJsonFieldValue(req.state));
-                if (req.state !== null && typeof req.state === 'object' && 'args' in req.state) {
+                this.setBlockFieldObj(req.blockId, "blockStorage", this.createJsonFieldValue(req.state));
+                if (req.state !== null && typeof req.state === "object" && "args" in req.state) {
                     args = req.state.args;
                 }
                 else {
@@ -472,10 +472,10 @@ class ProjectMutator {
             if (args !== undefined) {
                 const currentArgsData = canonicalJsonBytes(args);
                 const argsPartRef = this.tx.createValue(Pl.JsonObject, currentArgsData);
-                this.setBlockField(req.blockId, 'currentArgs', argsPartRef, 'Ready', currentArgsData);
+                this.setBlockField(req.blockId, "currentArgs", argsPartRef, "Ready", currentArgsData);
             }
             else {
-                this.deleteBlockFields(req.blockId, 'currentArgs');
+                this.deleteBlockFields(req.blockId, "currentArgs");
             }
             // Set currentPrerunArgs field and check if it actually changed
             let prerunArgsChanged = false;
@@ -483,11 +483,12 @@ class ProjectMutator {
                 const prerunArgsData = canonicalJsonBytes(prerunArgs);
                 const oldPrerunArgsData = info.fields.currentPrerunArgs?.value;
                 // Check if prerunArgs actually changed
-                if (oldPrerunArgsData === undefined || Buffer.compare(oldPrerunArgsData, prerunArgsData) !== 0) {
+                if (oldPrerunArgsData === undefined ||
+                    Buffer.compare(oldPrerunArgsData, prerunArgsData) !== 0) {
                     prerunArgsChanged = true;
                 }
                 const prerunArgsRef = this.tx.createValue(Pl.JsonObject, prerunArgsData);
-                this.setBlockField(req.blockId, 'currentPrerunArgs', prerunArgsRef, 'Ready', prerunArgsData);
+                this.setBlockField(req.blockId, "currentPrerunArgs", prerunArgsRef, "Ready", prerunArgsData);
             }
             else {
                 // prerunArgs is undefined - check if we previously had one
@@ -507,21 +508,21 @@ class ProjectMutator {
             }
         }
         // resetting staging outputs for all downstream blocks
-        this.getStagingGraph().traverse('downstream', changedArgs, ({ id }) => this.resetStaging(id));
+        this.getStagingGraph().traverse("downstream", changedArgs, ({ id }) => this.resetStaging(id));
         if (somethingChanged)
             this.updateLastModified();
     }
     setBlockSettings(blockId, newValue) {
-        this.setBlockFieldObj(blockId, 'blockSettings', this.createJsonFieldValue(newValue));
+        this.setBlockFieldObj(blockId, "blockSettings", this.createJsonFieldValue(newValue));
         this.updateLastModified();
     }
     createProdCtx(upstream) {
         const upstreamContexts = [];
         upstream.forEach((id) => {
             const info = this.getBlockInfo(id);
-            if (info.fields['prodCtx']?.ref === undefined)
-                throw new Error('One of the upstreams staging is not rendered.');
-            upstreamContexts.push(Pl.unwrapHolder(this.tx, info.fields['prodCtx'].ref));
+            if (info.fields["prodCtx"]?.ref === undefined)
+                throw new Error("One of the upstreams staging is not rendered.");
+            upstreamContexts.push(Pl.unwrapHolder(this.tx, info.fields["prodCtx"].ref));
         });
         return createBContextFromUpstreams(this.tx, upstreamContexts);
     }
@@ -529,11 +530,11 @@ class ProjectMutator {
         const upstreamContexts = [];
         upstream.forEach((id) => {
             const info = this.getBlockInfo(id);
-            if (info.fields['stagingCtx']?.ref === undefined)
-                throw new Error('One of the upstreams staging is not rendered.');
-            upstreamContexts.push(Pl.unwrapHolder(this.tx, info.fields['stagingCtx'].ref));
-            if (info.fields['prodCtx']?.ref !== undefined)
-                upstreamContexts.push(Pl.unwrapHolder(this.tx, info.fields['prodCtx'].ref));
+            if (info.fields["stagingCtx"]?.ref === undefined)
+                throw new Error("One of the upstreams staging is not rendered.");
+            upstreamContexts.push(Pl.unwrapHolder(this.tx, info.fields["stagingCtx"].ref));
+            if (info.fields["prodCtx"]?.ref !== undefined)
+                upstreamContexts.push(Pl.unwrapHolder(this.tx, info.fields["prodCtx"].ref));
         });
         return createBContextFromUpstreams(this.tx, upstreamContexts);
     }
@@ -553,8 +554,8 @@ class ProjectMutator {
             return;
         }
         const ctx = this.createStagingCtx(this.getStagingGraph().nodes.get(blockId).upstream);
-        if (this.getBlock(blockId).renderingMode !== 'Heavy')
-            throw new Error('not supported yet');
+        if (this.getBlock(blockId).renderingMode !== "Heavy")
+            throw new Error("not supported yet");
         const tpl = info.getTemplate(this.tx);
         // Use currentPrerunArgs for staging rendering
         const results = createRenderHeavyBlock(this.tx, tpl, {
@@ -566,11 +567,11 @@ class ProjectMutator {
         // Here we set the staging ctx to the input context of the staging workflow, not the output because exports
         // of one staging context should stay within the same block, and not travel downstream.
         // We may change this decision in the future if wanted to support traveling staging exports downstream.
-        this.setBlockField(blockId, 'stagingCtx', Pl.wrapInEphHolder(this.tx, ctx), 'NotReady');
+        this.setBlockField(blockId, "stagingCtx", Pl.wrapInEphHolder(this.tx, ctx), "NotReady");
         // Yet the staging UI Ctx is the output context of the staging workflow, because it is used to form the result pool
         // thus creating a certain discrepancy between staging workflow context behavior and desktop's result pool.
-        this.setBlockField(blockId, 'stagingUiCtx', this.exportCtx(results.context), 'NotReady');
-        this.setBlockField(blockId, 'stagingOutput', results.result, 'NotReady');
+        this.setBlockField(blockId, "stagingUiCtx", this.exportCtx(results.context), "NotReady");
+        this.setBlockField(blockId, "stagingOutput", results.result, "NotReady");
     }
     renderProductionFor(blockId) {
         this.resetProduction(blockId);
@@ -580,8 +581,8 @@ class ProjectMutator {
             throw new Error(`Can't render production for block ${blockId}: currentArgs not set`);
         }
         const ctx = this.createProdCtx(this.getPendingProductionGraph().nodes.get(blockId).upstream);
-        if (this.getBlock(blockId).renderingMode === 'Light')
-            throw new Error('Can\'t render production for light block.');
+        if (this.getBlock(blockId).renderingMode === "Light")
+            throw new Error("Can't render production for light block.");
         const tpl = info.getTemplate(this.tx);
         const results = createRenderHeavyBlock(this.tx, tpl, {
             args: info.fields.currentArgs.ref,
@@ -589,11 +590,11 @@ class ProjectMutator {
             isProduction: this.tx.createValue(Pl.JsonBool, JSON.stringify(true)),
             context: ctx,
         });
-        this.setBlockField(blockId, 'prodCtx', Pl.wrapInEphHolder(this.tx, results.context), 'NotReady');
-        this.setBlockField(blockId, 'prodUiCtx', this.exportCtx(results.context), 'NotReady');
-        this.setBlockField(blockId, 'prodOutput', results.result, 'NotReady');
+        this.setBlockField(blockId, "prodCtx", Pl.wrapInEphHolder(this.tx, results.context), "NotReady");
+        this.setBlockField(blockId, "prodUiCtx", this.exportCtx(results.context), "NotReady");
+        this.setBlockField(blockId, "prodOutput", results.result, "NotReady");
         // saving inputs for which we rendered the production
-        this.setBlockFieldObj(blockId, 'prodArgs', info.fields.currentArgs);
+        this.setBlockFieldObj(blockId, "prodArgs", info.fields.currentArgs);
         // removing block from limbo as we juts rendered fresh production for it
         if (this.blocksInLimbo.delete(blockId))
             this.renderingStateChanged = true;
@@ -606,14 +607,14 @@ class ProjectMutator {
         this.blockInfos.set(blockId, info);
         // block pack
         const bp = createBlockPack(this.tx, spec.blockPack);
-        this.setBlockField(blockId, 'blockPack', Pl.wrapInHolder(this.tx, bp), 'NotReady');
+        this.setBlockField(blockId, "blockPack", Pl.wrapInHolder(this.tx, bp), "NotReady");
         // settings
-        this.setBlockFieldObj(blockId, 'blockSettings', this.createJsonFieldValue(InitialBlockSettings));
+        this.setBlockFieldObj(blockId, "blockSettings", this.createJsonFieldValue(InitialBlockSettings));
         const blockConfig = info.config;
         let args;
         let prerunArgs;
         let storageToWrite;
-        if (spec.storageMode === 'fromModel') {
+        if (spec.storageMode === "fromModel") {
             // Model API v2+: get initial storage and derive args from it
             storageToWrite = this.projectHelper.getInitialStorageInVM(blockConfig);
             // Derive args directly from storage (VM extracts data internally)
@@ -627,12 +628,12 @@ class ProjectMutator {
                 prerunArgs = this.projectHelper.derivePrerunArgsFromStorage(blockConfig, storageToWrite);
             }
         }
-        else if (spec.storageMode === 'legacy') {
+        else if (spec.storageMode === "legacy") {
             // Model API v1: use legacyState from spec
             const parsedState = JSON.parse(spec.legacyState);
             args = parsedState.args;
             if (args === undefined) {
-                throw new Error('args is undefined in legacyState');
+                throw new Error("args is undefined in legacyState");
             }
             prerunArgs = args;
             storageToWrite = spec.legacyState;
@@ -642,14 +643,14 @@ class ProjectMutator {
         }
         // currentArgs
         if (args !== undefined) {
-            this.setBlockFieldObj(blockId, 'currentArgs', this.createJsonFieldValue(args));
+            this.setBlockFieldObj(blockId, "currentArgs", this.createJsonFieldValue(args));
         }
         // currentPrerunArgs
         if (prerunArgs !== undefined) {
-            this.setBlockFieldObj(blockId, 'currentPrerunArgs', this.createJsonFieldValue(prerunArgs));
+            this.setBlockFieldObj(blockId, "currentPrerunArgs", this.createJsonFieldValue(prerunArgs));
         }
         // blockStorage
-        this.setBlockFieldObj(blockId, 'blockStorage', this.createJsonFieldValueByContent(storageToWrite));
+        this.setBlockFieldObj(blockId, "blockStorage", this.createJsonFieldValueByContent(storageToWrite));
         // checking structure
         info.check();
     }
@@ -657,25 +658,21 @@ class ProjectMutator {
         const fields = this.getBlockInfo(blockId).fields;
         const diff = (setA, setB) => new Set([...setA].filter((x) => !setB.has(x)));
         // Check if we can safely move to limbo (both core production fields are ready)
-        if (fields.prodOutput?.status === 'Ready' && fields.prodCtx?.status === 'Ready') {
+        if (fields.prodOutput?.status === "Ready" && fields.prodCtx?.status === "Ready") {
             if (this.blocksInLimbo.has(blockId))
                 // we are already in limbo
                 return FieldsToDuplicate;
-            return diff(FieldsToDuplicate, new Set([
-                'prodOutputPrevious',
-                'prodCtxPrevious',
-                'prodUiCtxPrevious',
-            ]));
+            return diff(FieldsToDuplicate, new Set(["prodOutputPrevious", "prodCtxPrevious", "prodUiCtxPrevious"]));
         }
         else {
             return diff(FieldsToDuplicate, new Set([
-                'prodOutput',
-                'prodCtx',
-                'prodUiCtx',
-                'prodArgs',
-                'prodOutputPrevious',
-                'prodCtxPrevious',
-                'prodUiCtxPrevious',
+                "prodOutput",
+                "prodCtx",
+                "prodUiCtx",
+                "prodArgs",
+                "prodOutputPrevious",
+                "prodCtxPrevious",
+                "prodUiCtxPrevious",
             ]));
         }
     }
@@ -685,7 +682,9 @@ class ProjectMutator {
         const fieldNamesToDuplicate = this.getFieldNamesToDuplicate(blockId);
         // Copy all fields from original block to new block by sharing references
         for (const [fieldName, fieldState] of Object.entries(originalBlockInfo.fields)) {
-            if (fieldNamesToDuplicate.has(fieldName) && fieldState && fieldState.ref) {
+            if (fieldNamesToDuplicate.has(fieldName) &&
+                fieldState &&
+                fieldState.ref) {
                 this.setBlockFieldObj(blockId, fieldName, {
                     ref: fieldState.ref,
                     status: fieldState.status,
@@ -722,12 +721,12 @@ class ProjectMutator {
         const prodDiff = graphDiff(currentActualProductionGraph, newActualProductionGraph);
         // applying changes due to topology change in production to affected nodes and
         // all their downstreams
-        currentActualProductionGraph.traverse('downstream', [...prodDiff.different], (node) => {
+        currentActualProductionGraph.traverse("downstream", [...prodDiff.different], (node) => {
             this.resetOrLimboProduction(node.id);
         });
-        if (stagingDiff.onlyInB.size > 0
-            || stagingDiff.onlyInA.size > 0
-            || stagingDiff.different.size > 0)
+        if (stagingDiff.onlyInB.size > 0 ||
+            stagingDiff.onlyInA.size > 0 ||
+            stagingDiff.different.size > 0)
             this.resetStagingRefreshTimestamp();
         this.struct = newStructure;
         this.structureChanged = true;
@@ -760,7 +759,7 @@ class ProjectMutator {
         }
         this.updateStructure(newStruct, (blockId) => {
             if (blockId !== block.id)
-                throw new Error('Unexpected');
+                throw new Error("Unexpected");
             this.initializeNewBlock(blockId, spec);
         });
     }
@@ -803,7 +802,7 @@ class ProjectMutator {
         }
         this.updateStructure(newStruct, (blockId) => {
             if (blockId !== newBlockId)
-                throw new Error('Unexpected');
+                throw new Error("Unexpected");
             this.initializeBlockDuplicate(blockId, originalBlockInfo);
         });
     }
@@ -828,7 +827,7 @@ class ProjectMutator {
     migrateBlockPack(blockId, spec, newClearState) {
         const info = this.getBlockInfo(blockId);
         const newConfig = extractConfig(spec.config);
-        this.setBlockField(blockId, 'blockPack', Pl.wrapInHolder(this.tx, createBlockPack(this.tx, spec)), 'NotReady');
+        this.setBlockField(blockId, "blockPack", Pl.wrapInHolder(this.tx, createBlockPack(this.tx, spec)), "NotReady");
         if (newClearState !== undefined) {
             // State is being reset - no migration needed
             const supportsStorageFromVM = newConfig.modelAPIVersion === 2;
@@ -839,11 +838,11 @@ class ProjectMutator {
                 // Derive args from storage - only set currentArgs if derivation succeeds
                 const deriveArgsResult = this.projectHelper.deriveArgsFromStorage(newConfig, initialStorageJson);
                 if (!deriveArgsResult.error) {
-                    this.setBlockFieldObj(blockId, 'currentArgs', this.createJsonFieldValue(deriveArgsResult.value));
+                    this.setBlockFieldObj(blockId, "currentArgs", this.createJsonFieldValue(deriveArgsResult.value));
                     // Derive prerunArgs from storage
                     const prerunArgs = this.projectHelper.derivePrerunArgsFromStorage(newConfig, initialStorageJson);
                     if (prerunArgs !== undefined) {
-                        this.setBlockFieldObj(blockId, 'currentPrerunArgs', this.createJsonFieldValue(prerunArgs));
+                        this.setBlockFieldObj(blockId, "currentPrerunArgs", this.createJsonFieldValue(prerunArgs));
                     }
                 }
                 this.blocksWithChangedInputs.add(blockId);
@@ -873,11 +872,11 @@ class ProjectMutator {
                 }
             }
             // resetting staging outputs for all downstream blocks
-            this.getStagingGraph().traverse('downstream', [blockId], ({ id }) => this.resetStaging(id));
+            this.getStagingGraph().traverse("downstream", [blockId], ({ id }) => this.resetStaging(id));
         }
         // also reset or limbo all downstream productions
         if (info.productionRendered)
-            this.getActualProductionGraph().traverse('downstream', [blockId], ({ id }) => this.resetOrLimboProduction(id));
+            this.getActualProductionGraph().traverse("downstream", [blockId], ({ id }) => this.resetOrLimboProduction(id));
         this.updateLastModified();
     }
     //
@@ -888,17 +887,18 @@ class ProjectMutator {
         const prodGraph = this.getPendingProductionGraph();
         if (addUpstreams)
             // adding all upstreams automatically
-            prodGraph.traverse('upstream', blockIds, (node) => {
+            prodGraph.traverse("upstream", blockIds, (node) => {
                 blockIdsSet.add(node.id);
             });
-        else // checking that targets contain all upstreams
+        else
+            // checking that targets contain all upstreams
             for (const blockId of blockIdsSet) {
                 const node = prodGraph.nodes.get(blockId);
                 if (node === undefined)
                     throw new Error(`Can't find block with id: ${blockId}`);
                 for (const upstream of node.upstream)
                     if (!blockIdsSet.has(upstream))
-                        throw new Error('Can\'t render blocks not including all upstreams.');
+                        throw new Error("Can't render blocks not including all upstreams.");
             }
         // traversing in topological order and rendering target blocks
         const rendered = new Set();
@@ -919,14 +919,14 @@ class ProjectMutator {
         }
         const renderedArray = [...rendered];
         // sending to limbo all downstream blocks
-        prodGraph.traverse('downstream', renderedArray, (node) => {
+        prodGraph.traverse("downstream", renderedArray, (node) => {
             if (rendered.has(node.id))
                 // don't send to limbo blocks that were just rendered
                 return;
             this.resetOrLimboProduction(node.id);
         });
         // resetting staging outputs for all downstream blocks
-        this.getStagingGraph().traverse('downstream', renderedArray, ({ id }) => {
+        this.getStagingGraph().traverse("downstream", renderedArray, ({ id }) => {
             // don't reset staging of the first rendered block
             if (renderedArray[0] !== id)
                 this.resetStaging(id);
@@ -946,14 +946,14 @@ class ProjectMutator {
         while (!queue.isEmpty()) {
             const blockId = queue.shift();
             const fields = this.getBlockInfo(blockId).fields;
-            if (fields.prodOutput?.status === 'Ready' && fields.prodCtx?.status === 'Ready')
+            if (fields.prodOutput?.status === "Ready" && fields.prodCtx?.status === "Ready")
                 // skipping finished blocks
                 continue;
-            if (this.deleteBlockFields(blockId, 'prodOutput', 'prodCtx', 'prodUiCtx', 'prodArgs')) {
+            if (this.deleteBlockFields(blockId, "prodOutput", "prodCtx", "prodUiCtx", "prodArgs")) {
                 // was actually stopped
                 stopped.push(blockId);
                 // will try to stop all its downstreams
-                for (const downstream of activeProdGraph.traverseIdsExcludingRoots('downstream', blockId)) {
+                for (const downstream of activeProdGraph.traverseIdsExcludingRoots("downstream", blockId)) {
                     if (queued.has(downstream))
                         continue;
                     queue.push(downstream);
@@ -962,10 +962,10 @@ class ProjectMutator {
             }
         }
         // blocks under stopped blocks, but having finished production results, goes to limbo
-        for (const blockId of activeProdGraph.traverseIdsExcludingRoots('downstream', ...stopped))
+        for (const blockId of activeProdGraph.traverseIdsExcludingRoots("downstream", ...stopped))
             this.resetOrLimboProduction(blockId);
         // reset staging outputs for all downstream blocks
-        this.getStagingGraph().traverse('downstream', stopped, ({ id }) => this.resetStaging(id));
+        this.getStagingGraph().traverse("downstream", stopped, ({ id }) => this.resetStaging(id));
     }
     traverseWithStagingLag(cb) {
         const lags = new Map();
@@ -1022,12 +1022,12 @@ class ProjectMutator {
     doRefresh(stagingRenderingRate) {
         this.refreshStagings(stagingRenderingRate);
         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');
+            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");
         });
     }
     assignAuthorMarkers() {
@@ -1102,22 +1102,18 @@ class ProjectMutator {
                 if (state.ref === undefined)
                     continue;
                 if (!isResource(state.ref) || isResourceRef(state.ref))
-                    throw new Error('unexpected behaviour');
+                    throw new Error("unexpected behaviour");
                 const fieldName = fName;
                 blockFieldRequests.push([
-                    info, fieldName,
-                    state, tx.getResourceData(state.ref, fieldName == 'blockPack')
+                    info,
+                    fieldName,
+                    state,
+                    tx.getResourceData(state.ref, fieldName == "blockPack"),
                 ]);
             }
         });
         // loading jsons
-        const [schema, lastModified, meta, structure, { stagingRefreshTimestamp, blocksInLimbo },] = await Promise.all([
-            schemaP,
-            lastModifiedP,
-            metaP,
-            structureP,
-            renderingStateP,
-        ]);
+        const [schema, lastModified, meta, structure, { stagingRefreshTimestamp, blocksInLimbo }] = await Promise.all([schemaP, lastModifiedP, metaP, structureP, renderingStateP]);
         // Checking schema version of the project
         if (schema !== SchemaVersionCurrent) {
             if (Number(schema) < Number(SchemaVersionCurrent))
@@ -1137,17 +1133,20 @@ class ProjectMutator {
             const result = await response;
             state.value = result.data;
             if (isNotNullResourceId(result.error))
-                state.status = 'Error';
+                state.status = "Error";
             else if (result.resourceReady || isNotNullResourceId(result.originalResourceId))
-                state.status = 'Ready';
+                state.status = "Ready";
             else
-                state.status = 'NotReady';
+                state.status = "NotReady";
             // For block pack we need to traverse the ref field from the resource data
-            if (fieldName === 'blockPack') {
+            if (fieldName === "blockPack") {
                 const refField = result.fields.find((f) => f.name === Pl.HolderRefField);
                 if (refField === undefined)
-                    throw new Error('Block pack ref field is missing');
-                blockPackRequests.push([info, tx.getResourceData(ensureResourceIdNotNull(refField.value), false)]);
+                    throw new Error("Block pack ref field is missing");
+                blockPackRequests.push([
+                    info,
+                    tx.getResourceData(ensureResourceIdNotNull(refField.value), false),
+                ]);
             }
         }
         //
@@ -1172,7 +1171,7 @@ class ProjectMutator {
             ctxExportTplHolder = ensureResourceIdNotNull(ctxExportTplField.value);
         else {
             ctxExportTplHolder = Pl.wrapInHolder(tx, loadTemplate(tx, ctxExportTplEnvelope.spec));
-            tx.createField(field(rid, getServiceTemplateField(ctxExportTplEnvelope.hash)), 'Dynamic', ctxExportTplHolder);
+            tx.createField(field(rid, getServiceTemplateField(ctxExportTplEnvelope.hash)), "Dynamic", ctxExportTplHolder);
         }
         const renderingState = { stagingRefreshTimestamp };
         const blocksInLimboSet = new Set(blocksInLimbo);
@@ -1207,7 +1206,7 @@ async function createProject(tx, meta = InitialBlockMeta) {
     tx.setKValue(prj, ProjectStructureKey, JSON.stringify(InitialBlockStructure));
     tx.setKValue(prj, BlockRenderingStateKey, JSON.stringify(InitialProjectRenderingState));
     const ctxExportTplEnvelope = await getPreparedExportTemplateEnvelope();
-    tx.createField(field(prj, getServiceTemplateField(ctxExportTplEnvelope.hash)), 'Dynamic', Pl.wrapInHolder(tx, loadTemplate(tx, ctxExportTplEnvelope.spec)));
+    tx.createField(field(prj, getServiceTemplateField(ctxExportTplEnvelope.hash)), "Dynamic", Pl.wrapInHolder(tx, loadTemplate(tx, ctxExportTplEnvelope.spec)));
     return prj;
 }
 async function withProject(projectHelper, txOrPl, rid, cb, ops) {
@@ -1215,7 +1214,7 @@ async function withProject(projectHelper, txOrPl, rid, cb, ops) {
 }
 async function withProjectAuthored(projectHelper, txOrPl, rid, author, cb, ops = {}) {
     if (txOrPl instanceof PlClient) {
-        return await txOrPl.withWriteTx('ProjectAction' + (ops.name ? `: ${ops.name}` : ''), async (tx) => {
+        return await txOrPl.withWriteTx("ProjectAction" + (ops.name ? `: ${ops.name}` : ""), async (tx) => {
             const mut = await ProjectMutator.load(projectHelper, tx, rid, author);
             const result = await cb(mut);
             if (!mut.wasModified)