@milaboratories/pl-middle-layer 1.66.19 → 1.67.1

package/src/middle_layer/middle_layer.ts

@@ -20,7 +20,23 @@ import {
   ProjectsField,
   ProjectsResourceType,
 } from "./project_list";
-import { createProject, duplicateProject, withProjectAuthored } from "../mutator/project";
+import {
+  createProject,
+  duplicateProject,
+  withProject,
+  withProjectAuthored,
+} from "../mutator/project";
+import type { ProjectTemplateExportOutcome } from "../model/template_serializer";
+import type { ProjectTemplateV1 } from "@milaboratories/pl-model-common";
+import { extractConfig, ensureError } from "@platforma-sdk/model";
+import type { TemplateApplyProblem, TemplateApplyReport } from "../model/template_apply";
+import { TemplateEntryRejected, kindMismatch } from "../model/template_apply";
+import type { BlockPackProvider } from "../model/template_resolve";
+import { resolveTemplateEntries } from "../model/template_resolve";
+import type { PreparedTemplateEntry } from "../mutator/template_construct";
+import { applyTemplateEntries } from "../mutator/template_construct";
+import { throwIfMissingServerCapabilities } from "./project";
+import { cacheBlockPackTemplate } from "../mutator/template/template_cache";
 import { ProjectMetaKey } from "../model/project_model";
 import type { ProjectId } from "../model/project_model";
 import type { SynchronizedTreeState } from "@milaboratories/pl-tree";
@@ -75,6 +91,7 @@ import type {
   ProjectMeta,
   BlockPlatform,
 } from "@milaboratories/pl-model-middle-layer";
+import type { AppliedEntry } from "../model/template_apply";
 import { BlockUpdateWatcher } from "../block_registry/watcher";
 import type { QuickJSWASMModule } from "quickjs-emscripten";
 import { getQuickJS } from "quickjs-emscripten";
@@ -325,6 +342,180 @@ export class MiddleLayer {
     await this.projectListTree.refreshState();
   }
 
