@milaboratories/pl-middle-layer 1.66.18 → 1.67.0

package/dist/model/template_serializer.js

@@ -0,0 +1,157 @@
+import { walkProjectForTemplateExport } from "./template_export.js";
+import YAML from "yaml";
+import { pathToFileURL } from "node:url";
+import { PROJECT_TEMPLATE_SCHEMA_V1, kindReferenceToSelectorReference, parseProjectTemplateV1 } from "@milaboratories/pl-model-common";
+//#region src/model/template_serializer.ts
+/**
+* The `location` to write for a block installed from the filesystem, or `undefined`
+* for one that came from a registry and therefore needs no locator.
+*
+* Both filesystem spec shapes are emitted, and they anchor at different directories
+* — a dev block at its facade package, an npm-consumed one at its block-pack folder.
+* The document does not distinguish them: one URI is written either way, and telling
+* the two layouts apart is done by looking at what is actually there, by the side
+* that has the filesystem anyway. Encoding the layout in the file instead would
+* freeze today's two shapes into the format.
+*
+* A dev spec carries an OS path and is converted here, which also percent-encodes a
+* path containing spaces. An npm-consumed spec already carries a `file:` URL and is
+* passed through: it is the locator the block itself emitted, and reconstructing one
+* from it could only lose information.
+*/
+function locationOf(spec) {
+	switch (spec.type) {
+		case "dev-v2": return pathToFileURL(spec.folder).href;
+		case "from-pack-v2": return spec.packUrl;
+		case "dev-v1":
+		case "from-registry-v1":
+		case "from-registry-v2": return;
+	}
+}
+/**
+* Turn a project into a template document.
+*
+* Assembly is deliberately dull — the entry is the block's id, its widened kind
+* reference, and the params the walk already collected. The interesting decisions
+* were made upstream; what is left here is the two things only this layer can
+* check, both of which produce problems rather than a broken file:
+*
+* - **A block with no kind cannot be written.** An entry's `kind` is required — it
+*   is the params contract the entry is typed against — while a block's kind is
+*   optional, so a block that predates kinds, or that uses the deprecated
+*   kind-less model overload, has no legal entry. Reported per block. This is not
+*   an edge case today: it is what most existing projects will hit until their
+*   blocks are republished.
+* - **References must point at an entry declared earlier.** Verbatim id reuse
+*   means a reference to a deleted block survives into the file naming nothing:
+*   deleting a block only removes it from the structure and does not rewrite
+*   downstream args, so a live project holds such references routinely.
+*
+* `block` is never emitted. That override exists to pin an implementation against
+* a kind's version range, and export always writes the exact version the block
+* implements, so there is nothing left for it to pin.
+*
+* `location` IS emitted, for every block that was installed from the filesystem. Such
+* a block is not in any registry, so the kind reference alone names nothing the
+* importer could find, and a file that omitted the one usable answer would describe a
+* project that cannot be recreated. It costs portability, and nothing says so: such a
+* file is the debugging path, read by the developer who wrote it on the machine that
+* wrote it.
+*
+* Problems from `walk` are carried through, so a caller can hand a walk straight
+* in and get one combined list.
+*/
+function assembleProjectTemplateV1(walk, kindProvider, specProvider) {
+	const problems = [...walk.problems];
+	const blocks = [];
+	for (const entry of walk.entries) {
+		const kind = kindProvider(entry.blockId);
+		if (kind === void 0) {
+			problems.push({
+				blockId: entry.blockId,
+				error: "Block declares no kind, so it cannot be written to a template: an entry's kind carries the params contract the entry is typed against"
+			});
+			continue;
+		}
+		let selector;
+		try {
+			selector = kindReferenceToSelectorReference(kind);
+		} catch (e) {
+			problems.push({
+				blockId: entry.blockId,
+				error: `Block's stored kind reference is malformed: ${e instanceof Error ? e.message : String(e)}`
+			});
+			continue;
+		}
+		const spec = specProvider(entry.blockId);
+		const location = spec === void 0 ? void 0 : locationOf(spec);
+		blocks.push({
+			id: entry.blockId,
+			kind: selector,
+			params: entry.params,
+			...location !== void 0 ? { location } : {}
+		});
+	}
+	return {
+		document: {
+			schema: PROJECT_TEMPLATE_SCHEMA_V1,
+			blocks
+		},
+		problems
+	};
+}
+/**
+* Render a template document to YAML text.
+*
+* Two non-default emitter settings, both about the file being read by someone
+* else's code:
+*
+* - **No line folding.** A wrapped scalar still parses, but it makes a diff between
+*   two exported templates unreadable, which is most of the reason to prefer YAML
+*   over JSON here.
+* - **Quote as if the reader were YAML 1.1**, while still parsing as 1.2. YAML 1.2
+*   dropped `yes`/`no`/`on`/`off`/`y`/`n` as booleans and dropped sexagesimal
+*   integers, so a 1.2 emitter leaves a params value of `"yes"` or `"1:30"` bare —
+*   which a 1.1 reader (PyYAML's default, and Go's yaml.v2) turns into `true` and
+*   `90`. A template is a contract for a second implementation, so the safe
+*   combination is to quote against the stricter ruleset and read with the looser
+*   one: a quoted scalar means the same thing under both. This adds no `%YAML`
+*   directive — it only changes which scalars get quotes.
+*/
+function stringifyProjectTemplateV1(document) {
+	return YAML.stringify(document, {
+		lineWidth: 0,
+		version: "1.1"
+	});
+}
+/**
+* Export a project as `template-v1` YAML, or report every reason it cannot be.
+*
+* All-or-nothing on purpose. A partial template silently drops blocks and the
+* surviving entries may reference the dropped ones, so what looks like a
+* successful export would produce a project missing pieces the user never chose
+* to leave out. Reporting everything at once instead of failing on the first
+* problem is the other half of that: fixing an export should take one pass.
+*
+* @param structure The project structure, which supplies both membership and order
+* @param paramsProvider A block's derived template params, in live form
+* @param kindProvider A block's exact kind reference, read from its stored config
+* @param specProvider A block's origin spec, read from the same stored container
+*/
+function exportProjectAsTemplateV1(structure, paramsProvider, kindProvider, specProvider) {
+	const { document, problems } = assembleProjectTemplateV1(walkProjectForTemplateExport(structure, paramsProvider), kindProvider, specProvider);
+	if (problems.length > 0) return {
+		ok: false,
+		problems
+	};
+	parseProjectTemplateV1(document);
+	return {
+		ok: true,
+		yaml: stringifyProjectTemplateV1(document),
+		document
+	};
+}
+//#endregion
+export { assembleProjectTemplateV1, exportProjectAsTemplateV1, locationOf, stringifyProjectTemplateV1 };
+
+//# sourceMappingURL=template_serializer.js.map

