@milaboratories/pl-middle-layer 1.46.20 → 1.46.22

package/src/js_render/context.ts

@@ -1,18 +1,15 @@
-import type { ComputableCtx } from '@milaboratories/computable';
-import type {
-  BlockCodeKnownFeatureFlags } from '@platforma-sdk/model';
-import {
-  JsRenderInternal,
-} from '@platforma-sdk/model';
-import { notEmpty } from '@milaboratories/ts-helpers';
-import { randomUUID } from 'node:crypto';
-import type { QuickJSContext, QuickJSHandle } from 'quickjs-emscripten';
-import { Scope, errors } from 'quickjs-emscripten';
-import type { BlockContextAny } from '../middle_layer/block_ctx';
-import type { MiddleLayerEnvironment } from '../middle_layer/middle_layer';
-import { stringifyWithResourceId } from '@milaboratories/pl-client';
-import { PlQuickJSError } from '@milaboratories/pl-errors';
-import { ComputableContextHelper } from './computable_context';
+import type { ComputableCtx } from "@milaboratories/computable";
+import type { BlockCodeKnownFeatureFlags } from "@platforma-sdk/model";
+import { JsRenderInternal } from "@platforma-sdk/model";
+import { notEmpty } from "@milaboratories/ts-helpers";
+import { randomUUID } from "node:crypto";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import { Scope, errors } from "quickjs-emscripten";
+import type { BlockContextAny } from "../middle_layer/block_ctx";
+import type { MiddleLayerEnvironment } from "../middle_layer/middle_layer";
+import { stringifyWithResourceId } from "@milaboratories/pl-client";
+import { PlQuickJSError } from "@milaboratories/pl-errors";
+import { ComputableContextHelper } from "./computable_context";
 
 export type DeadlineSettings = {
   currentExecutionTarget: string;
@@ -70,28 +67,37 @@ export class JsExecutionContext {
     this.callbackRegistry = this.scope.manage(this.vm.newObject());
 
     this.fnJSONStringify = scope.manage(
-      vm.getProp(vm.global, 'JSON').consume((json) => vm.getProp(json, 'stringify')),
+      vm.getProp(vm.global, "JSON").consume((json) => vm.getProp(json, "stringify")),
     );
-    if (vm.typeof(this.fnJSONStringify) !== 'function')
+    if (vm.typeof(this.fnJSONStringify) !== "function")
       throw new Error(`JSON.stringify() not found.`);
 
     this.fnJSONParse = scope.manage(
-      vm.getProp(vm.global, 'JSON').consume((json) => vm.getProp(json, 'parse')),
+      vm.getProp(vm.global, "JSON").consume((json) => vm.getProp(json, "parse")),
     );
-    if (vm.typeof(this.fnJSONParse) !== 'function') throw new Error(`JSON.parse() not found.`);
+    if (vm.typeof(this.fnJSONParse) !== "function") throw new Error(`JSON.parse() not found.`);
 
     if (computableEnv !== undefined)
-      this.computableHelper = new ComputableContextHelper(this, computableEnv.blockCtx, computableEnv.mlEnv, featureFlags, computableEnv.computableCtx);
+      this.computableHelper = new ComputableContextHelper(
+        this,
+        computableEnv.blockCtx,
+        computableEnv.mlEnv,
+        featureFlags,
+        computableEnv.computableCtx,
+      );
 
     this.injectCtx();
   }
 
   public resetComputableCtx() {
-    notEmpty(this.computableHelper, 'Computable context helper is not initialized').resetComputableCtx();
+    notEmpty(
+      this.computableHelper,
+      "Computable context helper is not initialized",
+    ).resetComputableCtx();
   }
 
   private static cleanErrorContext(error: unknown): void {
-    if (typeof error === 'object' && error !== null && 'context' in error) delete error['context'];
+    if (typeof error === "object" && error !== null && "context" in error) delete error["context"];
   }
 
   // private static cleanError(error: unknown): unknown {
@@ -106,8 +112,11 @@ export class JsExecutionContext {
 
   public evaluateBundle(code: string) {
     try {
-      this.deadlineSetter({ currentExecutionTarget: 'evaluateBundle', deadline: Date.now() + 10000 });
-      this.vm.unwrapResult(this.vm.evalCode(code, 'bundle.js', { type: 'global' })).dispose();
+      this.deadlineSetter({
+        currentExecutionTarget: "evaluateBundle",
+        deadline: Date.now() + 10000,
+      });
+      this.vm.unwrapResult(this.vm.evalCode(code, "bundle.js", { type: "global" })).dispose();
     } catch (err: unknown) {
       JsExecutionContext.cleanErrorContext(err);
       throw err;
@@ -122,7 +131,7 @@ export class JsExecutionContext {
       return Scope.withScope((localScope) => {
         const targetCallback = localScope.manage(this.vm.getProp(this.callbackRegistry, cbName));
 
-        if (this.vm.typeof(targetCallback) !== 'function')
+        if (this.vm.typeof(targetCallback) !== "function")
           throw new Error(`No such callback: ${cbName}`);
 
         return this.scope.manage(
@@ -154,7 +163,9 @@ export class JsExecutionContext {
   ): QuickJSHandle {
     const result = this.tryExportSingleValue(obj, scope);
     if (result === undefined) {
-      throw new Error(`Can't export value: ${obj === undefined ? 'undefined' : JSON.stringify(obj)}`);
+      throw new Error(
+        `Can't export value: ${obj === undefined ? "undefined" : JSON.stringify(obj)}`,
+      );
     }
     return result;
   }
@@ -163,18 +174,18 @@ export class JsExecutionContext {
     let handle: QuickJSHandle;
     let manage = false;
     switch (typeof obj) {
-      case 'string':
+      case "string":
         handle = this.vm.newString(obj);
         manage = true;
         break;
-      case 'number':
+      case "number":
         handle = this.vm.newNumber(obj);
         manage = true;
         break;
-      case 'undefined':
+      case "undefined":
         handle = this.vm.undefined;
         break;
-      case 'boolean':
+      case "boolean":
         handle = obj ? this.vm.true : this.vm.false;
         break;
       default:
@@ -210,11 +221,11 @@ export class JsExecutionContext {
   public importObjectUniversal(handle: QuickJSHandle | undefined): unknown {
     if (handle === undefined) return undefined;
     switch (this.vm.typeof(handle)) {
-      case 'undefined':
+      case "undefined":
         return undefined;
-      case 'boolean':
-      case 'number':
-      case 'string':
+      case "boolean":
+      case "number":
+      case "string":
         return this.vm.dump(handle);
       default:
         return this.importObjectViaJson(handle);
@@ -225,7 +236,7 @@ export class JsExecutionContext {
     const text = this.vm
       .unwrapResult(this.vm.callFunction(this.fnJSONStringify, this.vm.undefined, handle))
       .consume((strHandle) => this.vm.getString(strHandle));
-    if (text === 'undefined')
+    if (text === "undefined")
       // special case with futures
       return undefined;
     return JSON.parse(text);
@@ -239,10 +250,10 @@ export class JsExecutionContext {
       // Core props
       //
 
-      this.vm.setProp(configCtx, 'callbackRegistry', this.callbackRegistry);
+      this.vm.setProp(configCtx, "callbackRegistry", this.callbackRegistry);
       this.vm.setProp(
         configCtx,
-        'featureFlags',
+        "featureFlags",
         this.exportObjectUniversal(JsRenderInternal.GlobalCfgRenderCtxFeatureFlags, localScope),
       );
 
@@ -255,7 +266,7 @@ export class JsExecutionContext {
       // Creating global variable inside the vm
       //
 
-      this.vm.setProp(this.vm.global, 'cfgRenderCtx', configCtx);
+      this.vm.setProp(this.vm.global, "cfgRenderCtx", configCtx);
     });
   }
 }
@@ -290,25 +301,42 @@ export class ErrorRepository {
   /** Returns the original error that was stored by parsing uuid of mimicrated error. */
   public getOriginal(quickJSError: unknown): unknown {
     if (!(quickJSError instanceof errors.QuickJSUnwrapError)) {
-      console.warn('ErrorRepo: quickJSError is not a QuickJSUnwrapError', stringifyWithResourceId(quickJSError));
+      console.warn(
+        "ErrorRepo: quickJSError is not a QuickJSUnwrapError",
+        stringifyWithResourceId(quickJSError),
+      );
       return quickJSError;
     }
 
     const cause = quickJSError.cause;
-    if (!(typeof cause === 'object' && cause !== null && ('name' in cause) && typeof cause.name === 'string')) {
-      console.warn('ErrorRepo: quickJSError.cause is not an Error (can be stack limit exceeded)', stringifyWithResourceId(quickJSError));
+    if (
+      !(
+        typeof cause === "object" &&
+        cause !== null &&
+        "name" in cause &&
+        typeof cause.name === "string"
+      )
+    ) {
+      console.warn(
+        "ErrorRepo: quickJSError.cause is not an Error (can be stack limit exceeded)",
+        stringifyWithResourceId(quickJSError),
+      );
       return quickJSError;
     }
 
     const causeName = cause.name;
-    const errorId = causeName.slice(causeName.indexOf('/uuid:') + '/uuid:'.length);
+    const errorId = causeName.slice(causeName.indexOf("/uuid:") + "/uuid:".length);
     if (!errorId) {
-      throw new Error(`ErrorRepo: quickJSError.cause.name does not contain errorId: ${causeName}, ${stringifyWithResourceId(quickJSError)}`);
+      throw new Error(
+        `ErrorRepo: quickJSError.cause.name does not contain errorId: ${causeName}, ${stringifyWithResourceId(quickJSError)}`,
+      );
     }
 
     const error = this.errorIdToError.get(errorId);
     if (error === undefined) {
-      throw new Error(`ErrorRepo: errorId not found: ${errorId}, ${stringifyWithResourceId(quickJSError)}`);
+      throw new Error(
+        `ErrorRepo: errorId not found: ${errorId}, ${stringifyWithResourceId(quickJSError)}`,
+      );
     }
 
     return new PlQuickJSError(quickJSError, error as Error);

package/src/js_render/index.ts

@@ -1,20 +1,30 @@
-import type { MiddleLayerEnvironment } from '../middle_layer/middle_layer';
-import type { BlockCodeWithInfo, ConfigRenderLambda } from '@platforma-sdk/model';
-import type { ComputableRenderingOps } from '@milaboratories/computable';
-import { Computable } from '@milaboratories/computable';
-import type { QuickJSWASMModule } from 'quickjs-emscripten';
-import { Scope } from 'quickjs-emscripten';
-import type { DeadlineSettings } from './context';
-import { JsExecutionContext } from './context';
-import type { BlockContextAny } from '../middle_layer/block_ctx';
-import { getDebugFlags } from '../debug';
-
-function logOutputStatus(handle: string, renderedResult: unknown, stable: boolean, recalculationCounter: number, unstableMarker?: string) {
-  if (getDebugFlags().logOutputStatus && (getDebugFlags().logOutputStatus === 'any' || !stable)) {
+import type { MiddleLayerEnvironment } from "../middle_layer/middle_layer";
+import type { BlockCodeWithInfo, ConfigRenderLambda } from "@platforma-sdk/model";
+import type { ComputableRenderingOps } from "@milaboratories/computable";
+import { Computable } from "@milaboratories/computable";
+import type { QuickJSWASMModule } from "quickjs-emscripten";
+import { Scope } from "quickjs-emscripten";
+import type { DeadlineSettings } from "./context";
+import { JsExecutionContext } from "./context";
+import type { BlockContextAny } from "../middle_layer/block_ctx";
+import { getDebugFlags } from "../debug";
+
+function logOutputStatus(
+  handle: string,
+  renderedResult: unknown,
+  stable: boolean,
+  recalculationCounter: number,
+  unstableMarker?: string,
+) {
+  if (getDebugFlags().logOutputStatus && (getDebugFlags().logOutputStatus === "any" || !stable)) {
     if (stable)
-      console.log(`Stable output ${handle} calculated ${renderedResult !== undefined ? 'defined' : 'undefined'}; (#${recalculationCounter})`);
+      console.log(
+        `Stable output ${handle} calculated ${renderedResult !== undefined ? "defined" : "undefined"}; (#${recalculationCounter})`,
+      );
     else
-      console.log(`Unstable output ${handle}; marker = ${unstableMarker}; ${renderedResult !== undefined ? 'defined' : 'undefined'} (#${recalculationCounter})`);
+      console.log(
+        `Unstable output ${handle}; marker = ${unstableMarker}; ${renderedResult !== undefined ? "defined" : "undefined"} (#${recalculationCounter})`,
+      );
   }
 }
 
@@ -77,12 +87,14 @@ export function computableFromRF(
   // adding configKey to reload all outputs on block-pack update
   const key = `${ctx.blockId}#lambda#${configKey}#${fh.handle}`;
   ops = { ...ops, key };
-  if (ops.mode === undefined && fh.retentive === true) ops.mode = 'StableOnlyRetentive';
+  if (ops.mode === undefined && fh.retentive === true) ops.mode = "StableOnlyRetentive";
   return Computable.makeRaw((cCtx) => {
     const { code, featureFlags } = codeWithInfo;
 
     if (getDebugFlags().logOutputRecalculations)
-      console.log(`Block lambda recalculation : ${key} (${cCtx.changeSourceMarker}; ${cCtx.bodyInvocations} invocations)`);
+      console.log(
+        `Block lambda recalculation : ${key} (${cCtx.changeSourceMarker}; ${cCtx.bodyInvocations} invocations)`,
+      );
 
     const scope = new Scope();
     let keepVmAlive = false;
@@ -104,10 +116,15 @@ export function computableFromRF(
         return false;
       });
       const vm = scope.manage(runtime.newContext());
-      const rCtx = new JsExecutionContext(scope, vm,
-        (s) => { deadlineSettings = s; },
+      const rCtx = new JsExecutionContext(
+        scope,
+        vm,
+        (s) => {
+          deadlineSettings = s;
+        },
         featureFlags,
-        { computableCtx: cCtx, blockCtx: ctx, mlEnv: env });
+        { computableCtx: cCtx, blockCtx: ctx, mlEnv: env },
+      );
 
       rCtx.evaluateBundle(code.content);
       const result = rCtx.runCallback(fh.handle);
@@ -118,7 +135,13 @@ export function computableFromRF(
 
       if (Object.keys(toBeResolved).length === 0) {
         const importedResult = rCtx.importObjectUniversal(result);
-        logOutputStatus(fh.handle, importedResult, cCtx.unstableMarker === undefined, -1, cCtx.unstableMarker);
+        logOutputStatus(
+          fh.handle,
+          importedResult,
+          cCtx.unstableMarker === undefined,
+          -1,
+          cCtx.unstableMarker,
+        );
         return { ir: importedResult };
       }
 
@@ -130,7 +153,7 @@ export function computableFromRF(
       return {
         ir: toBeResolved,
         postprocessValue: (resolved: Record<string, unknown>, { unstableMarker, stable }) => {
-        // resolving futures
+          // resolving futures
           for (const [handle, value] of Object.entries(resolved)) rCtx.runCallback(handle, value);
 
           // rendering result
@@ -172,8 +195,12 @@ export function executeSingleLambda(
       return false;
     });
     const vm = scope.manage(runtime.newContext());
-    const rCtx = new JsExecutionContext(scope, vm,
-      (s) => { deadlineSettings = s; },
+    const rCtx = new JsExecutionContext(
+      scope,
+      vm,
+      (s) => {
+        deadlineSettings = s;
+      },
       featureFlags,
     );
 

package/src/middle_layer/active_cfg.ts

@@ -1,14 +1,14 @@
-import { notEmpty } from '@milaboratories/ts-helpers';
-import type { PlTreeEntry } from '@milaboratories/pl-tree';
-import type { MiddleLayerEnvironment } from './middle_layer';
-import { Computable } from '@milaboratories/computable';
-import type { ProjectStructure } from '../model/project_model';
-import { ProjectStructureKey } from '../model/project_model';
-import { allBlocks } from '../model/project_model_util';
-import { constructBlockContext } from './block_ctx';
-import { computableFromCfgOrRF, isActive } from './render';
-import { getBlockPackInfo } from './util';
-import { extractCodeWithInfo, wrapCallback } from '@platforma-sdk/model';
+import { notEmpty } from "@milaboratories/ts-helpers";
+import type { PlTreeEntry } from "@milaboratories/pl-tree";
+import type { MiddleLayerEnvironment } from "./middle_layer";
+import { Computable } from "@milaboratories/computable";
+import type { ProjectStructure } from "../model/project_model";
+import { ProjectStructureKey } from "../model/project_model";
+import { allBlocks } from "../model/project_model_util";
+import { constructBlockContext } from "./block_ctx";
+import { computableFromCfgOrRF, isActive } from "./render";
+import { getBlockPackInfo } from "./util";
+import { extractCodeWithInfo, wrapCallback } from "@platforma-sdk/model";
 
 /** Returns derived general project state form the project resource */
 export function activeConfigs(
@@ -38,7 +38,9 @@ export function activeConfigs(
 
       for (const cfg of activeOutputConfigs) {
         ret.push(
-          Computable.wrapError(computableFromCfgOrRF(env, blockCtx, cfg, codeWithInfoOrError.value, bp.bpId)),
+          Computable.wrapError(
+            computableFromCfgOrRF(env, blockCtx, cfg, codeWithInfoOrError.value, bp.bpId),
+          ),
         );
       }
     }

package/src/middle_layer/block.ts

@@ -1,34 +1,32 @@
-import type { PlTreeEntry } from '@milaboratories/pl-tree';
+import type { PlTreeEntry } from "@milaboratories/pl-tree";
 import type {
   ComputableCtx,
   ComputableStableDefined,
   ComputableValueOrErrors,
-} from '@milaboratories/computable';
-import {
-  Computable,
-} from '@milaboratories/computable';
-import { constructBlockContext, constructBlockContextArgsOnly } from './block_ctx';
-import { blockArgsAuthorKey } from '../model/project_model';
-import { ifNotUndef } from '../cfg_render/util';
-import type { MiddleLayerEnvironment } from './middle_layer';
-import { getBlockPackInfo } from './util';
-import type { AuthorMarker, BlockStateInternalV3 } from '@milaboratories/pl-model-middle-layer';
-import { computableFromCfgOrRF } from './render';
-import { resourceIdToString } from '@milaboratories/pl-client';
-import { deepFreeze } from '@milaboratories/ts-helpers';
-import { extractCodeWithInfo } from '@platforma-sdk/model';
-import { getDebugFlags } from '../debug';
+} from "@milaboratories/computable";
+import { Computable } from "@milaboratories/computable";
+import { constructBlockContext, constructBlockContextArgsOnly } from "./block_ctx";
+import { blockArgsAuthorKey } from "../model/project_model";
+import { ifNotUndef } from "../cfg_render/util";
+import type { MiddleLayerEnvironment } from "./middle_layer";
+import { getBlockPackInfo } from "./util";
+import type { AuthorMarker, BlockStateInternalV3 } from "@milaboratories/pl-model-middle-layer";
+import { computableFromCfgOrRF } from "./render";
+import { resourceIdToString } from "@milaboratories/pl-client";
+import { deepFreeze } from "@milaboratories/ts-helpers";
+import { extractCodeWithInfo } from "@platforma-sdk/model";
+import { getDebugFlags } from "../debug";
 
-export type BlockParameters = Omit<BlockStateInternalV3, 'outputs' | 'navigationState'>;
+export type BlockParameters = Omit<BlockStateInternalV3, "outputs" | "navigationState">;
 
 export function getBlockParameters(
   projectEntry: PlTreeEntry,
-  blockId: string
+  blockId: string,
 ): Computable<BlockParameters>;
 export function getBlockParameters(
   projectEntry: PlTreeEntry,
   blockId: string,
-  cCtx: ComputableCtx
+  cCtx: ComputableCtx,
 ): BlockParameters;
 export function getBlockParameters(
   projectEntry: PlTreeEntry,
@@ -44,7 +42,8 @@ export function getBlockParameters(
   const ctx = constructBlockContextArgsOnly(projectEntry, blockId);
   const blockStorageJson = ctx.blockStorage(cCtx);
   // Parse raw storage JSON - UI will derive data using sdk/model
-  const blockStorage = blockStorageJson !== undefined ? deepFreeze(JSON.parse(blockStorageJson)) : undefined;
+  const blockStorage =
+    blockStorageJson !== undefined ? deepFreeze(JSON.parse(blockStorageJson)) : undefined;
   return {
     author: prj.getKeyValueAsJson<AuthorMarker>(blockArgsAuthorKey(blockId)),
     blockStorage,
@@ -56,11 +55,13 @@ export function blockOutputs(
   blockId: string,
   env: MiddleLayerEnvironment,
 ): ComputableStableDefined<Record<string, ComputableValueOrErrors<unknown>>> {
-  const key = 'outputs#' + resourceIdToString(projectEntry.rid) + '#' + blockId;
+  const key = "outputs#" + resourceIdToString(projectEntry.rid) + "#" + blockId;
   return Computable.make(
     (c) => {
       if (getDebugFlags().logOutputRecalculations) {
-        console.log(`blockOutput recalculation : ${key} (${c.changeSourceMarker}; ${c.bodyInvocations} invocations)`);
+        console.log(
+          `blockOutput recalculation : ${key} (${c.changeSourceMarker}; ${c.bodyInvocations} invocations)`,
+        );
       }
 
       const prj = c.accessor(projectEntry).node();
@@ -69,7 +70,13 @@ export function blockOutputs(
       return ifNotUndef(getBlockPackInfo(prj, blockId), ({ cfg, bpId }) => {
         const outputs: Record<string, Computable<any>> = {};
         for (const [cellId, cellCfg] of Object.entries(cfg.outputs)) {
-          const computableOutput = computableFromCfgOrRF(env, ctx, cellCfg, extractCodeWithInfo(cfg), bpId);
+          const computableOutput = computableFromCfgOrRF(
+            env,
+            ctx,
+            cellCfg,
+            extractCodeWithInfo(cfg),
+            bpId,
+          );
           outputs[cellId] = Computable.wrapError(computableOutput, 1);
         }
         return outputs;

package/src/middle_layer/block_ctx.ts

@@ -1,17 +1,12 @@
-import type { ComputableCtx } from '@milaboratories/computable';
-import type { PlTreeEntry } from '@milaboratories/pl-tree';
-import { cachedDecode, notEmpty } from '@milaboratories/ts-helpers';
-import type { Optional } from 'utility-types';
-import type {
-  Block,
-  ProjectStructure } from '../model/project_model';
-import {
-  ProjectStructureKey,
-  projectFieldName,
-} from '../model/project_model';
-import { allBlocks } from '../model/project_model_util';
-import { ResultPool } from '../pool/result_pool';
-import { deriveDataFromStorage } from '@platforma-sdk/model';
+import type { ComputableCtx } from "@milaboratories/computable";
+import type { PlTreeEntry } from "@milaboratories/pl-tree";
+import { cachedDecode, notEmpty } from "@milaboratories/ts-helpers";
+import type { Optional } from "utility-types";
+import type { Block, ProjectStructure } from "../model/project_model";
+import { ProjectStructureKey, projectFieldName } from "../model/project_model";
+import { allBlocks } from "../model/project_model_util";
+import { ResultPool } from "../pool/result_pool";
+import { deriveDataFromStorage } from "@platforma-sdk/model";
 
 export type BlockContextArgsOnly = {
   readonly blockId: string;
@@ -29,7 +24,7 @@ export type BlockContextFull = BlockContextArgsOnly & {
   readonly getResultsPool: (cCtx: ComputableCtx) => ResultPool;
 };
 
-export type BlockContextAny = Optional<BlockContextFull, 'prod' | 'staging' | 'getResultsPool'>;
+export type BlockContextAny = Optional<BlockContextFull, "prod" | "staging" | "getResultsPool">;
 
 export function constructBlockContextArgsOnly(
   projectEntry: PlTreeEntry,
@@ -40,7 +35,7 @@ export function constructBlockContextArgsOnly(
       .accessor(projectEntry)
       .node()
       .traverse({
-        field: projectFieldName(blockId, 'currentArgs'),
+        field: projectFieldName(blockId, "currentArgs"),
         stableIfNotFound: true,
       })
       ?.getData();
@@ -51,7 +46,7 @@ export function constructBlockContextArgsOnly(
       .accessor(projectEntry)
       .node()
       .traverse({
-        field: projectFieldName(blockId, 'prodArgs'),
+        field: projectFieldName(blockId, "prodArgs"),
         stableIfNotFound: true,
       })
       ?.getData();
@@ -62,7 +57,7 @@ export function constructBlockContextArgsOnly(
       .accessor(projectEntry)
       .node()
       .traverse({
-        field: projectFieldName(blockId, 'blockStorage'),
+        field: projectFieldName(blockId, "blockStorage"),
         stableIfNotFound: true,
       })
       ?.getData();
@@ -76,7 +71,7 @@ export function constructBlockContextArgsOnly(
       const parsed = JSON.parse(rawJson);
       return JSON.stringify(deriveDataFromStorage(parsed));
     } catch (err) {
-      console.error('Error deriving data from storage', err);
+      console.error("Error deriving data from storage", err);
       return undefined;
     }
   };
@@ -86,7 +81,7 @@ export function constructBlockContextArgsOnly(
       .accessor(projectEntry)
       .node()
       .traverse({
-        field: projectFieldName(blockId, 'blockStorage'),
+        field: projectFieldName(blockId, "blockStorage"),
         stableIfNotFound: true,
       })
       ?.getData();
@@ -98,7 +93,7 @@ export function constructBlockContextArgsOnly(
       .accessor(projectEntry)
       .node()
       .traverse({
-        field: projectFieldName(blockId, 'currentPrerunArgs'),
+        field: projectFieldName(blockId, "currentPrerunArgs"),
         stableIfNotFound: true,
       })
       ?.getData();
@@ -132,7 +127,7 @@ export function constructBlockContext(
         .accessor(projectEntry)
         .node({ ignoreError: true })
         .traverse({
-          field: projectFieldName(blockId, 'prodOutput'),
+          field: projectFieldName(blockId, "prodOutput"),
           stableIfNotFound: true,
           ignoreError: true,
         })
@@ -141,20 +136,21 @@ export function constructBlockContext(
     staging: (cCtx: ComputableCtx) => {
       // Check if staging is expected (currentPrerunArgs is set)
       // For blocks with failed args derivation, staging will never be rendered
-      const hasPrerunArgs = cCtx
-        .accessor(projectEntry)
-        .node({ ignoreError: true })
-        .traverse({
-          field: projectFieldName(blockId, 'currentPrerunArgs'),
-          stableIfNotFound: true,
-          ignoreError: true,
-        }) !== undefined;
+      const hasPrerunArgs =
+        cCtx
+          .accessor(projectEntry)
+          .node({ ignoreError: true })
+          .traverse({
+            field: projectFieldName(blockId, "currentPrerunArgs"),
+            stableIfNotFound: true,
+            ignoreError: true,
+          }) !== undefined;
 
       const result = cCtx
         .accessor(projectEntry)
         .node({ ignoreError: true })
         .traverse({
-          field: projectFieldName(blockId, 'stagingOutput'),
+          field: projectFieldName(blockId, "stagingOutput"),
           // Only mark stable if staging is NOT expected (no prerunArgs)
           stableIfNotFound: !hasPrerunArgs,
           ignoreError: true,

package/src/middle_layer/block_ctx_unsafe.ts

@@ -1,10 +1,10 @@
-import type { ComputableCtx } from '@milaboratories/computable';
-import type { PlTreeEntry } from '@milaboratories/pl-tree';
-import type { PlResourceEntry, StdCtx } from '@platforma-sdk/model';
-import type { BlockContextAny } from './block_ctx';
+import type { ComputableCtx } from "@milaboratories/computable";
+import type { PlTreeEntry } from "@milaboratories/pl-tree";
+import type { PlResourceEntry, StdCtx } from "@platforma-sdk/model";
+import type { BlockContextAny } from "./block_ctx";
 
 type SC = StdCtx<unknown, unknown>;
-type SCAO = Pick<SC, '$blockId' | '$ui' | '$args' | '$data'>;
+type SCAO = Pick<SC, "$blockId" | "$ui" | "$args" | "$data">;
 export type MatStdCtxArgsOnly = {
   [Var in keyof SCAO]: SCAO[Var] extends PlResourceEntry
     ? PlTreeEntry | ((cCtx: ComputableCtx) => PlTreeEntry | undefined) | undefined
@@ -16,22 +16,22 @@ export type MatStdCtx = {
     : SC[Var];
 };
 
-export const NonKeyCtxFields = ['$prod', '$staging'];
+export const NonKeyCtxFields = ["$prod", "$staging"];
 
 export function toCfgContext(ctx: BlockContextAny): MatStdCtx {
   return {
     $blockId: ctx.blockId,
     $args: (cCtx: ComputableCtx) => {
       const args = ctx.args(cCtx);
-      return args !== undefined ? JSON.parse(args) as unknown : undefined;
+      return args !== undefined ? (JSON.parse(args) as unknown) : undefined;
     },
     $ui: (cCtx: ComputableCtx) => {
       const data = ctx.data(cCtx);
-      return data !== undefined ? JSON.parse(data) as unknown : undefined;
+      return data !== undefined ? (JSON.parse(data) as unknown) : undefined;
     },
     $data: (cCtx: ComputableCtx) => {
       const data = ctx.data(cCtx);
-      return data !== undefined ? JSON.parse(data) as unknown : undefined;
+      return data !== undefined ? (JSON.parse(data) as unknown) : undefined;
     },
     $prod: ctx.prod,
     $staging: ctx.staging,