+  /**
+   * Renders a project as a `template-v1` YAML document, or reports every reason it
+   * cannot be — the backing call for an "Export Project as Template…" command.
+   *
+   * Takes a project id rather than an open {@link Project} because exporting is a
+   * property of the stored project, not of a session with it: the command belongs on
+   * a project card, where the project is usually closed. Opening one to read it would
+   * spin up trees and watchers for a one-shot read, and then have to decide whether to
+   * close them again.
+   *
+   * Read-only — the underlying mutator touches no field, so the transaction is never
+   * committed and the project list needs no refresh.
+   *
+   * @param id - project id of the project to export
+   */
+  public async exportProjectAsTemplate(id: ProjectId): Promise<ProjectTemplateExportOutcome> {
+    const rid = await this.resolveProjectId(id);
+    return await withProject(
+      this.env.projectHelper,
+      this.pl,
+      rid,
+      (prj) => prj.exportAsTemplateV1(),
+      { name: "exportProjectAsTemplate" },
+    );
+  }
+
+  /**
+   * Creates the blocks a `template-v1` document describes in an existing project, in the
+   * order the document lists them — the backing call for a "Create Project from Template
+   * file…" command, which is `createProject` followed by this.
+   *
+   * Takes a project id rather than an open {@link Project}, like
+   * {@link exportProjectAsTemplate} and for the same reason: applying a template is a
+   * property of the stored project, not of a session with it, and the flow that needs it
+   * has just created the project and has no session yet. An already-open session picks the
+   * new blocks up through its own refresh loop.
+   *
+   * Three stages, and their order is the design:
+   *
+   * 1. **Resolve every entry** to a concrete block pack, through `provider`.
+   * 2. **Prepare every block**: fetch it, check it can run against this backend, cache its
+   *    workflow template, and offer the entry's params to the block's kind for a shape
+   *    check.
+   * 3. **Create the blocks**, in one transaction — each one's params first pointed at this
+   *    project by the block's own model, since which values in there are references is
+   *    knowledge only the block has.
+   *
+   * The first two create nothing, so either of them failing leaves the project exactly as it
+   * was. They are also what leaves stage 3 with only in-memory work, and hence able to be a
+   * single transaction.
+   *
+   * **Stage 3 is all or nothing too**, because it is that one transaction: an entry it cannot
+   * create throws, the transaction is never committed, and the project keeps none of the
+   * blocks the apply had placed. So `problems` non-empty always means `added` is empty, at
+   * every stage — a caller never has to reconcile a half-built project, and never has to ask
+   * which of the blocks present came from the file.
+   *
+   * What is NOT checked before the work starts: which entries an entry references. Reading
+   * that means reading the params, which only the block can do, and no block exists until
+   * stage 2 has fetched one. A file whose entry references one listed below it therefore
+   * applies, and the block it creates reports itself as missing references — the same way a
+   * reference to a deleted block already behaves.
+   *
+   * @param id Project to apply into
+   * @param document A parsed template document
+   * @param provider Where each entry's block comes from
+   * @param options `allowUnstable` widens resolution to pre-release implementations, for
+   *   the whole document
+   */
+  public async applyTemplateToProject(
+    id: ProjectId,
+    document: ProjectTemplateV1,
+    provider: BlockPackProvider,
+    options: { allowUnstable?: boolean; author?: AuthorMarker } = {},
+  ): Promise<TemplateApplyReport> {
+    const resolution = await resolveTemplateEntries(document, provider, {
+      allowUnstable: options.allowUnstable ?? false,
+    });
+    if (resolution.problems.length > 0) return { added: [], problems: resolution.problems };
+
+    // One map, not one per field: resolution reports by entry id, so everything this loop
+    // needs about an entry is looked up the same way.
+    const byEntryId = new Map(document.blocks.map((entry) => [entry.id, entry]));
+    const prepared = new Map<string, PreparedTemplateEntry>();
+    const problems: TemplateApplyProblem[] = [];
+
+    for (const entry of resolution.resolved) {
+      try {
+        const documentEntry = byEntryId.get(entry.entryId)!;
+        const preparedBp = await this.env.bpPreparer.prepare(entry.spec);
+        const blockCfg = extractConfig(preparedBp.config);
+
+        // The first question asked of the prepared block: is it the block this entry meant.
+        // Everything below is only meaningful once the answer is yes.
+        //
+        // The locator is appended here rather than inside the check, which names no route:
+        // when the file chose the implementation itself, what it chose is the thing to correct.
+        const mismatch = kindMismatch(documentEntry.kind, preparedBp.config.kind);
+        if (mismatch !== undefined) {
+          const locator = documentEntry.location ?? documentEntry.block;
+          problems.push({
+            entryId: entry.entryId,
+            error: locator === undefined ? `${mismatch}.` : `${mismatch} (${locator}).`,
+          });
+          continue;
+        }
+
+        // The same two gates `Project.addBlock` applies, for the same reason: a block that
+        // cannot run here must not be installed. Here they become per-entry problems
+        // rather than throws, so one unusable block reads as one bad entry.
+        this.env.runtimeCapabilities.throwIfIncompatible(blockCfg.featureFlags);
+        throwIfMissingServerCapabilities(this.pl, preparedBp.requiredCapabilities);
+
+        const cachedBp = await cacheBlockPackTemplate(this.pl, preparedBp);
+
+        // Offered to the block's kind while nothing has been created yet. Every entry is
+        // checked, including one whose file omitted `params` — the parser read that as `{}`,
+        // which a kind with required fields rejects, and rightly: it would otherwise apply as
+        // a block that looks configured and is not.
+        const checked = this.env.projectHelper.validateTemplateParamsInVM(
+          blockCfg,
+          documentEntry.params,
+        );
+        if (checked.error !== undefined) {
+          problems.push({ entryId: entry.entryId, error: checked.error.message });
+          continue;
+        }
+
+        // The block package's own title, the same thing the add-block UI writes. It is
+        // what the user sees for a block whose model derives no title of its own, and it
+        // is resolution's to supply — nothing here could reconstruct it.
+        prepared.set(entry.entryId, { blockPack: cachedBp, label: entry.title });
+      } catch (e) {
+        problems.push({
+          entryId: entry.entryId,
+          error: `This entry's block could not be installed: ${ensureError(e).message}`,
+        });
+      }
+    }
+
+    if (problems.length > 0) return { added: [], problems };
+
+    const rid = await this.resolveProjectId(id);
+    let added: AppliedEntry[] = [];
+    try {
+      await withProjectAuthored(
+        this.env.projectHelper,
+        this.pl,
+        rid,
+        options.author,
+        (mut) => {
+          added = applyTemplateEntries({
+            document,
+            placer: mut,
+            entries: prepared,
+            projectHelper: this.env.projectHelper,
+          });
+        },
+        // Under the same lock an open session's own mutations take, so an apply and a user
+        // editing the project cannot interleave.
+        { name: "applyTemplateToProject", lockId: `project:${id}` },
+      );
+    } catch (e: unknown) {
+      // A statement about the file: the transaction went with the throw, so the project kept
+      // none of the blocks the apply had placed, and `added` is empty by construction.
+      // Anything else — a backend that refused the write, say — is not about the file and
+      // keeps propagating.
+      if (!(e instanceof TemplateEntryRejected)) throw e;
+      return { added: [], problems: [{ entryId: e.entryId, error: e.message }] };
+    }
+
+    return { added, problems: [] };
+  }
+
   /** Permanently deletes project from the project list, this will result in
    * destruction of all attached objects, like files, analysis results etc. */
   public async deleteProject(id: ProjectId): Promise<void> {

package/src/middle_layer/project.ts

@@ -996,7 +996,7 @@ function convertErrorsToStrings(
  * the UI (`AddBlockModal`) and direct middle-layer callers (the MCP server's
  * `add_block` tool, programmatic block installs, tests) reject incompatible
  * blocks consistently. */
-function throwIfMissingServerCapabilities(
+export function throwIfMissingServerCapabilities(
   pl: PlClient,
   requiredCapabilities: readonly string[] | undefined,
 ): void {

package/src/model/args.test.ts

@@ -1,5 +1,7 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, test } from "vitest";
 import canonicalize from "canonicalize";
+import type { ColumnUniversalId } from "@milaboratories/pl-model-common";
+import { canonicalizeJson, createColumnDiscoveredId } from "@milaboratories/pl-model-common";
 import { inferAllReferencedBlocks, outputRef } from "./args";
 
 describe("inferAllReferencedBlocks", () => {
@@ -133,3 +135,26 @@ describe("inferAllReferencedBlocks", () => {
     expect(result.upstreams.size).toBe(0);
   });
 });
+
+test("a block id in a map KEY is an upstream too", () => {
+  // A discovered column's `queriesQualifications` is `Record<PObjectId, …>`, so the id sits in
+  // the key. Walking values only lost that edge: the block depended on an upstream the graph
+  // never knew about, and the loss was invisible because the rest of the id parsed fine.
+  const qual = [{ axis: { name: "sampleId" }, contextDomain: {} }];
+  const discovered = createColumnDiscoveredId({
+    column: canonicalizeJson(outputRef("A", "clonotypes")) as ColumnUniversalId,
+    path: [
+      {
+        type: "linker",
+        column: canonicalizeJson(outputRef("B", "cell-to-clone")) as ColumnUniversalId,
+      },
+    ],
+    queriesQualifications: {
+      [canonicalizeJson(outputRef("D", "anchor")) as ColumnUniversalId]: qual,
+    },
+  });
+
+  const result = inferAllReferencedBlocks({ anchor: discovered });
+
+  expect([...result.upstreams].sort()).toEqual(["A", "B", "D"]);
+});

package/src/model/args.ts

@@ -1,5 +1,6 @@
 import { assertNever } from "@milaboratories/ts-helpers";
 import type { PlRef } from "@platforma-sdk/model";
+import { peelJsonLayers } from "@milaboratories/pl-model-common";
 
 export function outputRef(blockId: string, name: string, requireEnrichments?: boolean): PlRef {
   if (requireEnrichments) return { __isRef: true, blockId, name, requireEnrichments };
@@ -48,9 +49,15 @@ function addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?:
     case "undefined":
       return;
     case "string": {
-      unwrapEmbeddedRef(node as string, (parsed) =>
-        addAllReferencedBlocks(result, parsed, allowed),
-      );
+      // A reference can be hiding inside a string under any number of `JSON.stringify`
+      // passes, and this walk would otherwise never reach it. Peeling is shared with the
+      // column-id remapper so that "how a value hides inside a string" has one
+      // definition; what happens at the bottom is not shared, and here it is deliberately
+      // broad — anything the peel produced is walked, including a foreign-schema document
+      // that merely contains a reference. That breadth is what makes this detector usable
+      // as a guard over carriers the template codec declines to touch.
+      const peeled = peelJsonLayers(node as string);
+      if (peeled !== undefined) addAllReferencedBlocks(result, peeled.value, allowed);
       return;
     }
     case "object": {
@@ -60,8 +67,13 @@ function addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?:
       } else if (Array.isArray(node)) {
         for (const child of node) addAllReferencedBlocks(result, child, allowed);
       } else {
-        for (const [, child] of Object.entries(node as object))
+        // Keys as well as values: a discovered column's `queriesQualifications` is keyed BY
+        // column id, so a map key can carry a block id — and dropping the key loses that
+        // upstream edge entirely.
+        for (const [key, child] of Object.entries(node as object)) {
+          addAllReferencedBlocks(result, key, allowed);
           addAllReferencedBlocks(result, child, allowed);
+        }
       }
 
       return;
@@ -71,33 +83,6 @@ function addAllReferencedBlocks(result: BlockUpstreams, node: unknown, allowed?:
   }
 }
 
-/**
- * Detect a PlRef carried inside a string and hand the decoded value to `onParsed`.
- *
- * A PlRef-as-string is canonical `{...}` optionally wrapped by N `JSON.stringify`
- * passes. Each pass adds a symmetric prefix/suffix made only of `"` and `\`
- * chars (the escape padding) of equal length. The regex below is the strict
- * shape gate — non-ref strings fail at the very first character, so we never
- * scan their body. One pass is peeled per call; deeper nesting is unwrapped
- * via recursion in the caller.
- */
-const EMBEDDED_REF_RE = /^(?<pre>[\\"]*)\{[\s\S]*?__isRef[\s\S]*\}(?<suf>[\\"]*)$/;
-
-function unwrapEmbeddedRef(s: string, onParsed: (value: unknown) => void) {
-  const c0 = s.charCodeAt(0);
-  if (c0 !== 0x7b /* { */ && c0 !== 0x22 /* " */) return;
-  const m = EMBEDDED_REF_RE.exec(s);
-  if (m === null) return;
-  if (m.groups!.pre.length !== m.groups!.suf.length) return;
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(s);
-  } catch {
-    return;
-  }
-  if (parsed !== s) onParsed(parsed);
-}
-
 function recordRef(
   result: BlockUpstreams,
   blockId: string,

package/src/model/index.ts

@@ -14,3 +14,24 @@ export {
 } from "./project_model";
 
 export * from "./sharing_model";
+
+// The template import path. A caller reads a file, parses it, creates a project and
+// applies the document — so the parser and the report types are as public as the
+// `MiddleLayer.applyTemplateToProject` that consumes them. `BlockPackProvider` is here
+// for the same reason: which registries to consult is the caller's decision.
+export { parseProjectTemplateV1Yaml, type TemplateParseOutcome } from "./template_parser";
+export {
+  resolveTemplateEntries,
+  parseBlockPackName,
+  type BlockPackProvider,
+  type KindResolution,
+  type ExactResolution,
+  type ResolvedEntry,
+  type TemplateResolveOutcome,
+} from "./template_resolve";
+export {
+  TemplateEntryRejected,
+  type AppliedEntry,
+  type TemplateApplyProblem,
+  type TemplateApplyReport,
+} from "./template_apply";

package/src/model/project_helper.ts

@@ -40,6 +40,20 @@ export type MigrationResult =
  */
 type ArgsDeriveResult = { error: string } | { error?: undefined; value: unknown };
 
+/**
+ * Result of building initial storage from params.
+ * Returned by the __pl_storage_initialFromParams VM callback.
+ */
+type ParamsStorageResult =
+  | { error: string }
+  | { error?: undefined; storageJson: StringifiedJson<BlockStorage> };
+
+/**
+ * Result of checking params against their kind.
+ * Returned by the __pl_initializationParams_validate VM callback.
+ */
+type InitializationParamsValidateResult = { error: string } | { error?: undefined };
+
 export class ProjectHelper {
   private readonly enrichmentTargetsCache = new LRUCache<
     string,
@@ -131,6 +145,88 @@ export class ProjectHelper {
     }
   }
 
+  /**
+   * Derives this block's template-export params from storage JSON using the VM
+   * callback (`__pl_initializationParams_derive`).
+   *
+   * The template-export counterpart of {@link deriveArgsFromStorage}: instead of
+   * the args a workflow runs on, it returns the params that would recreate the
+   * block — the inverse of the data model's `init`. Params come back exactly as the block
+   * projected them, references included: nothing marks or rewrites them on the way out, so
+   * nothing here has to know a kind's params shape or how a reference is spelled.
+   *
+   * A `{ value: undefined }` result means the block declares no `templateParams`, which only
+   * a block built against an older SDK can do. It does not reach a document: the export walk
+   * requires a mapping and reports anything else as that block's problem, so an entry always
+   * carries params.
+   *
+   * Unlike {@link derivePrerunArgsFromStorage}, a failure here is surfaced rather
+   * than swallowed — a prerun that cannot derive args just skips a block in
+   * staging, whereas an export that silently drops a block produces a template
+   * that does not describe the project.
+   *
+   * @param blockConfig The block configuration (provides the model code)
+   * @param storageJson Storage as JSON string
+   * @returns The derived params with identifiers wrapped, `undefined` if the block declares
+   *   no lambda, or an error if derivation failed
+   */
+  public deriveTemplateParamsFromStorage(
+    blockConfig: BlockConfig,
+    storageJson: string,
+  ): ResultOrError<unknown> {
+    if (blockConfig.modelAPIVersion !== BLOCK_STORAGE_FACADE_VERSION) {
+      return {
+        error: new Error(
+          "deriveTemplateParamsFromStorage is only supported for model API version 2",
+        ),
+      };
+    }
+
+    const callback =
+      blockConfig.blockLifecycleCallbacks[BlockStorageFacadeCallbacks.InitializationParamsDerive];
+
+    // A model built before this callback existed simply has no entry for it. That is
+    // NOT the same as a block declaring no `templateParams`: the block may well have
+    // params, we just have no way to ask for them. Reporting it as `undefined` params
+    // would export the block stripped of its configuration and quietly rebuild a
+    // differently-configured project, so it has to be an error.
+    // The message names the one action available to whoever pressed Export. It
+    // deliberately says nothing about SDKs or callbacks: the person reading it did
+    // not build this block and cannot change how it was built.
+    if (callback === undefined) {
+      return {
+        error: new Error(
+          "This version of the block cannot be written to a template. Update the block " +
+            "to a newer version and export again.",
+        ),
+      };
+    }
+
+    try {
+      const result = executeSingleLambda(
+        this.quickJs,
+        callback,
+        extractCodeWithInfo(blockConfig),
+        storageJson,
+      ) as ArgsDeriveResult;
+
+      if (result.error !== undefined) {
+        return { error: new Error(result.error) };
+      }
+      return { value: result.value };
+    } catch (e) {
+      const cause = ensureError(e);
+      // The reason goes in the message, not only in `cause`: this error is rendered
+      // into a per-block export problem and shown to whoever triggered the export,
+      // and every layer between here and there carries only `message`.
+      return {
+        error: new Error(`Template params derivation from storage failed: ${cause.message}`, {
+          cause,
+        }),
+      };
+    }
+  }
+
   private calculateEnrichmentTargets(req: EnrichmentTargetsRequest): PlRef[] | undefined {
     const blockConfig = req.blockConfig();
     if (blockConfig.enrichmentTargets === undefined) return undefined;
@@ -191,6 +287,148 @@ export class ProjectHelper {
     }
   }
 
+  /**
+   * Checks a template entry's params against the block's kind, creating nothing.
+   *
+   * The pre-flight half of {@link getInitialStorageFromParamsInVM}: run once per entry
+   * before a template is applied, so params a kind rejects are reported against the
+   * entry that carries them while there is still no project. Skipping it is safe —
+   * initialization runs the same check — but then the report arrives after earlier
+   * entries have already been created.
+   *
+   * Every kind declares a parser, so a pass here means the params were checked against
+   * the contract — not merely that they were JSON.
+   *
+   * A block whose model predates the callback passes unchecked rather than failing.
+   * Unlike initialization, this method creates nothing, so there is nothing to get wrong
+   * by proceeding, and such a block is refused outright at the point it is applied.
+   *
+   * @param blockConfig The block configuration (provides the model code)
+   * @param params The entry's params. Reference ids may be placeholders: what is being
+   *   checked is the shape of the params, not what they point at
+   * @returns Nothing, or why the params were rejected
+   */
+  public validateTemplateParamsInVM(
+    blockConfig: BlockConfig,
+    params: unknown,
+  ): ResultOrError<undefined> {
+    if (blockConfig.modelAPIVersion !== BLOCK_STORAGE_FACADE_VERSION) {
+      return {
+        error: new Error("validateTemplateParamsInVM is only supported for model API version 2"),
+      };
+    }
+
+    const callback =
+      blockConfig.blockLifecycleCallbacks[BlockStorageFacadeCallbacks.InitializationParamsValidate];
+    if (callback === undefined) return { value: undefined };
+
+    try {
+      const result = executeSingleLambda(
+        this.quickJs,
+        callback,
+        extractCodeWithInfo(blockConfig),
+        JSON.stringify(params ?? {}),
+      ) as InitializationParamsValidateResult;
+
+      if (result.error !== undefined) return { error: new Error(result.error) };
+      return { value: undefined };
+    } catch (e) {
+      const cause = ensureError(e);
+      return { error: new Error(`Params check failed to run: ${cause.message}`, { cause }) };
+    }
+  }
+
+  /**
+   * Creates initial BlockStorage for a block being created from template params.
+   *
+   * The inverse of {@link deriveTemplateParamsFromStorage}, and the reason a block
+   * can be created by anything other than the UI: it hands the params to the
+   * block's own init factory inside the model VM, so the resulting storage is
+   * whatever that block considers a correctly-initialized state.
+   *
+   * **Pointing the entry's references at this project happens in the same call**, before the
+   * factory sees them — inside the block's bundle, because recognizing a reference means
+   * knowing the reference system and a template engine deliberately does not. Params reach
+   * here exactly as the file held them.
+   *
+   * One call and not two: every VM call builds a fresh runtime and re-evaluates the whole
+   * model bundle, so asking the block to relocate and then asking it to initialize would parse
+   * it twice per entry, for an intermediate value nothing else reads.
+   *
+   * `blockIds` holds the entries created so far, so an id it does not name is left as it is —
+   * a reference to an entry further down the file keeps pointing at nothing, and the applied
+   * block reports itself as missing references rather than being wired to a block below it.
+   *
+   * @param blockConfig The block configuration (provides the model code)
+   * @param params The entry's params, as the document held them
+   * @param blockIds template-local entry id → the block id that entry was given
+   * @returns The initial storage as JSON string, or why the params yield none
+   */
+  public getInitialStorageFromParamsInVM(
+    blockConfig: BlockConfig,
+    params: unknown,
+    blockIds: ReadonlyMap<string, string>,
+  ): ResultOrError<string> {
+    if (blockConfig.modelAPIVersion !== BLOCK_STORAGE_FACADE_VERSION) {
+      return {
+        error: new Error(
+          "getInitialStorageFromParamsInVM is only supported for model API version 2",
+        ),
+      };
+    }
+
+    const callback =
+      blockConfig.blockLifecycleCallbacks[BlockStorageFacadeCallbacks.StorageInitialFromParams];
+
+    // A model built before this callback existed has no entry for it. Falling back to the
+    // params-less initializer is not an option: it would produce a default-configured block
+    // that looks like a successful apply, so the block the user gets would silently differ
+    // from the one the template describes. Nor could its params be used as written — they name
+    // the blocks of the project the template came from, and only this callback knows which of
+    // the values in there are references at all.
+    //
+    // The message offers the two actions available to whoever applied the file. The
+    // second one is the reason this branch is reachable at all: kind resolution only
+    // ever returns a block that declares a kind, and such a block is new enough to
+    // support this — but an entry may pin an exact block version instead, bypassing
+    // resolution, and that pin can name anything ever published.
+    if (callback === undefined) {
+      return {
+        error: new Error(
+          "This version of the block cannot be created from a template. Use a newer " +
+            "version of the block, or remove the pinned block version from the template " +
+            "entry so a supported one is chosen automatically.",
+        ),
+      };
+    }
+
+    try {
+      const result = executeSingleLambda(
+        this.quickJs,
+        callback,
+        extractCodeWithInfo(blockConfig),
+        // Params cross the VM boundary as text, like storage does. `undefined` would
+        // stringify to nothing at all, and an entry with no params must go through
+        // the params-less initializer rather than reaching this method.
+        JSON.stringify(params ?? {}),
+        JSON.stringify(Object.fromEntries(blockIds)),
+      ) as ParamsStorageResult;
+
+      if (result.error !== undefined) return { error: new Error(result.error) };
+      return { value: result.storageJson };
+    } catch (e) {
+      const cause = ensureError(e);
+      // The reason goes in the message, not only in `cause`: this error becomes a
+      // per-entry apply problem shown to whoever triggered the import, and every
+      // layer in between carries only `message`.
+      return {
+        error: new Error(`Initial storage creation from params failed: ${cause.message}`, {
+          cause,
+        }),
+      };
+    }
+  }
+
   /**
    * Applies a state update using VM-based transformation.
    * This calls the model's `__pl_storage_applyUpdate` callback which: