@milaboratories/pl-middle-layer 1.48.11 → 1.48.13

package/dist/cfg_render/executor.js

@@ -1,156 +1,154 @@
-import Denque from 'denque';
-import { assertNever, notEmpty } from '@milaboratories/ts-helpers';
-import { Computable } from '@milaboratories/computable';
-import { renderCfg, resOp } from './renderer.js';
-import canonicalize from 'canonicalize';
-import { toCfgContext, NonKeyCtxFields } from '../middle_layer/block_ctx_unsafe.js';
+import { renderCfg, resOp } from "./renderer.js";
+import { NonKeyCtxFields, toCfgContext } from "../middle_layer/block_ctx_unsafe.js";
+import { assertNever, notEmpty } from "@milaboratories/ts-helpers";
+import { Computable } from "@milaboratories/computable";
+import Denque from "denque";
+import canonicalize from "canonicalize";
 
+//#region src/cfg_render/executor.ts
 /** Special address of operation, see below. */
 const ReturnOpKey = Symbol();
 /** The same, but for the argument part of destination, see below. */
 const ReturnArgKey = "return";
 /** Special destination, telling the executor that corresponding result should
- * be exposed as a final result, and execution terminate at this point. */
-const ReturnDestination = { op: ReturnOpKey, arg: ReturnArgKey };
+* be exposed as a final result, and execution terminate at this point. */
+const ReturnDestination = {
+	op: ReturnOpKey,
+	arg: ReturnArgKey
+};
 function isReturnDestination(destination) {
-    return destination.op == ReturnOpKey && destination.arg == ReturnArgKey;
+	return destination.op == ReturnOpKey && destination.arg == ReturnArgKey;
 }
 /** Returns initial stack value. */
 function zeroStack() {
-    return { pendingSubroutines: new Map() };
+	return { pendingSubroutines: /* @__PURE__ */ new Map() };
 }
 /** Implements main executor mechanism.
- * @param env to be passed to while executing operations
- * @param stack execution stack to continue execution from
- * @param operations operations to initiate the execution process
- * @param allowComputables if false, scheduling of async computables will result in error
- * */
+* @param env to be passed to while executing operations
+* @param stack execution stack to continue execution from
+* @param operations operations to initiate the execution process
+* @param allowComputables if false, scheduling of async computables will result in error
+* */
 function execute(env, stack, operations, allowComputables) {
-    const operationQueue = new Denque(operations);
-    /** Returns false if final result is set as result of this operation,
-     * true if we should continue processing. */
-    const deliverResult = (destination, result) => {
-        if (isReturnDestination(destination)) {
-            stack.result = result;
-            return false;
-        }
-        const pending = notEmpty(stack.pendingSubroutines.get(destination.op));
-        if (destination.arg in pending.args)
-            throw new Error("argument already set");
-        pending.args[destination.arg] = result;
-        pending.argCounter--;
-        if (pending.argCounter === 0) {
-            stack.pendingSubroutines.delete(destination.op);
-            operationQueue.push({
-                destination: pending.destination,
-                operation: pending.subroutine(pending.args),
-            });
-        }
-        return true;
-    };
-    // computables, scheduled during computation, are aggregated in this array,
-    // and returned from the function in the end
-    const computables = [];
-    // each loop = execution of a single queued operation
-    mainLoop: while (operationQueue.length > 0) {
-        const op = operationQueue.shift();
-        const action = op.operation(env);
-        switch (action.type) {
-            case "ReturnResult":
-                if (!deliverResult(op.destination, action.result))
-                    break mainLoop; // this terminates execution
-                break; // switch
-            case "ScheduleSubroutine":
-                {
-                    const newOpKey = Symbol();
-                    const argRequests = Object.entries(action.args);
-                    const initialArgCounter = argRequests.length;
-                    if (initialArgCounter === 0)
-                        // if no pending arguments
-                        operationQueue.push({
-                            destination: op.destination,
-                            operation: action.subroutine({}),
-                        });
-                    else {
-                        for (const [arg, operation] of argRequests)
-                            operationQueue.push({
-                                destination: { op: newOpKey, arg },
-                                operation,
-                            });
-                        stack.pendingSubroutines.set(newOpKey, {
-                            argCounter: initialArgCounter,
-                            args: {},
-                            subroutine: action.subroutine,
-                            destination: op.destination,
-                        });
-                    }
-                }
-                break;
-            case "ScheduleComputable":
-                if (!allowComputables)
-                    throw new Error("asynchronous operations are forbidden in this context");
-                computables.push({
-                    destination: op.destination,
-                    computable: action.computable,
-                });
-                break;
-            default:
-                assertNever(action);
-        }
-    }
-    return computables;
+	const operationQueue = new Denque(operations);
+	/** Returns false if final result is set as result of this operation,
+	* true if we should continue processing. */
+	const deliverResult = (destination, result) => {
+		if (isReturnDestination(destination)) {
+			stack.result = result;
+			return false;
+		}
+		const pending = notEmpty(stack.pendingSubroutines.get(destination.op));
+		if (destination.arg in pending.args) throw new Error("argument already set");
+		pending.args[destination.arg] = result;
+		pending.argCounter--;
+		if (pending.argCounter === 0) {
+			stack.pendingSubroutines.delete(destination.op);
+			operationQueue.push({
+				destination: pending.destination,
+				operation: pending.subroutine(pending.args)
+			});
+		}
+		return true;
+	};
+	const computables = [];
+	mainLoop: while (operationQueue.length > 0) {
+		const op = operationQueue.shift();
+		const action = op.operation(env);
+		switch (action.type) {
+			case "ReturnResult":
+				if (!deliverResult(op.destination, action.result)) break mainLoop;
+				break;
+			case "ScheduleSubroutine":
+				{
+					const newOpKey = Symbol();
+					const argRequests = Object.entries(action.args);
+					const initialArgCounter = argRequests.length;
+					if (initialArgCounter === 0) operationQueue.push({
+						destination: op.destination,
+						operation: action.subroutine({})
+					});
+					else {
+						for (const [arg, operation] of argRequests) operationQueue.push({
+							destination: {
+								op: newOpKey,
+								arg
+							},
+							operation
+						});
+						stack.pendingSubroutines.set(newOpKey, {
+							argCounter: initialArgCounter,
+							args: {},
+							subroutine: action.subroutine,
+							destination: op.destination
+						});
+					}
+				}
+				break;
+			case "ScheduleComputable":
+				if (!allowComputables) throw new Error("asynchronous operations are forbidden in this context");
+				computables.push({
+					destination: op.destination,
+					computable: action.computable
+				});
+				break;
+			default: assertNever(action);
+		}
+	}
+	return computables;
 }