package/dist/model/template_serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template_serializer.js","names":[],"sources":["../../src/model/template_serializer.ts"],"sourcesContent":["import YAML from \"yaml\";\nimport { pathToFileURL } from \"node:url\";\nimport type {\n  BlockKindReference,\n  BlockKindSelectorReference,\n  BlockPackLocationReference,\n  ProjectTemplateV1,\n  ProjectTemplateV1Entry,\n} from \"@milaboratories/pl-model-common\";\nimport {\n  PROJECT_TEMPLATE_SCHEMA_V1,\n  kindReferenceToSelectorReference,\n  parseProjectTemplateV1,\n} from \"@milaboratories/pl-model-common\";\nimport type { BlockPackSpec } from \"@milaboratories/pl-model-middle-layer\";\nimport type { ProjectStructure } from \"./project_model\";\nimport type {\n  TemplateExportProblem,\n  TemplateExportWalk,\n  TemplateParamsResult,\n} from \"./template_export\";\nimport { walkProjectForTemplateExport } from \"./template_export\";\n\n/** A block's exact kind reference, or `undefined` for a block that declares no kind. */\nexport type BlockKindProvider = (blockId: string) => BlockKindReference | undefined;\n\n/**\n * A block's origin spec — where the installed block came from — or `undefined` when\n * it is not known for that block.\n *\n * The project stores this next to the kind reference, so both are read from the same\n * place and neither costs an extra round-trip.\n */\nexport type BlockPackSpecProvider = (blockId: string) => BlockPackSpec | undefined;\n\n/** What the caller gets back for a whole project. */\nexport type ProjectTemplateExportOutcome =\n  | {\n      readonly ok: true;\n      readonly yaml: string;\n      /** The document the YAML was rendered from, already validated. */\n      readonly document: ProjectTemplateV1;\n    }\n  | {\n      readonly ok: false;\n      /** Every block that stands in the way, not just the first. */\n      readonly problems: readonly TemplateExportProblem[];\n    };\n\n/**\n * The `location` to write for a block installed from the filesystem, or `undefined`\n * for one that came from a registry and therefore needs no locator.\n *\n * Both filesystem spec shapes are emitted, and they anchor at different directories\n * — a dev block at its facade package, an npm-consumed one at its block-pack folder.\n * The document does not distinguish them: one URI is written either way, and telling\n * the two layouts apart is done by looking at what is actually there, by the side\n * that has the filesystem anyway. Encoding the layout in the file instead would\n * freeze today's two shapes into the format.\n *\n * A dev spec carries an OS path and is converted here, which also percent-encodes a\n * path containing spaces. An npm-consumed spec already carries a `file:` URL and is\n * passed through: it is the locator the block itself emitted, and reconstructing one\n * from it could only lose information.\n */\nexport function locationOf(spec: BlockPackSpec): BlockPackLocationReference | undefined {\n  switch (spec.type) {\n    case \"dev-v2\":\n      return pathToFileURL(spec.folder).href as BlockPackLocationReference;\n    case \"from-pack-v2\":\n      return spec.packUrl as BlockPackLocationReference;\n    // A registry block is found by name, which is what makes the entry portable —\n    // writing where this machine happened to cache it would take that away. `dev-v1`\n    // predates kinds entirely, so such a block has no kind and never reaches here.\n    case \"dev-v1\":\n    case \"from-registry-v1\":\n    case \"from-registry-v2\":\n      return undefined;\n  }\n}\n\n/**\n * Turn a project into a template document.\n *\n * Assembly is deliberately dull — the entry is the block's id, its widened kind\n * reference, and the params the walk already collected. The interesting decisions\n * were made upstream; what is left here is the two things only this layer can\n * check, both of which produce problems rather than a broken file:\n *\n * - **A block with no kind cannot be written.** An entry's `kind` is required — it\n *   is the params contract the entry is typed against — while a block's kind is\n *   optional, so a block that predates kinds, or that uses the deprecated\n *   kind-less model overload, has no legal entry. Reported per block. This is not\n *   an edge case today: it is what most existing projects will hit until their\n *   blocks are republished.\n * - **References must point at an entry declared earlier.** Verbatim id reuse\n *   means a reference to a deleted block survives into the file naming nothing:\n *   deleting a block only removes it from the structure and does not rewrite\n *   downstream args, so a live project holds such references routinely.\n *\n * `block` is never emitted. That override exists to pin an implementation against\n * a kind's version range, and export always writes the exact version the block\n * implements, so there is nothing left for it to pin.\n *\n * `location` IS emitted, for every block that was installed from the filesystem. Such\n * a block is not in any registry, so the kind reference alone names nothing the\n * importer could find, and a file that omitted the one usable answer would describe a\n * project that cannot be recreated. It costs portability, and nothing says so: such a\n * file is the debugging path, read by the developer who wrote it on the machine that\n * wrote it.\n *\n * Problems from `walk` are carried through, so a caller can hand a walk straight\n * in and get one combined list.\n */\nexport function assembleProjectTemplateV1(\n  walk: TemplateExportWalk,\n  kindProvider: BlockKindProvider,\n  specProvider: BlockPackSpecProvider,\n): { document: ProjectTemplateV1; problems: readonly TemplateExportProblem[] } {\n  const problems: TemplateExportProblem[] = [...walk.problems];\n  const blocks: ProjectTemplateV1Entry[] = [];\n\n  for (const entry of walk.entries) {\n    const kind = kindProvider(entry.blockId);\n\n    if (kind === undefined) {\n      problems.push({\n        blockId: entry.blockId,\n        error:\n          \"Block declares no kind, so it cannot be written to a template: an entry's kind \" +\n          \"carries the params contract the entry is typed against\",\n      });\n      continue;\n    }\n\n    let selector: BlockKindSelectorReference;\n    try {\n      // Widening validates, and therefore throws — which is why it happens here\n      // and not where the reference is read: every read site sits inside a\n      // recomputed project overview, where one malformed stored reference must not\n      // be able to break unrelated blocks.\n      selector = kindReferenceToSelectorReference(kind);\n    } catch (e) {\n      problems.push({\n        blockId: entry.blockId,\n        error: `Block's stored kind reference is malformed: ${e instanceof Error ? e.message : String(e)}`,\n      });\n      continue;\n    }\n\n    const spec = specProvider(entry.blockId);\n    const location = spec === undefined ? undefined : locationOf(spec);\n\n    blocks.push({\n      id: entry.blockId,\n      kind: selector,\n      params: entry.params,\n      ...(location !== undefined ? { location } : {}),\n    });\n  }\n\n  // References are not examined. A project's structure is topological by construction, so an\n  // entry cannot legally reference one below it — and checking would mean reading the params,\n  // which only the block that wrote them can do.\n  const document: ProjectTemplateV1 = { schema: PROJECT_TEMPLATE_SCHEMA_V1, blocks };\n\n  return { document, problems };\n}\n\n/**\n * Render a template document to YAML text.\n *\n * Two non-default emitter settings, both about the file being read by someone\n * else's code:\n *\n * - **No line folding.** A wrapped scalar still parses, but it makes a diff between\n *   two exported templates unreadable, which is most of the reason to prefer YAML\n *   over JSON here.\n * - **Quote as if the reader were YAML 1.1**, while still parsing as 1.2. YAML 1.2\n *   dropped `yes`/`no`/`on`/`off`/`y`/`n` as booleans and dropped sexagesimal\n *   integers, so a 1.2 emitter leaves a params value of `\"yes\"` or `\"1:30\"` bare —\n *   which a 1.1 reader (PyYAML's default, and Go's yaml.v2) turns into `true` and\n *   `90`. A template is a contract for a second implementation, so the safe\n *   combination is to quote against the stricter ruleset and read with the looser\n *   one: a quoted scalar means the same thing under both. This adds no `%YAML`\n *   directive — it only changes which scalars get quotes.\n */\nexport function stringifyProjectTemplateV1(document: ProjectTemplateV1): string {\n  return YAML.stringify(document, { lineWidth: 0, version: \"1.1\" });\n}\n\n/**\n * Export a project as `template-v1` YAML, or report every reason it cannot be.\n *\n * All-or-nothing on purpose. A partial template silently drops blocks and the\n * surviving entries may reference the dropped ones, so what looks like a\n * successful export would produce a project missing pieces the user never chose\n * to leave out. Reporting everything at once instead of failing on the first\n * problem is the other half of that: fixing an export should take one pass.\n *\n * @param structure The project structure, which supplies both membership and order\n * @param paramsProvider A block's derived template params, in live form\n * @param kindProvider A block's exact kind reference, read from its stored config\n * @param specProvider A block's origin spec, read from the same stored container\n */\nexport function exportProjectAsTemplateV1(\n  structure: ProjectStructure,\n  paramsProvider: (blockId: string) => TemplateParamsResult | undefined,\n  kindProvider: BlockKindProvider,\n  specProvider: BlockPackSpecProvider,\n): ProjectTemplateExportOutcome {\n  const walk = walkProjectForTemplateExport(structure, paramsProvider);\n  const { document, problems } = assembleProjectTemplateV1(walk, kindProvider, specProvider);\n\n  if (problems.length > 0) return { ok: false, problems };\n\n  // Export must emit exactly what import parses, so that is asserted on every\n  // export rather than only in tests — running the import-side parser over the\n  // document we are about to write is the cheapest possible proof of it. Nothing\n  // user-facing is expected to fail here: the kind grammar was checked by the\n  // widening above, params were checked to be a mapping by the walk, and the\n  // reference rules by the assembler. A throw means a bug in the assembler, with\n  // one known exception: a project structure holding two blocks with the same id,\n  // which is reachable through the mutator and produces duplicate entry ids.\n  parseProjectTemplateV1(document);\n\n  return {\n    ok: true,\n    yaml: stringifyProjectTemplateV1(document),\n    document,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAiEA,SAAgB,WAAW,MAA6D;CACtF,QAAQ,KAAK,MAAb;EACE,KAAK,UACH,OAAO,cAAc,KAAK,MAAM,CAAC,CAAC;EACpC,KAAK,gBACH,OAAO,KAAK;EAId,KAAK;EACL,KAAK;EACL,KAAK,oBACH;CACJ;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,0BACd,MACA,cACA,cAC6E;CAC7E,MAAM,WAAoC,CAAC,GAAG,KAAK,QAAQ;CAC3D,MAAM,SAAmC,CAAC;CAE1C,KAAK,MAAM,SAAS,KAAK,SAAS;EAChC,MAAM,OAAO,aAAa,MAAM,OAAO;EAEvC,IAAI,SAAS,KAAA,GAAW;GACtB,SAAS,KAAK;IACZ,SAAS,MAAM;IACf,OACE;GAEJ,CAAC;GACD;EACF;EAEA,IAAI;EACJ,IAAI;GAKF,WAAW,iCAAiC,IAAI;EAClD,SAAS,GAAG;GACV,SAAS,KAAK;IACZ,SAAS,MAAM;IACf,OAAO,+CAA+C,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC;GACjG,CAAC;GACD;EACF;EAEA,MAAM,OAAO,aAAa,MAAM,OAAO;EACvC,MAAM,WAAW,SAAS,KAAA,IAAY,KAAA,IAAY,WAAW,IAAI;EAEjE,OAAO,KAAK;GACV,IAAI,MAAM;GACV,MAAM;GACN,QAAQ,MAAM;GACd,GAAI,aAAa,KAAA,IAAY,EAAE,SAAS,IAAI,CAAC;EAC/C,CAAC;CACH;CAOA,OAAO;EAAE,UAAA;GAF6B,QAAQ;GAA4B;EAE1D;EAAG;CAAS;AAC9B;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,2BAA2B,UAAqC;CAC9E,OAAO,KAAK,UAAU,UAAU;EAAE,WAAW;EAAG,SAAS;CAAM,CAAC;AAClE;;;;;;;;;;;;;;;AAgBA,SAAgB,0BACd,WACA,gBACA,cACA,cAC8B;CAE9B,MAAM,EAAE,UAAU,aAAa,0BADlB,6BAA6B,WAAW,cACO,GAAG,cAAc,YAAY;CAEzF,IAAI,SAAS,SAAS,GAAG,OAAO;EAAE,IAAI;EAAO;CAAS;CAUtD,uBAAuB,QAAQ;CAE/B,OAAO;EACL,IAAI;EACJ,MAAM,2BAA2B,QAAQ;EACzC;CACF;AACF"}

package/dist/mutator/block-pack/block_pack.cjs

@@ -13,9 +13,9 @@ let _platforma_sdk_block_tools = require("@platforma-sdk/block-tools");
 let node_fs = require("node:fs");
 node_fs = require_runtime.__toESM(node_fs, 1);
 let _milaboratories_ts_helpers = require("@milaboratories/ts-helpers");
+let node_url = require("node:url");
 let _milaboratories_pl_client = require("@milaboratories/pl-client");
 let lru_cache = require("lru-cache");
-let node_url = require("node:url");
 let canonicalize = require("canonicalize");
 canonicalize = require_runtime.__toESM(canonicalize, 1);
 let zod = require("zod");

package/dist/mutator/block-pack/block_pack.js

@@ -11,9 +11,9 @@ import { request } from "undici";
 import { RegistryV1, loadPackDescription, loadPackDescriptionFromManifest } from "@platforma-sdk/block-tools";
 import fs from "node:fs";
 import { assertNever } from "@milaboratories/ts-helpers";
+import { fileURLToPath } from "node:url";
 import { field } from "@milaboratories/pl-client";
 import { LRUCache } from "lru-cache";
-import { fileURLToPath } from "node:url";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 //#region src/mutator/block-pack/block_pack.ts

package/dist/mutator/migration.cjs

@@ -2,8 +2,8 @@ const require_project_model = require("../model/project_model.cjs");
 const require_project_model_util = require("../model/project_model_util.cjs");
 const require_project_model_v1 = require("../model/project_model_v1.cjs");
 let _milaboratories_ts_helpers = require("@milaboratories/ts-helpers");
-let _milaboratories_pl_client = require("@milaboratories/pl-client");
 let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
+let _milaboratories_pl_client = require("@milaboratories/pl-client");
 //#region src/mutator/migration.ts
 /**
 * Migrates the project to the latest schema version.

package/dist/mutator/migration.js

@@ -2,8 +2,8 @@ import { ProjectStructureKey, SchemaVersionKey, projectFieldName } from "../mode
 import { allBlocks } from "../model/project_model_util.js";
 import { BlockFrontendStateKeyPrefixV1 } from "../model/project_model_v1.js";
 import { cachedDeserialize } from "@milaboratories/ts-helpers";
-import { field, isNullSignedResourceId } from "@milaboratories/pl-client";
 import { UiError } from "@milaboratories/pl-model-common";
+import { field, isNullSignedResourceId } from "@milaboratories/pl-client";
 //#region src/mutator/migration.ts
 /**
 * Migrates the project to the latest schema version.

package/dist/mutator/project.cjs

@@ -5,6 +5,7 @@ const require_template_loading = require("./template/template_loading.cjs");
 const require_block_pack = require("./block-pack/block_pack.cjs");
 const require_project_model_util = require("../model/project_model_util.cjs");
 const require_context_export = require("./context_export.cjs");
+const require_template_serializer = require("../model/template_serializer.cjs");
 const require_index = require("../debug/index.cjs");
 let _platforma_sdk_model = require("@platforma-sdk/model");
 let _milaboratories_pl_model_middle_layer = require("@milaboratories/pl-model-middle-layer");
@@ -48,12 +49,14 @@ var BlockInfo = class {
 	fields;
 	config;
 	source;
+	kind;
 	logger;
-	constructor(id, fields, config, source, logger = new _milaboratories_ts_helpers.ConsoleLoggerAdapter()) {
+	constructor(id, fields, config, source, kind, logger = new _milaboratories_ts_helpers.ConsoleLoggerAdapter()) {
 		this.id = id;
 		this.fields = fields;
 		this.config = config;
 		this.source = source;
+		this.kind = kind;
 		this.logger = logger;
 	}
 	check() {
@@ -243,6 +246,32 @@ var ProjectMutator = class ProjectMutator {
 			enrichmentTargets: this.projectHelper.getEnrichmentTargets(() => bInfo.config, () => args)
 		};
 	}
+	/**
+	* Render this project as a `template-v1` YAML document, or report every reason it
+	* cannot be.
+	*
+	* Read-only: it derives params in the VM and touches no field, so a `withProject`
+	* wrapper sees `wasModified === false` and skips the commit.
+	*
+	* This is where the three providers the serializer needs come from, and all are
+	* only reachable here. A block's storage lives behind `BlockInfo`, which is
+	* populated by the loader's batched round-trips, and both its kind reference and
+	* its origin spec are read off the block-pack container during that same load —
+	* `config` cannot carry the kind, since `extractConfig` normalizes the render
+	* envelope one level below it, and the spec is not part of the config at all.
+	*/
+	exportAsTemplateV1() {
+		return require_template_serializer.exportProjectAsTemplateV1(this.struct, (blockId) => this.deriveTemplateParams(blockId), (blockId) => this.blockInfos.get(blockId)?.kind, (blockId) => this.blockInfos.get(blockId)?.source);
+	}
+	deriveTemplateParams(blockId) {
+		const info = this.blockInfos.get(blockId);
+		if (info === void 0) return void 0;
+		const storageJson = info.blockStorageJson;
+		if (storageJson === void 0) return void 0;
+		const derived = this.projectHelper.deriveTemplateParamsFromStorage(info.config, storageJson);
+		if (derived.error !== void 0) return { error: derived.error.message };
+		return { value: derived.value };
+	}
 	getPendingProductionGraph() {
 		if (this.pendingProductionGraph === void 0) this.pendingProductionGraph = require_project_model_util.productionGraph(this.struct, (blockId) => this.getProductionGraphBlockInfo(blockId, false));
 		return this.pendingProductionGraph;
@@ -601,7 +630,7 @@ var ProjectMutator = class ProjectMutator {
 		if (this.blocksInLimbo.delete(blockId)) this.renderingStateChanged = true;
 	}
 	initializeNewBlock(blockId, spec) {
-		const info = new BlockInfo(blockId, {}, (0, _platforma_sdk_model.extractConfig)(spec.blockPack.config), spec.blockPack.source, this.projectHelper.logger);
+		const info = new BlockInfo(blockId, {}, (0, _platforma_sdk_model.extractConfig)(spec.blockPack.config), spec.blockPack.source, spec.blockPack.config.kind, this.projectHelper.logger);
 		this.blockInfos.set(blockId, info);
 		const bp = require_block_pack.createBlockPack(this.tx, spec.blockPack);
 		this.setBlockField(blockId, "blockPack", _milaboratories_pl_client.Pl.wrapInHolder(this.tx, bp), "NotReady");
@@ -611,7 +640,7 @@ var ProjectMutator = class ProjectMutator {
 		let prerunArgs;
 		let storageToWrite;
 		if (spec.storageMode === "fromModel") {
-			storageToWrite = this.projectHelper.getInitialStorageInVM(blockConfig);
+			storageToWrite = spec.initialStorage ?? this.projectHelper.getInitialStorageInVM(blockConfig);
 			prerunArgs = this.projectHelper.derivePrerunArgsFromStorage(blockConfig, storageToWrite);
 			const deriveArgsResult = this.projectHelper.deriveArgsFromStorage(blockConfig, storageToWrite);
 			args = deriveArgsResult.error ? void 0 : deriveArgsResult.value;
@@ -647,7 +676,7 @@ var ProjectMutator = class ProjectMutator {
 		]));
 	}
 	initializeBlockDuplicate(blockId, originalBlockInfo) {
-		const info = new BlockInfo(blockId, {}, originalBlockInfo.config, originalBlockInfo.source, this.projectHelper.logger);
+		const info = new BlockInfo(blockId, {}, originalBlockInfo.config, originalBlockInfo.source, originalBlockInfo.kind, this.projectHelper.logger);
 		this.blockInfos.set(blockId, info);
 		const fieldNamesToDuplicate = this.getFieldNamesToDuplicate(blockId);
 		for (const [fieldName, fieldState] of Object.entries(originalBlockInfo.fields)) if (fieldNamesToDuplicate.has(fieldName) && fieldState && fieldState.ref) this.setBlockFieldObj(blockId, fieldName, {
@@ -990,6 +1019,7 @@ var ProjectMutator = class ProjectMutator {
 		for (const [info, response] of blockPackRequests) {
 			const bpInfo = (0, _milaboratories_ts_helpers.cachedDeserialize)((0, _milaboratories_ts_helpers.notEmpty)((await response).data));
 			info.blockConfig = (0, _platforma_sdk_model.extractConfig)(bpInfo.config);
+			info.blockKind = bpInfo.config.kind;
 			info.blockPack = bpInfo.source;
 		}
 		const ctxExportTplEnvelope = await require_context_export.getPreparedExportTemplateEnvelope();
@@ -1004,7 +1034,7 @@ var ProjectMutator = class ProjectMutator {
 		const renderingState = { stagingRefreshTimestamp };
 		const blocksInLimboSet = new Set(blocksInLimbo);
 		const blockInfos = /* @__PURE__ */ new Map();
-		blockInfoStates.forEach(({ id, fields, blockConfig, blockPack }) => blockInfos.set(id, new BlockInfo(id, fields, (0, _milaboratories_ts_helpers.notEmpty)(blockConfig), (0, _milaboratories_ts_helpers.notEmpty)(blockPack), projectHelper.logger)));
+		blockInfoStates.forEach(({ id, fields, blockConfig, blockKind, blockPack }) => blockInfos.set(id, new BlockInfo(id, fields, (0, _milaboratories_ts_helpers.notEmpty)(blockConfig), (0, _milaboratories_ts_helpers.notEmpty)(blockPack), blockKind, projectHelper.logger)));
 		const blockInStruct = /* @__PURE__ */ new Set();
 		for (const b of require_project_model_util.allBlocks(structure)) {
 			if (!blockInfos.has(b.id)) throw new Error(`Inconsistent project structure: no inputs for ${b.id}`);