-//
-// Computable
-//
 /** Main method to render configurations */
 function computableFromCfg(drivers, bCtx, cfg, ops = {}) {
-    return computableFromCfgUnsafe(drivers, toCfgContext(bCtx), cfg, ops);
+	return computableFromCfgUnsafe(drivers, toCfgContext(bCtx), cfg, ops);
 }
 function computableFromCfgUnsafe(drivers, ctx, cfg, ops = {}) {
-    const key = `${ctx.blockId}#` +
-        canonicalize({
-            ctx: Object.fromEntries(Object.entries(ctx).filter(([k]) => NonKeyCtxFields.indexOf(k) === -1)),
-            cfg: cfg,
-        });
-    return Computable.makeRaw((c) => {
-        const env = { drivers, cCtx: c };
-        const stack = zeroStack();
-        const computables = execute(env, stack, [
-            {
-                destination: ReturnDestination,
-                operation: renderCfg(ctx, cfg),
-            },
-        ], true);
-        return {
-            ir: computables,
-            postprocessValue(value) {
-                const resolvedOps = [];
-                for (const mc of value)
-                    resolvedOps.push({ destination: mc.destination, operation: resOp(mc.computable) });
-                const postEnv = {
-                    drivers,
-                    get cCtx() {
-                        throw new Error("asynchronous operations are forbidden in this context");
-                    },
-                };
-                // Post process can be called several times, that's why it must be a side-effect-free function.
-                // But `execute` modifies a stack, so we have to defensively copy it here.
-                const copyOfPendingSubrotines = new Map();
-                for (const [key, value] of stack.pendingSubroutines)
-                    copyOfPendingSubrotines.set(key, { ...value, args: { ...value.args } });
-                const copiedStack = {
-                    result: stack.result,
-                    pendingSubroutines: copyOfPendingSubrotines,
-                };
-                execute(postEnv, copiedStack, resolvedOps, false);
-                if (!("result" in copiedStack))
-                    throw new Error("illegal cfg rendering stack state, no result");
-                return copiedStack.result;
-            },
-        };
-    }, { ...ops, key });
+	const key = `${ctx.blockId}#` + canonicalize({
+		ctx: Object.fromEntries(Object.entries(ctx).filter(([k]) => NonKeyCtxFields.indexOf(k) === -1)),
+		cfg
+	});
+	return Computable.makeRaw((c) => {
+		const env = {
+			drivers,
+			cCtx: c
+		};
+		const stack = zeroStack();
+		return {
+			ir: execute(env, stack, [{
+				destination: ReturnDestination,
+				operation: renderCfg(ctx, cfg)
+			}], true),
+			postprocessValue(value) {
+				const resolvedOps = [];
+				for (const mc of value) resolvedOps.push({
+					destination: mc.destination,
+					operation: resOp(mc.computable)
+				});
+				const postEnv = {
+					drivers,
+					get cCtx() {
+						throw new Error("asynchronous operations are forbidden in this context");
+					}
+				};
+				const copyOfPendingSubrotines = /* @__PURE__ */ new Map();
+				for (const [key, value] of stack.pendingSubroutines) copyOfPendingSubrotines.set(key, {
+					...value,
+					args: { ...value.args }
+				});
+				const copiedStack = {
+					result: stack.result,
+					pendingSubroutines: copyOfPendingSubrotines
+				};
+				execute(postEnv, copiedStack, resolvedOps, false);
+				if (!("result" in copiedStack)) throw new Error("illegal cfg rendering stack state, no result");
+				return copiedStack.result;
+			}
+		};
+	}, {
+		...ops,
+		key
+	});
 }
 
+//#endregion
 export { computableFromCfg, computableFromCfgUnsafe };
-//# sourceMappingURL=executor.js.map
+//# sourceMappingURL=executor.js.map

package/dist/cfg_render/executor.js.map

@@ -1 +1 @@
-{"version":3,"file":"executor.js","sources":["../../src/cfg_render/executor.ts"],"sourcesContent":["import type {\n  ArgumentKey,\n  ArgumentValues,\n  ExecutionEnvironment,\n  Operation,\n  Subroutine,\n} from \"./operation\";\nimport Denque from \"denque\";\nimport { assertNever, notEmpty } from \"@milaboratories/ts-helpers\";\nimport type { ComputableCtx, ComputableRenderingOps } from \"@milaboratories/computable\";\nimport { Computable } from \"@milaboratories/computable\";\nimport type { Cfg } from \"@platforma-sdk/model\";\nimport { renderCfg, resOp } from \"./renderer\";\nimport canonicalize from \"canonicalize\";\nimport type { BlockContextAny } from \"../middle_layer/block_ctx\";\nimport type { MiddleLayerDriverKit } from \"../middle_layer/driver_kit\";\nimport { NonKeyCtxFields, toCfgContext } from \"../middle_layer/block_ctx_unsafe\";\n\n/** Addresses pending subroutines inside the stack */\ntype SubroutineKey = symbol;\n\n/** Represents destination of the result of an operation. I.e. when sequence of\n * subroutine invocations, and computables terminates with result, this object\n * determines to which argument of which pending subroutine it should be delivered.\n * See special value for delivery of the final \"return\" result. */\ntype Destination = {\n  op: SubroutineKey;\n  arg: ArgumentKey;\n};\n\n/** Special address of operation, see below. */\nconst ReturnOpKey: unique symbol = Symbol();\n/** The same, but for the argument part of destination, see below. */\nconst ReturnArgKey = \"return\";\n\n/** Special destination, telling the executor that corresponding result should\n * be exposed as a final result, and execution terminate at this point. */\nconst ReturnDestination = { op: ReturnOpKey, arg: ReturnArgKey } as Destination;\n\nfunction isReturnDestination(destination: Destination): boolean {\n  return destination.op == ReturnOpKey && destination.arg == ReturnArgKey;\n}\n\n/** Queued operation, used inside the executor */\ntype QueuedOperation = {\n  operation: Operation;\n  destination: Destination;\n};\n\n/** Queued computation, returned by the first round of config execution. Such\n * computables should be returned in the intermediate representation of the\n * enclosing computable, and after they are resolved and passed to the\n * postprocessing routine, should be injected into the execution stack to\n * finalize the computation. */\ntype ScheduledComputable = {\n  destination: Destination;\n  computable: Computable<unknown>;\n};\n\n/** This is what ScheduledComputable transforms from intermediate\n * representation to post-processing. */\ntype MaterializedComputable = {\n  destination: Destination;\n  computable: unknown;\n};\n\n/** Main entry inside the execution stack. */\ntype PendingSubroutine = {\n  subroutine: Subroutine;\n  destination: Destination;\n  argCounter: number;\n  args: ArgumentValues;\n};\n\n/** Execution stack. The closest concept that this object along with enclosed\n * {@link PendingSubroutine}s represent is a Continuation.\n * https://en.wikipedia.org/wiki/Continuation */\ntype ExecutionStack = {\n  result?: unknown;\n  pendingSubroutines: Map<SubroutineKey, PendingSubroutine>;\n};\n\n/** Returns initial stack value. */\nfunction zeroStack(): ExecutionStack {\n  return { pendingSubroutines: new Map<SubroutineKey, PendingSubroutine>() };\n}\n\n/** Implements main executor mechanism.\n * @param env to be passed to while executing operations\n * @param stack execution stack to continue execution from\n * @param operations operations to initiate the execution process\n * @param allowComputables if false, scheduling of async computables will result in error\n * */\nfunction execute(\n  env: ExecutionEnvironment,\n  stack: ExecutionStack,\n  operations: QueuedOperation[],\n  allowComputables: boolean,\n): ScheduledComputable[] {\n  const operationQueue = new Denque<QueuedOperation>(operations);\n\n  /** Returns false if final result is set as result of this operation,\n   * true if we should continue processing. */\n  const deliverResult = (destination: Destination, result: unknown): boolean => {\n    if (isReturnDestination(destination)) {\n      stack.result = result;\n      return false;\n    }\n\n    const pending = notEmpty(stack.pendingSubroutines.get(destination.op));\n    if (destination.arg in pending.args) throw new Error(\"argument already set\");\n    pending.args[destination.arg] = result;\n    pending.argCounter--;\n    if (pending.argCounter === 0) {\n      stack.pendingSubroutines.delete(destination.op);\n      operationQueue.push({\n        destination: pending.destination,\n        operation: pending.subroutine(pending.args),\n      });\n    }\n\n    return true;\n  };\n\n  // computables, scheduled during computation, are aggregated in this array,\n  // and returned from the function in the end\n  const computables: ScheduledComputable[] = [];\n\n  // each loop = execution of a single queued operation\n  mainLoop: while (operationQueue.length > 0) {\n    const op = operationQueue.shift()!;\n    const action = op.operation(env);\n    switch (action.type) {\n      case \"ReturnResult\":\n        if (!deliverResult(op.destination, action.result)) break mainLoop; // this terminates execution\n        break; // switch\n\n      case \"ScheduleSubroutine\":\n        {\n          const newOpKey = Symbol();\n\n          const argRequests = Object.entries(action.args);\n          const initialArgCounter = argRequests.length;\n\n          if (initialArgCounter === 0)\n            // if no pending arguments\n            operationQueue.push({\n              destination: op.destination,\n              operation: action.subroutine({}),\n            });\n          else {\n            for (const [arg, operation] of argRequests)\n              operationQueue.push({\n                destination: { op: newOpKey, arg },\n                operation,\n              });\n\n            stack.pendingSubroutines.set(newOpKey, {\n              argCounter: initialArgCounter,\n              args: {},\n              subroutine: action.subroutine,\n              destination: op.destination,\n            });\n          }\n        }\n        break;\n\n      case \"ScheduleComputable\":\n        if (!allowComputables)\n          throw new Error(\"asynchronous operations are forbidden in this context\");\n        computables.push({\n          destination: op.destination,\n          computable: action.computable,\n        });\n        break;\n\n      default:\n        assertNever(action);\n    }\n  }\n\n  return computables;\n}\n\n//\n// Computable\n//\n\n/** Main method to render configurations */\nexport function computableFromCfg(\n  drivers: MiddleLayerDriverKit,\n  bCtx: BlockContextAny,\n  cfg: Cfg,\n  ops: Partial<ComputableRenderingOps> = {},\n): Computable<unknown> {\n  return computableFromCfgUnsafe(drivers, toCfgContext(bCtx), cfg, ops);\n}\n\nexport function computableFromCfgUnsafe(\n  drivers: MiddleLayerDriverKit,\n  ctx: Record<string, unknown>,\n  cfg: Cfg,\n  ops: Partial<ComputableRenderingOps> = {},\n): Computable<unknown> {\n  const key =\n    `${ctx.blockId}#` +\n    canonicalize({\n      ctx: Object.fromEntries(\n        Object.entries(ctx).filter(([k]) => NonKeyCtxFields.indexOf(k) === -1),\n      ),\n      cfg: cfg,\n    })!;\n  return Computable.makeRaw(\n    (c) => {\n      const env: ExecutionEnvironment = { drivers, cCtx: c };\n      const stack = zeroStack();\n      const computables = execute(\n        env,\n        stack,\n        [\n          {\n            destination: ReturnDestination,\n            operation: renderCfg(ctx, cfg),\n          },\n        ],\n        true,\n      );\n      return {\n        ir: computables,\n        postprocessValue(value: MaterializedComputable[]): unknown {\n          const resolvedOps: QueuedOperation[] = [];\n          for (const mc of value)\n            resolvedOps.push({ destination: mc.destination, operation: resOp(mc.computable) });\n          const postEnv: ExecutionEnvironment = {\n            drivers,\n            get cCtx(): ComputableCtx {\n              throw new Error(\"asynchronous operations are forbidden in this context\");\n            },\n          };\n\n          // Post process can be called several times, that's why it must be a side-effect-free function.\n          // But `execute` modifies a stack, so we have to defensively copy it here.\n          const copyOfPendingSubrotines = new Map<SubroutineKey, PendingSubroutine>();\n          for (const [key, value] of stack.pendingSubroutines)\n            copyOfPendingSubrotines.set(key, { ...value, args: { ...value.args } });\n          const copiedStack: ExecutionStack = {\n            result: stack.result,\n            pendingSubroutines: copyOfPendingSubrotines,\n          };\n          execute(postEnv, copiedStack, resolvedOps, false);\n          if (!(\"result\" in copiedStack))\n            throw new Error(\"illegal cfg rendering stack state, no result\");\n          return copiedStack.result;\n        },\n      };\n    },\n    { ...ops, key },\n  );\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"executor.js","names":[],"sources":["../../src/cfg_render/executor.ts"],"sourcesContent":["import type {\n  ArgumentKey,\n  ArgumentValues,\n  ExecutionEnvironment,\n  Operation,\n  Subroutine,\n} from \"./operation\";\nimport Denque from \"denque\";\nimport { assertNever, notEmpty } from \"@milaboratories/ts-helpers\";\nimport type { ComputableCtx, ComputableRenderingOps } from \"@milaboratories/computable\";\nimport { Computable } from \"@milaboratories/computable\";\nimport type { Cfg } from \"@platforma-sdk/model\";\nimport { renderCfg, resOp } from \"./renderer\";\nimport canonicalize from \"canonicalize\";\nimport type { BlockContextAny } from \"../middle_layer/block_ctx\";\nimport type { MiddleLayerDriverKit } from \"../middle_layer/driver_kit\";\nimport { NonKeyCtxFields, toCfgContext } from \"../middle_layer/block_ctx_unsafe\";\n\n/** Addresses pending subroutines inside the stack */\ntype SubroutineKey = symbol;\n\n/** Represents destination of the result of an operation. I.e. when sequence of\n * subroutine invocations, and computables terminates with result, this object\n * determines to which argument of which pending subroutine it should be delivered.\n * See special value for delivery of the final \"return\" result. */\ntype Destination = {\n  op: SubroutineKey;\n  arg: ArgumentKey;\n};\n\n/** Special address of operation, see below. */\nconst ReturnOpKey: unique symbol = Symbol();\n/** The same, but for the argument part of destination, see below. */\nconst ReturnArgKey = \"return\";\n\n/** Special destination, telling the executor that corresponding result should\n * be exposed as a final result, and execution terminate at this point. */\nconst ReturnDestination = { op: ReturnOpKey, arg: ReturnArgKey } as Destination;\n\nfunction isReturnDestination(destination: Destination): boolean {\n  return destination.op == ReturnOpKey && destination.arg == ReturnArgKey;\n}\n\n/** Queued operation, used inside the executor */\ntype QueuedOperation = {\n  operation: Operation;\n  destination: Destination;\n};\n\n/** Queued computation, returned by the first round of config execution. Such\n * computables should be returned in the intermediate representation of the\n * enclosing computable, and after they are resolved and passed to the\n * postprocessing routine, should be injected into the execution stack to\n * finalize the computation. */\ntype ScheduledComputable = {\n  destination: Destination;\n  computable: Computable<unknown>;\n};\n\n/** This is what ScheduledComputable transforms from intermediate\n * representation to post-processing. */\ntype MaterializedComputable = {\n  destination: Destination;\n  computable: unknown;\n};\n\n/** Main entry inside the execution stack. */\ntype PendingSubroutine = {\n  subroutine: Subroutine;\n  destination: Destination;\n  argCounter: number;\n  args: ArgumentValues;\n};\n\n/** Execution stack. The closest concept that this object along with enclosed\n * {@link PendingSubroutine}s represent is a Continuation.\n * https://en.wikipedia.org/wiki/Continuation */\ntype ExecutionStack = {\n  result?: unknown;\n  pendingSubroutines: Map<SubroutineKey, PendingSubroutine>;\n};\n\n/** Returns initial stack value. */\nfunction zeroStack(): ExecutionStack {\n  return { pendingSubroutines: new Map<SubroutineKey, PendingSubroutine>() };\n}\n\n/** Implements main executor mechanism.\n * @param env to be passed to while executing operations\n * @param stack execution stack to continue execution from\n * @param operations operations to initiate the execution process\n * @param allowComputables if false, scheduling of async computables will result in error\n * */\nfunction execute(\n  env: ExecutionEnvironment,\n  stack: ExecutionStack,\n  operations: QueuedOperation[],\n  allowComputables: boolean,\n): ScheduledComputable[] {\n  const operationQueue = new Denque<QueuedOperation>(operations);\n\n  /** Returns false if final result is set as result of this operation,\n   * true if we should continue processing. */\n  const deliverResult = (destination: Destination, result: unknown): boolean => {\n    if (isReturnDestination(destination)) {\n      stack.result = result;\n      return false;\n    }\n\n    const pending = notEmpty(stack.pendingSubroutines.get(destination.op));\n    if (destination.arg in pending.args) throw new Error(\"argument already set\");\n    pending.args[destination.arg] = result;\n    pending.argCounter--;\n    if (pending.argCounter === 0) {\n      stack.pendingSubroutines.delete(destination.op);\n      operationQueue.push({\n        destination: pending.destination,\n        operation: pending.subroutine(pending.args),\n      });\n    }\n\n    return true;\n  };\n\n  // computables, scheduled during computation, are aggregated in this array,\n  // and returned from the function in the end\n  const computables: ScheduledComputable[] = [];\n\n  // each loop = execution of a single queued operation\n  mainLoop: while (operationQueue.length > 0) {\n    const op = operationQueue.shift()!;\n    const action = op.operation(env);\n    switch (action.type) {\n      case \"ReturnResult\":\n        if (!deliverResult(op.destination, action.result)) break mainLoop; // this terminates execution\n        break; // switch\n\n      case \"ScheduleSubroutine\":\n        {\n          const newOpKey = Symbol();\n\n          const argRequests = Object.entries(action.args);\n          const initialArgCounter = argRequests.length;\n\n          if (initialArgCounter === 0)\n            // if no pending arguments\n            operationQueue.push({\n              destination: op.destination,\n              operation: action.subroutine({}),\n            });\n          else {\n            for (const [arg, operation] of argRequests)\n              operationQueue.push({\n                destination: { op: newOpKey, arg },\n                operation,\n              });\n\n            stack.pendingSubroutines.set(newOpKey, {\n              argCounter: initialArgCounter,\n              args: {},\n              subroutine: action.subroutine,\n              destination: op.destination,\n            });\n          }\n        }\n        break;\n\n      case \"ScheduleComputable\":\n        if (!allowComputables)\n          throw new Error(\"asynchronous operations are forbidden in this context\");\n        computables.push({\n          destination: op.destination,\n          computable: action.computable,\n        });\n        break;\n\n      default:\n        assertNever(action);\n    }\n  }\n\n  return computables;\n}\n\n//\n// Computable\n//\n\n/** Main method to render configurations */\nexport function computableFromCfg(\n  drivers: MiddleLayerDriverKit,\n  bCtx: BlockContextAny,\n  cfg: Cfg,\n  ops: Partial<ComputableRenderingOps> = {},\n): Computable<unknown> {\n  return computableFromCfgUnsafe(drivers, toCfgContext(bCtx), cfg, ops);\n}\n\nexport function computableFromCfgUnsafe(\n  drivers: MiddleLayerDriverKit,\n  ctx: Record<string, unknown>,\n  cfg: Cfg,\n  ops: Partial<ComputableRenderingOps> = {},\n): Computable<unknown> {\n  const key =\n    `${ctx.blockId}#` +\n    canonicalize({\n      ctx: Object.fromEntries(\n        Object.entries(ctx).filter(([k]) => NonKeyCtxFields.indexOf(k) === -1),\n      ),\n      cfg: cfg,\n    })!;\n  return Computable.makeRaw(\n    (c) => {\n      const env: ExecutionEnvironment = { drivers, cCtx: c };\n      const stack = zeroStack();\n      const computables = execute(\n        env,\n        stack,\n        [\n          {\n            destination: ReturnDestination,\n            operation: renderCfg(ctx, cfg),\n          },\n        ],\n        true,\n      );\n      return {\n        ir: computables,\n        postprocessValue(value: MaterializedComputable[]): unknown {\n          const resolvedOps: QueuedOperation[] = [];\n          for (const mc of value)\n            resolvedOps.push({ destination: mc.destination, operation: resOp(mc.computable) });\n          const postEnv: ExecutionEnvironment = {\n            drivers,\n            get cCtx(): ComputableCtx {\n              throw new Error(\"asynchronous operations are forbidden in this context\");\n            },\n          };\n\n          // Post process can be called several times, that's why it must be a side-effect-free function.\n          // But `execute` modifies a stack, so we have to defensively copy it here.\n          const copyOfPendingSubrotines = new Map<SubroutineKey, PendingSubroutine>();\n          for (const [key, value] of stack.pendingSubroutines)\n            copyOfPendingSubrotines.set(key, { ...value, args: { ...value.args } });\n          const copiedStack: ExecutionStack = {\n            result: stack.result,\n            pendingSubroutines: copyOfPendingSubrotines,\n          };\n          execute(postEnv, copiedStack, resolvedOps, false);\n          if (!(\"result\" in copiedStack))\n            throw new Error(\"illegal cfg rendering stack state, no result\");\n          return copiedStack.result;\n        },\n      };\n    },\n    { ...ops, key },\n  );\n}\n"],"mappings":"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"}