@platforma-open/milaboratories.sort-seq-analysis.block 1.0.3 → 1.0.5

package/dist/index.js

@@ -1,26 +1,4 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
+import { r as __toESM, t as __commonJSMin } from "./rolldown-runtime-DC62tzP2.js";
 //#region ../model/dist/columns.js
 /** Annotation keys this block reads on upstream columns. */
 const Annotation$1 = {
@@ -36,6 +14,8 @@ const PColumnName$1 = {
 	MutationCount: "pl7.app/repertoire/mutationCount",
 	/** The variant axis's label column — shown as "Variant Id". */
 	VariantLabel: "pl7.app/label",
+	/** The **sample** axis's label column. Same name as `VariantLabel`; the axis picks one. */
+	SampleLabel: "pl7.app/label",
 	/** The per-variant mutation list, shown as "Mutations". */
 	Mutations: "pl7.app/repertoire/mutations"
 };
@@ -103,16 +83,28 @@ const metadataSelector = {
 	}],
 	name: PColumnName$1.Metadata
 };
+/**
+* The sample axis's label column. `pl7.app/isLabel` is required alongside the name, which the
+* variant label column shares.
+*/
+const sampleLabelSelector = {
+	axes: [{
+		anchor: "main",
+		idx: 0
+	}],
+	name: PColumnName$1.SampleLabel,
+	annotations: { "pl7.app/isLabel": "true" }
+};
 PColumnName$1.MutationCount;
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/plugin_handle.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/plugin_handle.js
 const PLUGIN_OUTPUT_PREFIX = "plugin-output#";
 /** Construct the output key for a plugin output in the block outputs map. */
 function pluginOutputKey(handle, outputKey) {
 	return `${PLUGIN_OUTPUT_PREFIX}${handle}#${outputKey}`;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/block_storage.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_storage.js
 /**
 * Discriminator key for BlockStorage format detection.
 * This unique hash-based key identifies data as BlockStorage vs legacy formats.
@@ -354,1355 +346,727 @@ function getPluginData(rawStorage, handle) {
 	return pluginEntry.__data;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/block_migrations.js
-/** Create a DataVersioned wrapper with correct shape */
-function makeVersionedData(version, data) {
-	return {
-		version,
-		data
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
+var util;
+(function(util) {
+	util.assertEqual = (_) => {};
+	function assertIs(_arg) {}
+	util.assertIs = assertIs;
+	function assertNever(_x) {
+		throw new Error();
+	}
+	util.assertNever = assertNever;
+	util.arrayToEnum = (items) => {
+		const obj = {};
+		for (const item of items) obj[item] = item;
+		return obj;
 	};
-}
-/** Thrown by recover() to signal unrecoverable data. */
-var DataUnrecoverableError = class extends Error {
-	name = "DataUnrecoverableError";
-	constructor(dataVersion) {
-		super(`Unknown version '${dataVersion}'`);
+	util.getValidEnumValues = (obj) => {
+		const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+		const filtered = {};
+		for (const k of validKeys) filtered[k] = obj[k];
+		return util.objectValues(filtered);
+	};
+	util.objectValues = (obj) => {
+		return util.objectKeys(obj).map(function(e) {
+			return obj[e];
+		});
+	};
+	util.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+		const keys = [];
+		for (const key in object) if (Object.prototype.hasOwnProperty.call(object, key)) keys.push(key);
+		return keys;
+	};
+	util.find = (arr, checker) => {
+		for (const item of arr) if (checker(item)) return item;
+	};
+	util.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+	function joinValues(array, separator = " | ") {
+		return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+	}
+	util.joinValues = joinValues;
+	util.jsonStringifyReplacer = (_, value) => {
+		if (typeof value === "bigint") return value.toString();
+		return value;
+	};
+})(util || (util = {}));
+var objectUtil;
+(function(objectUtil) {
+	objectUtil.mergeShapes = (first, second) => {
+		return {
+			...first,
+			...second
+		};
+	};
+})(objectUtil || (objectUtil = {}));
+const ZodParsedType = util.arrayToEnum([
+	"string",
+	"nan",
+	"number",
+	"integer",
+	"float",
+	"boolean",
+	"date",
+	"bigint",
+	"symbol",
+	"function",
+	"undefined",
+	"null",
+	"array",
+	"object",
+	"unknown",
+	"promise",
+	"void",
+	"never",
+	"map",
+	"set"
+]);
+const getParsedType = (data) => {
+	switch (typeof data) {
+		case "undefined": return ZodParsedType.undefined;
+		case "string": return ZodParsedType.string;
+		case "number": return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+		case "boolean": return ZodParsedType.boolean;
+		case "function": return ZodParsedType.function;
+		case "bigint": return ZodParsedType.bigint;
+		case "symbol": return ZodParsedType.symbol;
+		case "object":
+			if (Array.isArray(data)) return ZodParsedType.array;
+			if (data === null) return ZodParsedType.null;
+			if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") return ZodParsedType.promise;
+			if (typeof Map !== "undefined" && data instanceof Map) return ZodParsedType.map;
+			if (typeof Set !== "undefined" && data instanceof Set) return ZodParsedType.set;
+			if (typeof Date !== "undefined" && data instanceof Date) return ZodParsedType.date;
+			return ZodParsedType.object;
+		default: return ZodParsedType.unknown;
 	}
 };
-function isDataUnrecoverableError(error) {
-	return error instanceof Error && error.name === "DataUnrecoverableError";
-}
-/**
-* Default recover function for unknown versions.
-* Use as fallback at the end of custom recover functions.
-*
-* @example
-* .recover((version, data) => {
-*   if (version === 'legacy') {
-*     return transformLegacyData(data);
-*   }
-*   return defaultRecover(version, data);
-* })
-*/
-const defaultRecover = (version, _data) => {
-	throw new DataUnrecoverableError(version);
-};
-/** Symbol for internal builder creation method */
-const FROM_BUILDER = Symbol("fromBuilder");
-/**
-* Abstract base for both migration chain types.
-* Holds shared state, buildStep() helper, and init().
-* migrate() cannot be shared due to a TypeScript limitation: when the base class
-* migrate() return type is abstract, subclasses cannot narrow it without losing type safety.
-* Each subclass therefore owns its migrate() with the correct concrete return type.
-*
-* @internal
-*/
-var MigrationChainBase = class {
-	versionChain;
-	migrationSteps;
-	transferSteps;
-	constructor(state) {
-		this.versionChain = state.versionChain;
-		this.migrationSteps = state.steps;
-		this.transferSteps = state.transferSteps ?? [];
+//#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.js
+const ZodIssueCode = util.arrayToEnum([
+	"invalid_type",
+	"invalid_literal",
+	"custom",
+	"invalid_union",
+	"invalid_union_discriminator",
+	"invalid_enum_value",
+	"unrecognized_keys",
+	"invalid_arguments",
+	"invalid_return_type",
+	"invalid_date",
+	"invalid_string",
+	"too_small",
+	"too_big",
+	"invalid_intersection_types",
+	"not_multiple_of",
+	"not_finite"
+]);
+var ZodError = class ZodError extends Error {
+	get errors() {
+		return this.issues;
 	}
-	/** Appends a migration step and returns the new versionChain and steps arrays. */
-	buildStep(nextVersion, fn) {
-		if (this.versionChain.includes(nextVersion)) throw new Error(`Duplicate version '${nextVersion}' in migration chain`);
-		const step = {
-			fromVersion: this.versionChain[this.versionChain.length - 1],
-			toVersion: nextVersion,
-			migrate: fn
+	constructor(issues) {
+		super();
+		this.issues = [];
+		this.addIssue = (sub) => {
+			this.issues = [...this.issues, sub];
 		};
-		return {
-			versionChain: [...this.versionChain, nextVersion],
-			steps: [...this.migrationSteps, step]
+		this.addIssues = (subs = []) => {
+			this.issues = [...this.issues, ...subs];
 		};
+		const actualProto = new.target.prototype;
+		if (Object.setPrototypeOf) Object.setPrototypeOf(this, actualProto);
+		else this.__proto__ = actualProto;
+		this.name = "ZodError";
+		this.issues = issues;
 	}
-	/** Validates uniqueness and records a TransferStep. */
-	buildTransfer(target, extract) {
-		if (this.transferSteps.some((t) => t.pluginId === target.id)) throw new Error(`Duplicate transfer for plugin '${target.id}'`);
-		const entry = {
-			pluginId: target.id,
-			beforeStepIndex: this.migrationSteps.length,
-			extract,
-			targetVersion: target.transferVersion
+	format(_mapper) {
+		const mapper = _mapper || function(issue) {
+			return issue.message;
 		};
-		return { transferSteps: [...this.transferSteps, entry] };
+		const fieldErrors = { _errors: [] };
+		const processError = (error) => {
+			for (const issue of error.issues) if (issue.code === "invalid_union") issue.unionErrors.map(processError);
+			else if (issue.code === "invalid_return_type") processError(issue.returnTypeError);
+			else if (issue.code === "invalid_arguments") processError(issue.argumentsError);
+			else if (issue.path.length === 0) fieldErrors._errors.push(mapper(issue));
+			else {
+				let curr = fieldErrors;
+				let i = 0;
+				while (i < issue.path.length) {
+					const el = issue.path[i];
+					if (!(i === issue.path.length - 1)) curr[el] = curr[el] || { _errors: [] };
+					else {
+						curr[el] = curr[el] || { _errors: [] };
+						curr[el]._errors.push(mapper(issue));
+					}
+					curr = curr[el];
+					i++;
+				}
+			}
+		};
+		processError(this);
+		return fieldErrors;
 	}
-	/** Returns recover-specific fields for DataModel construction. Overridden by WithRecover. */
-	recoverState() {
-		return {};
+	static assert(value) {
+		if (!(value instanceof ZodError)) throw new Error(`Not a ZodError: ${value}`);
 	}
-	/**
-	* Finalize the DataModel with initial data factory.
-	*
-	* @param initialData - Factory function returning the initial state
-	* @returns Finalized DataModel instance
-	*/
-	init(initialData) {
-		return DataModel[FROM_BUILDER]({
-			versionChain: this.versionChain,
-			steps: this.migrationSteps,
-			transferSteps: this.transferSteps,
-			initialDataFn: initialData,
-			...this.recoverState()
-		});
+	toString() {
+		return this.message;
 	}
-};
-/**
-* Migration chain after recover() or upgradeLegacy() has been called.
-* Further migrate() and transfer() calls are allowed; recover() and upgradeLegacy() are not
-* (enforced by type — no such methods on this class).
-*
-* @typeParam Current - Data type at the current point in the chain
-* @typeParam Transfers - Accumulated transfer types keyed by plugin ID
-* @internal
-*/
-var DataModelMigrationChainWithRecover = class DataModelMigrationChainWithRecover extends MigrationChainBase {
-	recoverFn;
-	recoverFromIndex;
-	/** @internal */
-	constructor(state) {
-		super(state);
-		this.recoverFn = state.recoverFn;
-		this.recoverFromIndex = state.recoverFromIndex;
+	get message() {
+		return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
 	}
-	recoverState() {
+	get isEmpty() {
+		return this.issues.length === 0;
+	}
+	flatten(mapper = (issue) => issue.message) {
+		const fieldErrors = {};
+		const formErrors = [];
+		for (const sub of this.issues) if (sub.path.length > 0) {
+			const firstEl = sub.path[0];
+			fieldErrors[firstEl] = fieldErrors[firstEl] || [];
+			fieldErrors[firstEl].push(mapper(sub));
+		} else formErrors.push(mapper(sub));
 		return {
-			recoverFn: this.recoverFn,
-			recoverFromIndex: this.recoverFromIndex
+			formErrors,
+			fieldErrors
 		};
 	}
-	/**
-	* Add a migration step. Same semantics as on the base chain.
-	* recover() and upgradeLegacy() are not available — one has already been called.
-	*/
-	migrate(nextVersion, fn) {
-		const { versionChain, steps } = this.buildStep(nextVersion, fn);
-		return new DataModelMigrationChainWithRecover({
-			versionChain,
-			steps,
-			transferSteps: this.transferSteps,
-			recoverFn: this.recoverFn,
-			recoverFromIndex: this.recoverFromIndex
-		});
+	get formErrors() {
+		return this.flatten();
 	}
-	/**
-	* Extract data at the current chain position for seeding a new plugin.
-	* The extract function's return type must match the plugin's transfer data type.
-	* Duplicate plugin IDs are rejected at both type and runtime level.
-	*/
-	transfer(target, extract) {
-		const { transferSteps } = this.buildTransfer(target, extract);
-		return new DataModelMigrationChainWithRecover({
-			versionChain: this.versionChain,
-			steps: this.migrationSteps,
-			transferSteps,
-			recoverFn: this.recoverFn,
-			recoverFromIndex: this.recoverFromIndex
-		});
+};
+ZodError.create = (issues) => {
+	return new ZodError(issues);
+};
+//#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/locales/en.js
+const errorMap = (issue, _ctx) => {
+	let message;
+	switch (issue.code) {
+		case ZodIssueCode.invalid_type:
+			if (issue.received === ZodParsedType.undefined) message = "Required";
+			else message = `Expected ${issue.expected}, received ${issue.received}`;
+			break;
+		case ZodIssueCode.invalid_literal:
+			message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
+			break;
+		case ZodIssueCode.unrecognized_keys:
+			message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
+			break;
+		case ZodIssueCode.invalid_union:
+			message = `Invalid input`;
+			break;
+		case ZodIssueCode.invalid_union_discriminator:
+			message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
+			break;
+		case ZodIssueCode.invalid_enum_value:
+			message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
+			break;
+		case ZodIssueCode.invalid_arguments:
+			message = `Invalid function arguments`;
+			break;
+		case ZodIssueCode.invalid_return_type:
+			message = `Invalid function return type`;
+			break;
+		case ZodIssueCode.invalid_date:
+			message = `Invalid date`;
+			break;
+		case ZodIssueCode.invalid_string:
+			if (typeof issue.validation === "object") {
+				if ("includes" in issue.validation) {
+					message = `Invalid input: must include "${issue.validation.includes}"`;
+					if (typeof issue.validation.position === "number") message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+				} else if ("startsWith" in issue.validation) message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+				else if ("endsWith" in issue.validation) message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+				else util.assertNever(issue.validation);
+			} else if (issue.validation !== "regex") message = `Invalid ${issue.validation}`;
+			else message = "Invalid";
+			break;
+		case ZodIssueCode.too_small:
+			if (issue.type === "array") message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+			else if (issue.type === "string") message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+			else if (issue.type === "number") message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+			else if (issue.type === "bigint") message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+			else if (issue.type === "date") message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
+			else message = "Invalid input";
+			break;
+		case ZodIssueCode.too_big:
+			if (issue.type === "array") message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+			else if (issue.type === "string") message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+			else if (issue.type === "number") message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+			else if (issue.type === "bigint") message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+			else if (issue.type === "date") message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
+			else message = "Invalid input";
+			break;
+		case ZodIssueCode.custom:
+			message = `Invalid input`;
+			break;
+		case ZodIssueCode.invalid_intersection_types:
+			message = `Intersection results could not be merged`;
+			break;
+		case ZodIssueCode.not_multiple_of:
+			message = `Number must be a multiple of ${issue.multipleOf}`;
+			break;
+		case ZodIssueCode.not_finite:
+			message = "Number must be finite";
+			break;
+		default:
+			message = _ctx.defaultError;
+			util.assertNever(issue);
 	}
+	return { message };
 };
-/**
-* Migration chain builder.
-* Each migrate() call advances the current data type. recover() can be called once
-* at any point — it removes itself from the returned chain so it cannot be called again.
-* Duplicate version keys throw at runtime.
-*
-* @typeParam Current - Data type at the current point in the migration chain
-* @typeParam Transfers - Accumulated transfer types keyed by plugin ID
-* @internal
-*/
-var DataModelMigrationChain = class DataModelMigrationChain extends MigrationChainBase {
-	/** @internal */
-	constructor({ versionChain, steps = [], transferSteps = [] }) {
-		super({
-			versionChain,
-			steps,
-			transferSteps
-		});
+//#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/errors.js
+let overrideErrorMap = errorMap;
+function getErrorMap() {
+	return overrideErrorMap;
+}
+//#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
+const makeIssue = (params) => {
+	const { data, path, errorMaps, issueData } = params;
+	const fullPath = [...path, ...issueData.path || []];
+	const fullIssue = {
+		...issueData,
+		path: fullPath
+	};
+	if (issueData.message !== void 0) return {
+		...issueData,
+		path: fullPath,
+		message: issueData.message
+	};
+	let errorMessage = "";
+	const maps = errorMaps.filter((m) => !!m).slice().reverse();
+	for (const map of maps) errorMessage = map(fullIssue, {
+		data,
+		defaultError: errorMessage
+	}).message;
+	return {
+		...issueData,
+		path: fullPath,
+		message: errorMessage
+	};
+};
+function addIssueToContext(ctx, issueData) {
+	const overrideMap = getErrorMap();
+	const issue = makeIssue({
+		issueData,
+		data: ctx.data,
+		path: ctx.path,
+		errorMaps: [
+			ctx.common.contextualErrorMap,
+			ctx.schemaErrorMap,
+			overrideMap,
+			overrideMap === errorMap ? void 0 : errorMap
+		].filter((x) => !!x)
+	});
+	ctx.common.issues.push(issue);
+}
+var ParseStatus = class ParseStatus {
+	constructor() {
+		this.value = "valid";
 	}
-	/**
-	* Add a migration step transforming data from the current version to the next.
-	*
-	* @typeParam Next - Data type of the next version
-	* @param nextVersion - Version key to migrate to (must be unique in the chain)
-	* @param fn - Migration function
-	* @returns Builder with the next version as current
-	*
-	* @example
-	* .migrate<BlockDataV2>("v2", (v1) => ({ ...v1, labels: [] }))
-	*/
-	migrate(nextVersion, fn) {
-		const { versionChain, steps } = this.buildStep(nextVersion, fn);
-		return new DataModelMigrationChain({
-			versionChain,
-			steps,
-			transferSteps: this.transferSteps
-		});
+	dirty() {
+		if (this.value === "valid") this.value = "dirty";
 	}
-	/**
-	* Extract data at the current chain position for seeding a new plugin.
-	* The extract function's return type must match the plugin's transfer data type.
-	* Duplicate plugin IDs are rejected at both type and runtime level.
-	*
-	* Calling .transfer() on DataModelInitialChain returns DataModelMigrationChain,
-	* which removes .upgradeLegacy() from the chain (preventing a problematic combination).
-	*
-	* @example
-	* .from<V1>("v1")
-	* .transfer(tablePlugin, (v1) => ({ state: v1.tableState }))
-	* .migrate<V2>("v2", ({ tableState: _, ...rest }) => rest)
-	*/
-	transfer(target, extract) {
-		const { transferSteps } = this.buildTransfer(target, extract);
-		return new DataModelMigrationChain({
-			versionChain: this.versionChain,
-			steps: this.migrationSteps,
-			transferSteps
-		});
+	abort() {
+		if (this.value !== "aborted") this.value = "aborted";
 	}
-	/**
-	* Set a recovery handler for unknown or legacy versions.
-	*
-	* The recover function is called when data has a version not in the migration chain.
-	* It must return data of the type at this point in the chain (Current). Any migrate()
-	* steps added after recover() will then run on the recovered data.
-	*
-	* Can only be called once — the returned chain has no recover() method.
-	*
-	* @param fn - Recovery function returning Current (the type at this chain position)
-	* @returns Builder with migrate() and init() but without recover()
-	*
-	* @example
-	* // Recover between migrations — recovered data goes through v3 migration
-	* new DataModelBuilder<V1>("v1")
-	*   .migrate<V2>("v2", (v1) => ({ ...v1, label: "" }))
-	*   .recover((version, data) => {
-	*     if (version === 'legacy') return transformLegacy(data); // returns V2
-	*     return defaultRecover(version, data);
-	*   })
-	*   .migrate<V3>("v3", (v2) => ({ ...v2, description: "" }))
-	*   .init(() => ({ count: 0, label: "", description: "" }));
-	*/
-	recover(fn) {
-		return new DataModelMigrationChainWithRecover({
-			versionChain: this.versionChain,
-			steps: this.migrationSteps,
-			transferSteps: this.transferSteps,
-			recoverFn: fn,
-			recoverFromIndex: this.migrationSteps.length
-		});
-	}
-};
-/**
-* Initial migration chain returned by `.from()`.
-* Extends DataModelMigrationChain with `upgradeLegacy()` — available only before
-* any `.migrate()` calls, since legacy data always arrives at the initial version.
-*
-* @typeParam Current - Data type at the initial version
-* @typeParam Transfers - Accumulated transfer types keyed by plugin ID
-* @internal
-*/
-var DataModelInitialChain = class extends DataModelMigrationChain {
-	/**
-	* Handle legacy V1 model state ({ args, uiState }) when upgrading a block from
-	* BlockModel V1 to BlockModelV3.
-	*
-	* When a V1 block is upgraded, its stored state `{ args, uiState }` is normalized
-	* to the internal default version. This method inserts a migration step from that
-	* internal version to the version specified in `.from()`, using the provided typed
-	* callback to transform the legacy shape. Non-legacy data passes through unchanged.
-	*
-	* Must be called right after `.from()` — not available after `.migrate()` calls.
-	* Any `.migrate()` steps added after `upgradeLegacy()` will run on the transformed result.
-	*
-	* Can only be called once — the returned chain has no upgradeLegacy() method.
-	* Mutually exclusive with recover().
-	*
-	* @typeParam Args - Type of the legacy block args
-	* @typeParam UiState - Type of the legacy block uiState
-	* @param fn - Typed transform from { args, uiState } to Current
-	* @returns Builder with migrate() and init() but without recover() or upgradeLegacy()
-	*
-	* @example
-	* type OldArgs = { inputFile: string; threshold: number };
-	* type OldUiState = { selectedTab: string };
-	* type BlockData = { inputFile: string; threshold: number; selectedTab: string };
-	*
-	* const dataModel = new DataModelBuilder()
-	*   .from<BlockData>("v1")
-	*   .upgradeLegacy<OldArgs, OldUiState>(({ args, uiState }) => ({
-	*     inputFile: args.inputFile,
-	*     threshold: args.threshold,
-	*     selectedTab: uiState.selectedTab,
-	*   }))
-	*   .init(() => ({ inputFile: '', threshold: 0, selectedTab: 'main' }));
-	*/
-	upgradeLegacy(fn) {
-		const wrappedFn = (data) => {
-			if (data !== null && typeof data === "object" && "args" in data) return fn(data);
-			return data;
-		};
-		const step = {
-			fromVersion: DATA_MODEL_LEGACY_VERSION,
-			toVersion: this.versionChain[0],
-			migrate: wrappedFn
+	static mergeArray(status, results) {
+		const arrayValue = [];
+		for (const s of results) {
+			if (s.status === "aborted") return INVALID;
+			if (s.status === "dirty") status.dirty();
+			arrayValue.push(s.value);
+		}
+		return {
+			status: status.value,
+			value: arrayValue
 		};
-		return new DataModelMigrationChainWithRecover({
-			versionChain: [DATA_MODEL_LEGACY_VERSION, ...this.versionChain],
-			steps: [step, ...this.migrationSteps],
-			transferSteps: this.transferSteps.map((t) => ({
-				...t,
-				beforeStepIndex: t.beforeStepIndex + 1
-			}))
-		});
-	}
-};
-/**
-* Builder entry point for creating DataModel with type-safe migrations.
-*
-* @example
-* // Simple (no migrations):
-* const dataModel = new DataModelBuilder()
-*   .from<BlockData>("v1")
-*   .init(() => ({ numbers: [] }));
-*
-* @example
-* // With migrations:
-* const dataModel = new DataModelBuilder()
-*   .from<BlockDataV1>("v1")
-*   .migrate<BlockDataV2>("v2", (v1) => ({ ...v1, labels: [] }))
-*   .migrate<BlockDataV3>("v3", (v2) => ({ ...v2, description: '' }))
-*   .init(() => ({ numbers: [], labels: [], description: '' }));
-*
-* @example
-* // With recover() between migrations — recovered data goes through remaining migrations:
-* const dataModelChain = new DataModelBuilder()
-*   .from<BlockDataV1>("v1")
-*   .migrate<BlockDataV2>("v2", (v1) => ({ ...v1, labels: [] }));
-*
-* // recover() placed before the v3 migration: recovered data goes through v3
-* const dataModel = dataModelChain
-*   .recover((version, data) => {
-*     if (version === 'legacy' && isLegacyData(data)) return transformLegacy(data); // returns V2
-*     return defaultRecover(version, data);
-*   })
-*   .migrate<BlockDataV3>("v3", (v2) => ({ ...v2, description: '' }))
-*   .init(() => ({ numbers: [], labels: [], description: '' }));
-*
-* @example
-* // With upgradeLegacy() — typed upgrade from BlockModel V1 state:
-* type OldArgs = { inputFile: string };
-* type OldUiState = { selectedTab: string };
-* type BlockData = { inputFile: string; selectedTab: string };
-*
-* const dataModel = new DataModelBuilder()
-*   .from<BlockData>("v1")
-*   .upgradeLegacy<OldArgs, OldUiState>(({ args, uiState }) => ({
-*     inputFile: args.inputFile,
-*     selectedTab: uiState.selectedTab,
-*   }))
-*   .init(() => ({ inputFile: '', selectedTab: 'main' }));
-*/
-var DataModelBuilder = class {
-	/**
-	* Start the migration chain with the given initial data type and version key.
-	*
-	* @typeParam T - Data type for the initial version
-	* @param initialVersion - Version key string (e.g. "v1")
-	* @returns Migration chain builder
-	*/
-	from(initialVersion) {
-		return new DataModelInitialChain({ versionChain: [initialVersion] });
-	}
-};
-/**
-* DataModel defines the block's data structure, initial values, and migrations.
-* Used by BlockModelV3 to manage data state.
-*
-* Use `new DataModelBuilder()` to create a DataModel.
-*
-* @example
-* // With recover() between migrations:
-* // Recovered data (V2) goes through the v2→v3 migration automatically.
-* const dataModel = new DataModelBuilder()
-*   .from<V1>("v1")
-*   .migrate<V2>("v2", (v1) => ({ ...v1, label: "" }))
-*   .recover((version, data) => {
-*     if (version === "legacy") return transformLegacy(data); // returns V2
-*     return defaultRecover(version, data);
-*   })
-*   .migrate<V3>("v3", (v2) => ({ ...v2, description: "" }))
-*   .init(() => ({ count: 0, label: "", description: "" }));
-*/
-var DataModel = class DataModel {
-	/** Latest version key — O(1) access for the common "already current" check. */
-	latestVersion;
-	/** Maps each known version key to the index of the first step to run from it. O(1) lookup. */
-	stepsByFromVersion;
-	steps;
-	transferSteps;
-	initialDataFn;
-	recoverFn;
-	recoverFromIndex;
-	constructor({ versionChain, steps, transferSteps = [], initialDataFn, recoverFn = defaultRecover, recoverFromIndex }) {
-		if (versionChain.length === 0) throw new Error("DataModel requires at least one version key");
-		this.latestVersion = versionChain[versionChain.length - 1];
-		this.stepsByFromVersion = new Map(versionChain.map((v, i) => [v, i]));
-		this.steps = steps;
-		this.transferSteps = transferSteps;
-		this.initialDataFn = initialDataFn;
-		this.recoverFn = recoverFn;
-		this.recoverFromIndex = recoverFromIndex ?? steps.length;
-	}
-	/**
-	* Internal method for creating DataModel from builder.
-	* Uses Symbol key to prevent external access.
-	* @internal
-	*/
-	static [FROM_BUILDER](state) {
-		return new DataModel(state);
-	}
-	/**
-	* The latest (current) version key in the migration chain.
-	*/
-	get version() {
-		return this.latestVersion;
-	}
-	/**
-	* Get a fresh copy of the initial data.
-	*/
-	initialData() {
-		return this.initialDataFn();
 	}
-	/**
-	* Get initial data wrapped with current version.
-	* Used when creating new blocks or resetting to defaults.
-	*/
-	getDefaultData() {
-		return makeVersionedData(this.latestVersion, this.initialDataFn());
+	static async mergeObjectAsync(status, pairs) {
+		const syncPairs = [];
+		for (const pair of pairs) {
+			const key = await pair.key;
+			const value = await pair.value;
+			syncPairs.push({
+				key,
+				value
+			});
+		}
+		return ParseStatus.mergeObjectSync(status, syncPairs);
 	}
-	recoverFrom(data, version) {
-		let currentData = this.recoverFn(version, data);
-		for (let i = this.recoverFromIndex; i < this.steps.length; i++) currentData = this.steps[i].migrate(currentData);
+	static mergeObjectSync(status, pairs) {
+		const finalObject = {};
+		for (const pair of pairs) {
+			const { key, value } = pair;
+			if (key.status === "aborted") return INVALID;
+			if (value.status === "aborted") return INVALID;
+			if (key.status === "dirty") status.dirty();
+			if (value.status === "dirty") status.dirty();
+			if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) finalObject[key.value] = value.value;
+		}
 		return {
-			version: this.latestVersion,
-			data: currentData
+			status: status.value,
+			value: finalObject
 		};
 	}
-	/**
-	* Migrate versioned data from any version to the latest.
-	* Collects transfer extractions at their designated chain positions.
-	*
-	* - If version is in chain, applies needed migrations (O(1) lookup)
-	* - If version is unknown, attempts recovery; falls back to initial data
-	* - If a migration step fails, throws so the caller can preserve original data
-	*
-	* Transfers only fire during normal step-by-step migration:
-	* - Recovery path: returns empty transfers
-	* - Fast-path (already at latest): returns empty transfers
-	*
-	* @param versioned - Data with version tag
-	* @returns Migrated data at the latest version with transfer record
-	* @throws If a migration step from a known version fails
-	*/
-	migrate(versioned) {
-		const { version: fromVersion, data } = versioned;
-		if (fromVersion === this.latestVersion) return {
-			version: this.latestVersion,
-			data,
-			transfers: {}
-		};
-		const startIndex = this.stepsByFromVersion.get(fromVersion);
-		if (startIndex === void 0) try {
-			return {
-				...this.recoverFrom(data, fromVersion),
-				transfers: {}
-			};
-		} catch {
-			return {
-				...this.getDefaultData(),
-				transfers: {}
-			};
-		}
-		let currentData = data;
-		const transfers = {};
-		for (let i = startIndex; i < this.steps.length; i++) {
-			for (const t of this.transferSteps) if (t.beforeStepIndex === i) transfers[t.pluginId] = {
-				version: t.targetVersion,
-				data: t.extract(currentData)
-			};
-			currentData = this.steps[i].migrate(currentData);
+};
+const INVALID = Object.freeze({ status: "aborted" });
+const DIRTY = (value) => ({
+	status: "dirty",
+	value
+});
+const OK = (value) => ({
+	status: "valid",
+	value
+});
+const isAborted = (x) => x.status === "aborted";
+const isDirty = (x) => x.status === "dirty";
+const isValid = (x) => x.status === "valid";
+const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
+//#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.js
+var errorUtil;
+(function(errorUtil) {
+	errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+	errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
+})(errorUtil || (errorUtil = {}));
+//#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
+var ParseInputLazyPath = class {
+	constructor(parent, value, path, key) {
+		this._cachedPath = [];
+		this.parent = parent;
+		this.data = value;
+		this._path = path;
+		this._key = key;
+	}
+	get path() {
+		if (!this._cachedPath.length) {
+			if (Array.isArray(this._key)) this._cachedPath.push(...this._path, ...this._key);
+			else this._cachedPath.push(...this._path, this._key);
 		}
-		for (const t of this.transferSteps) if (t.beforeStepIndex >= this.steps.length && t.beforeStepIndex >= startIndex) transfers[t.pluginId] = {
-			version: t.targetVersion,
-			data: t.extract(currentData)
-		};
+		return this._cachedPath;
+	}
+};
+const handleResult = (ctx, result) => {
+	if (isValid(result)) return {
+		success: true,
+		data: result.value
+	};
+	else {
+		if (!ctx.common.issues.length) throw new Error("Validation failed but no issues detected.");
 		return {
-			version: this.latestVersion,
-			data: currentData,
-			transfers
+			success: false,
+			get error() {
+				if (this._error) return this._error;
+				const error = new ZodError(ctx.common.issues);
+				this._error = error;
+				return this._error;
+			}
 		};
 	}
 };
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/internal.js
-/** Utility code helping to identify whether the code is running in actual UI environment */
-function isInUI() {
-	return typeof globalThis.getPlatforma !== "undefined" || typeof globalThis.platforma !== "undefined";
-}
-/** Utility code helping to retrieve a platforma instance form the environment */
-function getPlatformaInstance(config) {
-	if (config && typeof globalThis.getPlatforma === "function") return globalThis.getPlatforma(config);
-	else if (typeof globalThis.platforma !== "undefined") return globalThis.platforma;
-	else throw new Error("Can't get platforma instance.");
-}
-function tryGetCfgRenderCtx() {
-	if (typeof globalThis.cfgRenderCtx !== "undefined") return globalThis.cfgRenderCtx;
-	else return void 0;
-}
-function getCfgRenderCtx() {
-	if (typeof globalThis.cfgRenderCtx !== "undefined") return globalThis.cfgRenderCtx;
-	else throw new Error("Not in config rendering context");
-}
-function tryRegisterCallback(key, callback) {
-	const ctx = tryGetCfgRenderCtx();
-	if (ctx === void 0) return false;
-	if (key in ctx.callbackRegistry) throw new Error(`Callback with key ${key} already registered.`);
-	ctx.callbackRegistry[key] = callback;
-	return true;
-}
-/**
-* Registers a callback, replacing any existing callback with the same key.
-* Use this for callbacks that have a default value but can be overridden.
-*
-* @param key - The callback registry key
-* @param callback - The callback function to register
-* @returns true if registered, false if not in render context
-*/
-function replaceCallback(key, callback) {
-	const ctx = tryGetCfgRenderCtx();
-	if (ctx === void 0) return false;
-	ctx.callbackRegistry[key] = callback;
-	return true;
-}
-/** Creates a ConfigRenderLambda descriptor without registering a callback. */
-function createRenderLambda(opts) {
-	const { handle, ...flags } = opts;
+function processCreateParams(params) {
+	if (!params) return {};
+	const { errorMap, invalid_type_error, required_error, description } = params;
+	if (errorMap && (invalid_type_error || required_error)) throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+	if (errorMap) return {
+		errorMap,
+		description
+	};
+	const customMap = (iss, ctx) => {
+		const { message } = params;
+		if (iss.code === "invalid_enum_value") return { message: message ?? ctx.defaultError };
+		if (typeof ctx.data === "undefined") return { message: message ?? required_error ?? ctx.defaultError };
+		if (iss.code !== "invalid_type") return { message: ctx.defaultError };
+		return { message: message ?? invalid_type_error ?? ctx.defaultError };
+	};
 	return {
-		__renderLambda: true,
-		handle,
-		...flags
+		errorMap: customMap,
+		description
 	};
 }
-/** Registers a callback and returns a ConfigRenderLambda descriptor. */
-function createAndRegisterRenderLambda(opts, replace) {
-	const { handle, lambda, ...flags } = opts;
-	if (replace) replaceCallback(handle, lambda);
-	else tryRegisterCallback(handle, lambda);
-	return createRenderLambda({
-		handle,
-		...flags
-	});
-}
-const futureResolves = /* @__PURE__ */ new Map();
-function registerFutureAwait(handle, onResolve) {
-	if (!(handle in getCfgRenderCtx().callbackRegistry)) {
-		getCfgRenderCtx().callbackRegistry[handle] = (value) => {
-			for (const res of futureResolves.get(handle)) res(value);
-		};
-		futureResolves.set(handle, []);
+var ZodType = class {
+	get description() {
+		return this._def.description;
 	}
-	futureResolves.get(handle).push(onResolve);
-}
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/block_storage_facade.js
-/**
-* All facade callback names as constants.
-* These are the source of truth - the interface is derived from these.
-*
-* IMPORTANT: When adding a new callback:
-* 1. Add the constant here
-* 2. Add the callback signature to FacadeCallbackTypes below
-* 3. The BlockStorageFacade type will automatically include it
-*/
-const BlockStorageFacadeCallbacks = {
-	StorageApplyUpdate: "__pl_storage_applyUpdate",
-	StorageDebugView: "__pl_storage_debugView",
-	StorageMigrate: "__pl_storage_migrate",
-	ArgsDerive: "__pl_args_derive",
-	PrerunArgsDerive: "__pl_prerunArgs_derive",
-	StorageInitial: "__pl_storage_initial"
-};
-/**
-* Creates a map of lambda handles from a callbacks constant object.
-* Keys are the callback string values (e.g., '__pl_storage_applyUpdate').
-*/
-function createFacadeHandles(callbacks) {
-	return Object.fromEntries(Object.values(callbacks).map((handle) => [handle, createRenderLambda({ handle })]));
-}
-/**
-* Lambda handles for facade callbacks.
-* Used by the middle layer to invoke callbacks via executeSingleLambda().
-*/
-const BlockStorageFacadeHandles = createFacadeHandles(BlockStorageFacadeCallbacks);
-/** Register all facade callbacks at once. Ensures all required callbacks are provided. */
-function registerFacadeCallbacks(callbacks) {
-	for (const key of Object.values(BlockStorageFacadeCallbacks)) tryRegisterCallback(key, callbacks[key]);
-}
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/render/future.js
-var FutureRef = class FutureRef {
-	handle;
-	postProcess;
-	isResolved = false;
-	resolvedValue;
-	constructor(handle, postProcess = (v) => v) {
-		this.handle = handle;
-		this.postProcess = postProcess;
-		registerFutureAwait(handle, (value) => {
-			this.resolvedValue = postProcess(value);
-			this.isResolved = true;
-		});
+	_getType(input) {
+		return getParsedType(input.data);
 	}
-	map(mapping) {
-		return new FutureRef(this.handle, (v) => mapping(this.postProcess(v)));
+	_getOrReturnCtx(input, ctx) {
+		return ctx || {
+			common: input.parent.common,
+			data: input.data,
+			parsedType: getParsedType(input.data),
+			schemaErrorMap: this._def.errorMap,
+			path: input.path,
+			parent: input.parent
+		};
 	}
-	mapDefined(mapping) {
-		return new FutureRef(this.handle, (v) => {
-			const vv = this.postProcess(v);
-			return vv ? mapping(vv) : void 0;
-		});
+	_processInputParams(input) {
+		return {
+			status: new ParseStatus(),
+			ctx: {
+				common: input.parent.common,
+				data: input.data,
+				parsedType: getParsedType(input.data),
+				schemaErrorMap: this._def.errorMap,
+				path: input.path,
+				parent: input.parent
+			}
+		};
 	}
-	toJSON() {
-		return this.isResolved ? this.resolvedValue : { __awaited_futures__: [this.handle] };
+	_parseSync(input) {
+		const result = this._parse(input);
+		if (isAsync(result)) throw new Error("Synchronous parse encountered promise.");
+		return result;
 	}
-};
-//#endregion
-//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
-var util;
-(function(util) {
-	util.assertEqual = (_) => {};
-	function assertIs(_arg) {}
-	util.assertIs = assertIs;
-	function assertNever(_x) {
-		throw new Error();
+	_parseAsync(input) {
+		const result = this._parse(input);
+		return Promise.resolve(result);
 	}
-	util.assertNever = assertNever;
-	util.arrayToEnum = (items) => {
-		const obj = {};
-		for (const item of items) obj[item] = item;
-		return obj;
-	};
-	util.getValidEnumValues = (obj) => {
-		const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-		const filtered = {};
-		for (const k of validKeys) filtered[k] = obj[k];
-		return util.objectValues(filtered);
-	};
-	util.objectValues = (obj) => {
-		return util.objectKeys(obj).map(function(e) {
-			return obj[e];
+	parse(data, params) {
+		const result = this.safeParse(data, params);
+		if (result.success) return result.data;
+		throw result.error;
+	}
+	safeParse(data, params) {
+		const ctx = {
+			common: {
+				issues: [],
+				async: params?.async ?? false,
+				contextualErrorMap: params?.errorMap
+			},
+			path: params?.path || [],
+			schemaErrorMap: this._def.errorMap,
+			parent: null,
+			data,
+			parsedType: getParsedType(data)
+		};
+		const result = this._parseSync({
+			data,
+			path: ctx.path,
+			parent: ctx
 		});
-	};
-	util.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
-		const keys = [];
-		for (const key in object) if (Object.prototype.hasOwnProperty.call(object, key)) keys.push(key);
-		return keys;
-	};
-	util.find = (arr, checker) => {
-		for (const item of arr) if (checker(item)) return item;
-	};
-	util.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
-	function joinValues(array, separator = " | ") {
-		return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+		return handleResult(ctx, result);
 	}
-	util.joinValues = joinValues;
-	util.jsonStringifyReplacer = (_, value) => {
-		if (typeof value === "bigint") return value.toString();
-		return value;
-	};
-})(util || (util = {}));
-var objectUtil;
-(function(objectUtil) {
-	objectUtil.mergeShapes = (first, second) => {
-		return {
-			...first,
-			...second
+	"~validate"(data) {
+		const ctx = {
+			common: {
+				issues: [],
+				async: !!this["~standard"].async
+			},
+			path: [],
+			schemaErrorMap: this._def.errorMap,
+			parent: null,
+			data,
+			parsedType: getParsedType(data)
 		};
-	};
-})(objectUtil || (objectUtil = {}));
-const ZodParsedType = util.arrayToEnum([
-	"string",
-	"nan",
-	"number",
-	"integer",
-	"float",
-	"boolean",
-	"date",
-	"bigint",
-	"symbol",
-	"function",
-	"undefined",
-	"null",
-	"array",
-	"object",
-	"unknown",
-	"promise",
-	"void",
-	"never",
-	"map",
-	"set"
-]);
-const getParsedType = (data) => {
-	switch (typeof data) {
-		case "undefined": return ZodParsedType.undefined;
-		case "string": return ZodParsedType.string;
-		case "number": return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
-		case "boolean": return ZodParsedType.boolean;
-		case "function": return ZodParsedType.function;
-		case "bigint": return ZodParsedType.bigint;
-		case "symbol": return ZodParsedType.symbol;
-		case "object":
-			if (Array.isArray(data)) return ZodParsedType.array;
-			if (data === null) return ZodParsedType.null;
-			if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") return ZodParsedType.promise;
-			if (typeof Map !== "undefined" && data instanceof Map) return ZodParsedType.map;
-			if (typeof Set !== "undefined" && data instanceof Set) return ZodParsedType.set;
-			if (typeof Date !== "undefined" && data instanceof Date) return ZodParsedType.date;
-			return ZodParsedType.object;
-		default: return ZodParsedType.unknown;
+		if (!this["~standard"].async) try {
+			const result = this._parseSync({
+				data,
+				path: [],
+				parent: ctx
+			});
+			return isValid(result) ? { value: result.value } : { issues: ctx.common.issues };
+		} catch (err) {
+			if (err?.message?.toLowerCase()?.includes("encountered")) this["~standard"].async = true;
+			ctx.common = {
+				issues: [],
+				async: true
+			};
+		}
+		return this._parseAsync({
+			data,
+			path: [],
+			parent: ctx
+		}).then((result) => isValid(result) ? { value: result.value } : { issues: ctx.common.issues });
 	}
-};
-//#endregion
-//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.js
-const ZodIssueCode = util.arrayToEnum([
-	"invalid_type",
-	"invalid_literal",
-	"custom",
-	"invalid_union",
-	"invalid_union_discriminator",
-	"invalid_enum_value",
-	"unrecognized_keys",
-	"invalid_arguments",
-	"invalid_return_type",
-	"invalid_date",
-	"invalid_string",
-	"too_small",
-	"too_big",
-	"invalid_intersection_types",
-	"not_multiple_of",
-	"not_finite"
-]);
-var ZodError = class ZodError extends Error {
-	get errors() {
-		return this.issues;
+	async parseAsync(data, params) {
+		const result = await this.safeParseAsync(data, params);
+		if (result.success) return result.data;
+		throw result.error;
 	}
-	constructor(issues) {
-		super();
-		this.issues = [];
-		this.addIssue = (sub) => {
-			this.issues = [...this.issues, sub];
-		};
-		this.addIssues = (subs = []) => {
-			this.issues = [...this.issues, ...subs];
+	async safeParseAsync(data, params) {
+		const ctx = {
+			common: {
+				issues: [],
+				contextualErrorMap: params?.errorMap,
+				async: true
+			},
+			path: params?.path || [],
+			schemaErrorMap: this._def.errorMap,
+			parent: null,
+			data,
+			parsedType: getParsedType(data)
 		};
-		const actualProto = new.target.prototype;
-		if (Object.setPrototypeOf) Object.setPrototypeOf(this, actualProto);
-		else this.__proto__ = actualProto;
-		this.name = "ZodError";
-		this.issues = issues;
+		const maybeAsyncResult = this._parse({
+			data,
+			path: ctx.path,
+			parent: ctx
+		});
+		const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
+		return handleResult(ctx, result);
 	}
-	format(_mapper) {
-		const mapper = _mapper || function(issue) {
-			return issue.message;
-		};
-		const fieldErrors = { _errors: [] };
-		const processError = (error) => {
-			for (const issue of error.issues) if (issue.code === "invalid_union") issue.unionErrors.map(processError);
-			else if (issue.code === "invalid_return_type") processError(issue.returnTypeError);
-			else if (issue.code === "invalid_arguments") processError(issue.argumentsError);
-			else if (issue.path.length === 0) fieldErrors._errors.push(mapper(issue));
-			else {
-				let curr = fieldErrors;
-				let i = 0;
-				while (i < issue.path.length) {
-					const el = issue.path[i];
-					if (!(i === issue.path.length - 1)) curr[el] = curr[el] || { _errors: [] };
-					else {
-						curr[el] = curr[el] || { _errors: [] };
-						curr[el]._errors.push(mapper(issue));
-					}
-					curr = curr[el];
-					i++;
-				}
-			}
+	refine(check, message) {
+		const getIssueProperties = (val) => {
+			if (typeof message === "string" || typeof message === "undefined") return { message };
+			else if (typeof message === "function") return message(val);
+			else return message;
 		};
-		processError(this);
-		return fieldErrors;
-	}
-	static assert(value) {
-		if (!(value instanceof ZodError)) throw new Error(`Not a ZodError: ${value}`);
+		return this._refinement((val, ctx) => {
+			const result = check(val);
+			const setError = () => ctx.addIssue({
+				code: ZodIssueCode.custom,
+				...getIssueProperties(val)
+			});
+			if (typeof Promise !== "undefined" && result instanceof Promise) return result.then((data) => {
+				if (!data) {
+					setError();
+					return false;
+				} else return true;
+			});
+			if (!result) {
+				setError();
+				return false;
+			} else return true;
+		});
 	}
-	toString() {
-		return this.message;
+	refinement(check, refinementData) {
+		return this._refinement((val, ctx) => {
+			if (!check(val)) {
+				ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
+				return false;
+			} else return true;
+		});
 	}
-	get message() {
-		return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
+	_refinement(refinement) {
+		return new ZodEffects({
+			schema: this,
+			typeName: ZodFirstPartyTypeKind.ZodEffects,
+			effect: {
+				type: "refinement",
+				refinement
+			}
+		});
 	}
-	get isEmpty() {
-		return this.issues.length === 0;
+	superRefine(refinement) {
+		return this._refinement(refinement);
 	}
-	flatten(mapper = (issue) => issue.message) {
-		const fieldErrors = {};
-		const formErrors = [];
-		for (const sub of this.issues) if (sub.path.length > 0) {
-			const firstEl = sub.path[0];
-			fieldErrors[firstEl] = fieldErrors[firstEl] || [];
-			fieldErrors[firstEl].push(mapper(sub));
-		} else formErrors.push(mapper(sub));
-		return {
-			formErrors,
-			fieldErrors
+	constructor(def) {
+		/** Alias of safeParseAsync */
+		this.spa = this.safeParseAsync;
+		this._def = def;
+		this.parse = this.parse.bind(this);
+		this.safeParse = this.safeParse.bind(this);
+		this.parseAsync = this.parseAsync.bind(this);
+		this.safeParseAsync = this.safeParseAsync.bind(this);
+		this.spa = this.spa.bind(this);
+		this.refine = this.refine.bind(this);
+		this.refinement = this.refinement.bind(this);
+		this.superRefine = this.superRefine.bind(this);
+		this.optional = this.optional.bind(this);
+		this.nullable = this.nullable.bind(this);
+		this.nullish = this.nullish.bind(this);
+		this.array = this.array.bind(this);
+		this.promise = this.promise.bind(this);
+		this.or = this.or.bind(this);
+		this.and = this.and.bind(this);
+		this.transform = this.transform.bind(this);
+		this.brand = this.brand.bind(this);
+		this.default = this.default.bind(this);
+		this.catch = this.catch.bind(this);
+		this.describe = this.describe.bind(this);
+		this.pipe = this.pipe.bind(this);
+		this.readonly = this.readonly.bind(this);
+		this.isNullable = this.isNullable.bind(this);
+		this.isOptional = this.isOptional.bind(this);
+		this["~standard"] = {
+			version: 1,
+			vendor: "zod",
+			validate: (data) => this["~validate"](data)
 		};
 	}
-	get formErrors() {
-		return this.flatten();
-	}
-};
-ZodError.create = (issues) => {
-	return new ZodError(issues);
-};
-//#endregion
-//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/locales/en.js
-const errorMap = (issue, _ctx) => {
-	let message;
-	switch (issue.code) {
-		case ZodIssueCode.invalid_type:
-			if (issue.received === ZodParsedType.undefined) message = "Required";
-			else message = `Expected ${issue.expected}, received ${issue.received}`;
-			break;
-		case ZodIssueCode.invalid_literal:
-			message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
-			break;
-		case ZodIssueCode.unrecognized_keys:
-			message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
-			break;
-		case ZodIssueCode.invalid_union:
-			message = `Invalid input`;
-			break;
-		case ZodIssueCode.invalid_union_discriminator:
-			message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
-			break;
-		case ZodIssueCode.invalid_enum_value:
-			message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
-			break;
-		case ZodIssueCode.invalid_arguments:
-			message = `Invalid function arguments`;
-			break;
-		case ZodIssueCode.invalid_return_type:
-			message = `Invalid function return type`;
-			break;
-		case ZodIssueCode.invalid_date:
-			message = `Invalid date`;
-			break;
-		case ZodIssueCode.invalid_string:
-			if (typeof issue.validation === "object") {
-				if ("includes" in issue.validation) {
-					message = `Invalid input: must include "${issue.validation.includes}"`;
-					if (typeof issue.validation.position === "number") message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
-				} else if ("startsWith" in issue.validation) message = `Invalid input: must start with "${issue.validation.startsWith}"`;
-				else if ("endsWith" in issue.validation) message = `Invalid input: must end with "${issue.validation.endsWith}"`;
-				else util.assertNever(issue.validation);
-			} else if (issue.validation !== "regex") message = `Invalid ${issue.validation}`;
-			else message = "Invalid";
-			break;
-		case ZodIssueCode.too_small:
-			if (issue.type === "array") message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
-			else if (issue.type === "string") message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
-			else if (issue.type === "number") message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
-			else if (issue.type === "bigint") message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
-			else if (issue.type === "date") message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
-			else message = "Invalid input";
-			break;
-		case ZodIssueCode.too_big:
-			if (issue.type === "array") message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
-			else if (issue.type === "string") message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
-			else if (issue.type === "number") message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
-			else if (issue.type === "bigint") message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
-			else if (issue.type === "date") message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
-			else message = "Invalid input";
-			break;
-		case ZodIssueCode.custom:
-			message = `Invalid input`;
-			break;
-		case ZodIssueCode.invalid_intersection_types:
-			message = `Intersection results could not be merged`;
-			break;
-		case ZodIssueCode.not_multiple_of:
-			message = `Number must be a multiple of ${issue.multipleOf}`;
-			break;
-		case ZodIssueCode.not_finite:
-			message = "Number must be finite";
-			break;
-		default:
-			message = _ctx.defaultError;
-			util.assertNever(issue);
+	optional() {
+		return ZodOptional.create(this, this._def);
 	}
-	return { message };
-};
-//#endregion
-//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/errors.js
-let overrideErrorMap = errorMap;
-function getErrorMap() {
-	return overrideErrorMap;
-}
-//#endregion
-//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
-const makeIssue = (params) => {
-	const { data, path, errorMaps, issueData } = params;
-	const fullPath = [...path, ...issueData.path || []];
-	const fullIssue = {
-		...issueData,
-		path: fullPath
-	};
-	if (issueData.message !== void 0) return {
-		...issueData,
-		path: fullPath,
-		message: issueData.message
-	};
-	let errorMessage = "";
-	const maps = errorMaps.filter((m) => !!m).slice().reverse();
-	for (const map of maps) errorMessage = map(fullIssue, {
-		data,
-		defaultError: errorMessage
-	}).message;
-	return {
-		...issueData,
-		path: fullPath,
-		message: errorMessage
-	};
-};
-function addIssueToContext(ctx, issueData) {
-	const overrideMap = getErrorMap();
-	const issue = makeIssue({
-		issueData,
-		data: ctx.data,
-		path: ctx.path,
-		errorMaps: [
-			ctx.common.contextualErrorMap,
-			ctx.schemaErrorMap,
-			overrideMap,
-			overrideMap === errorMap ? void 0 : errorMap
-		].filter((x) => !!x)
-	});
-	ctx.common.issues.push(issue);
-}
-var ParseStatus = class ParseStatus {
-	constructor() {
-		this.value = "valid";
+	nullable() {
+		return ZodNullable.create(this, this._def);
 	}
-	dirty() {
-		if (this.value === "valid") this.value = "dirty";
+	nullish() {
+		return this.nullable().optional();
 	}
-	abort() {
-		if (this.value !== "aborted") this.value = "aborted";
+	array() {
+		return ZodArray.create(this);
 	}
-	static mergeArray(status, results) {
-		const arrayValue = [];
-		for (const s of results) {
-			if (s.status === "aborted") return INVALID;
-			if (s.status === "dirty") status.dirty();
-			arrayValue.push(s.value);
-		}
-		return {
-			status: status.value,
-			value: arrayValue
-		};
+	promise() {
+		return ZodPromise.create(this, this._def);
 	}
-	static async mergeObjectAsync(status, pairs) {
-		const syncPairs = [];
-		for (const pair of pairs) {
-			const key = await pair.key;
-			const value = await pair.value;
-			syncPairs.push({
-				key,
-				value
-			});
-		}
-		return ParseStatus.mergeObjectSync(status, syncPairs);
+	or(option) {
+		return ZodUnion.create([this, option], this._def);
 	}
-	static mergeObjectSync(status, pairs) {
-		const finalObject = {};
-		for (const pair of pairs) {
-			const { key, value } = pair;
-			if (key.status === "aborted") return INVALID;
-			if (value.status === "aborted") return INVALID;
-			if (key.status === "dirty") status.dirty();
-			if (value.status === "dirty") status.dirty();
-			if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) finalObject[key.value] = value.value;
-		}
-		return {
-			status: status.value,
-			value: finalObject
-		};
+	and(incoming) {
+		return ZodIntersection.create(this, incoming, this._def);
 	}
-};
-const INVALID = Object.freeze({ status: "aborted" });
-const DIRTY = (value) => ({
-	status: "dirty",
-	value
-});
-const OK = (value) => ({
-	status: "valid",
-	value
-});
-const isAborted = (x) => x.status === "aborted";
-const isDirty = (x) => x.status === "dirty";
-const isValid = (x) => x.status === "valid";
-const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
-//#endregion
-//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.js
-var errorUtil;
-(function(errorUtil) {
-	errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-	errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
-})(errorUtil || (errorUtil = {}));
-//#endregion
-//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
-var ParseInputLazyPath = class {
-	constructor(parent, value, path, key) {
-		this._cachedPath = [];
-		this.parent = parent;
-		this.data = value;
-		this._path = path;
-		this._key = key;
-	}
-	get path() {
-		if (!this._cachedPath.length) {
-			if (Array.isArray(this._key)) this._cachedPath.push(...this._path, ...this._key);
-			else this._cachedPath.push(...this._path, this._key);
-		}
-		return this._cachedPath;
-	}
-};
-const handleResult = (ctx, result) => {
-	if (isValid(result)) return {
-		success: true,
-		data: result.value
-	};
-	else {
-		if (!ctx.common.issues.length) throw new Error("Validation failed but no issues detected.");
-		return {
-			success: false,
-			get error() {
-				if (this._error) return this._error;
-				const error = new ZodError(ctx.common.issues);
-				this._error = error;
-				return this._error;
-			}
-		};
-	}
-};
-function processCreateParams(params) {
-	if (!params) return {};
-	const { errorMap, invalid_type_error, required_error, description } = params;
-	if (errorMap && (invalid_type_error || required_error)) throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
-	if (errorMap) return {
-		errorMap,
-		description
-	};
-	const customMap = (iss, ctx) => {
-		const { message } = params;
-		if (iss.code === "invalid_enum_value") return { message: message ?? ctx.defaultError };
-		if (typeof ctx.data === "undefined") return { message: message ?? required_error ?? ctx.defaultError };
-		if (iss.code !== "invalid_type") return { message: ctx.defaultError };
-		return { message: message ?? invalid_type_error ?? ctx.defaultError };
-	};
-	return {
-		errorMap: customMap,
-		description
-	};
-}
-var ZodType = class {
-	get description() {
-		return this._def.description;
-	}
-	_getType(input) {
-		return getParsedType(input.data);
-	}
-	_getOrReturnCtx(input, ctx) {
-		return ctx || {
-			common: input.parent.common,
-			data: input.data,
-			parsedType: getParsedType(input.data),
-			schemaErrorMap: this._def.errorMap,
-			path: input.path,
-			parent: input.parent
-		};
-	}
-	_processInputParams(input) {
-		return {
-			status: new ParseStatus(),
-			ctx: {
-				common: input.parent.common,
-				data: input.data,
-				parsedType: getParsedType(input.data),
-				schemaErrorMap: this._def.errorMap,
-				path: input.path,
-				parent: input.parent
+	transform(transform) {
+		return new ZodEffects({
+			...processCreateParams(this._def),
+			schema: this,
+			typeName: ZodFirstPartyTypeKind.ZodEffects,
+			effect: {
+				type: "transform",
+				transform
 			}
-		};
+		});
 	}
-	_parseSync(input) {
-		const result = this._parse(input);
-		if (isAsync(result)) throw new Error("Synchronous parse encountered promise.");
-		return result;
+	default(def) {
+		const defaultValueFunc = typeof def === "function" ? def : () => def;
+		return new ZodDefault({
+			...processCreateParams(this._def),
+			innerType: this,
+			defaultValue: defaultValueFunc,
+			typeName: ZodFirstPartyTypeKind.ZodDefault
+		});
 	}
-	_parseAsync(input) {
-		const result = this._parse(input);
-		return Promise.resolve(result);
+	brand() {
+		return new ZodBranded({
+			typeName: ZodFirstPartyTypeKind.ZodBranded,
+			type: this,
+			...processCreateParams(this._def)
+		});
 	}
-	parse(data, params) {
-		const result = this.safeParse(data, params);
-		if (result.success) return result.data;
-		throw result.error;
+	catch(def) {
+		const catchValueFunc = typeof def === "function" ? def : () => def;
+		return new ZodCatch({
+			...processCreateParams(this._def),
+			innerType: this,
+			catchValue: catchValueFunc,
+			typeName: ZodFirstPartyTypeKind.ZodCatch
+		});
 	}
-	safeParse(data, params) {
-		const ctx = {
-			common: {
-				issues: [],
-				async: params?.async ?? false,
-				contextualErrorMap: params?.errorMap
-			},
-			path: params?.path || [],
-			schemaErrorMap: this._def.errorMap,
-			parent: null,
-			data,
-			parsedType: getParsedType(data)
-		};
-		const result = this._parseSync({
-			data,
-			path: ctx.path,
-			parent: ctx
+	describe(description) {
+		const This = this.constructor;
+		return new This({
+			...this._def,
+			description
 		});
-		return handleResult(ctx, result);
 	}
-	"~validate"(data) {
-		const ctx = {
-			common: {
-				issues: [],
-				async: !!this["~standard"].async
-			},
-			path: [],
-			schemaErrorMap: this._def.errorMap,
-			parent: null,
-			data,
-			parsedType: getParsedType(data)
-		};
-		if (!this["~standard"].async) try {
-			const result = this._parseSync({
-				data,
-				path: [],
-				parent: ctx
-			});
-			return isValid(result) ? { value: result.value } : { issues: ctx.common.issues };
-		} catch (err) {
-			if (err?.message?.toLowerCase()?.includes("encountered")) this["~standard"].async = true;
-			ctx.common = {
-				issues: [],
-				async: true
-			};
-		}
-		return this._parseAsync({
-			data,
-			path: [],
-			parent: ctx
-		}).then((result) => isValid(result) ? { value: result.value } : { issues: ctx.common.issues });
+	pipe(target) {
+		return ZodPipeline.create(this, target);
 	}
-	async parseAsync(data, params) {
-		const result = await this.safeParseAsync(data, params);
-		if (result.success) return result.data;
-		throw result.error;
+	readonly() {
+		return ZodReadonly.create(this);
 	}
-	async safeParseAsync(data, params) {
-		const ctx = {
-			common: {
-				issues: [],
-				contextualErrorMap: params?.errorMap,
-				async: true
-			},
-			path: params?.path || [],
-			schemaErrorMap: this._def.errorMap,
-			parent: null,
-			data,
-			parsedType: getParsedType(data)
-		};
-		const maybeAsyncResult = this._parse({
-			data,
-			path: ctx.path,
-			parent: ctx
-		});
-		const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
-		return handleResult(ctx, result);
+	isOptional() {
+		return this.safeParse(void 0).success;
 	}
-	refine(check, message) {
-		const getIssueProperties = (val) => {
-			if (typeof message === "string" || typeof message === "undefined") return { message };
-			else if (typeof message === "function") return message(val);
-			else return message;
-		};
-		return this._refinement((val, ctx) => {
-			const result = check(val);
-			const setError = () => ctx.addIssue({
-				code: ZodIssueCode.custom,
-				...getIssueProperties(val)
-			});
-			if (typeof Promise !== "undefined" && result instanceof Promise) return result.then((data) => {
-				if (!data) {
-					setError();
-					return false;
-				} else return true;
-			});
-			if (!result) {
-				setError();
-				return false;
-			} else return true;
-		});
-	}
-	refinement(check, refinementData) {
-		return this._refinement((val, ctx) => {
-			if (!check(val)) {
-				ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
-				return false;
-			} else return true;
-		});
-	}
-	_refinement(refinement) {
-		return new ZodEffects({
-			schema: this,
-			typeName: ZodFirstPartyTypeKind.ZodEffects,
-			effect: {
-				type: "refinement",
-				refinement
-			}
-		});
-	}
-	superRefine(refinement) {
-		return this._refinement(refinement);
-	}
-	constructor(def) {
-		/** Alias of safeParseAsync */
-		this.spa = this.safeParseAsync;
-		this._def = def;
-		this.parse = this.parse.bind(this);
-		this.safeParse = this.safeParse.bind(this);
-		this.parseAsync = this.parseAsync.bind(this);
-		this.safeParseAsync = this.safeParseAsync.bind(this);
-		this.spa = this.spa.bind(this);
-		this.refine = this.refine.bind(this);
-		this.refinement = this.refinement.bind(this);
-		this.superRefine = this.superRefine.bind(this);
-		this.optional = this.optional.bind(this);
-		this.nullable = this.nullable.bind(this);
-		this.nullish = this.nullish.bind(this);
-		this.array = this.array.bind(this);
-		this.promise = this.promise.bind(this);
-		this.or = this.or.bind(this);
-		this.and = this.and.bind(this);
-		this.transform = this.transform.bind(this);
-		this.brand = this.brand.bind(this);
-		this.default = this.default.bind(this);
-		this.catch = this.catch.bind(this);
-		this.describe = this.describe.bind(this);
-		this.pipe = this.pipe.bind(this);
-		this.readonly = this.readonly.bind(this);
-		this.isNullable = this.isNullable.bind(this);
-		this.isOptional = this.isOptional.bind(this);
-		this["~standard"] = {
-			version: 1,
-			vendor: "zod",
-			validate: (data) => this["~validate"](data)
-		};
-	}
-	optional() {
-		return ZodOptional.create(this, this._def);
-	}
-	nullable() {
-		return ZodNullable.create(this, this._def);
-	}
-	nullish() {
-		return this.nullable().optional();
-	}
-	array() {
-		return ZodArray.create(this);
-	}
-	promise() {
-		return ZodPromise.create(this, this._def);
-	}
-	or(option) {
-		return ZodUnion.create([this, option], this._def);
-	}
-	and(incoming) {
-		return ZodIntersection.create(this, incoming, this._def);
-	}
-	transform(transform) {
-		return new ZodEffects({
-			...processCreateParams(this._def),
-			schema: this,
-			typeName: ZodFirstPartyTypeKind.ZodEffects,
-			effect: {
-				type: "transform",
-				transform
-			}
-		});
-	}
-	default(def) {
-		const defaultValueFunc = typeof def === "function" ? def : () => def;
-		return new ZodDefault({
-			...processCreateParams(this._def),
-			innerType: this,
-			defaultValue: defaultValueFunc,
-			typeName: ZodFirstPartyTypeKind.ZodDefault
-		});
-	}
-	brand() {
-		return new ZodBranded({
-			typeName: ZodFirstPartyTypeKind.ZodBranded,
-			type: this,
-			...processCreateParams(this._def)
-		});
-	}
-	catch(def) {
-		const catchValueFunc = typeof def === "function" ? def : () => def;
-		return new ZodCatch({
-			...processCreateParams(this._def),
-			innerType: this,
-			catchValue: catchValueFunc,
-			typeName: ZodFirstPartyTypeKind.ZodCatch
-		});
-	}
-	describe(description) {
-		const This = this.constructor;
-		return new This({
-			...this._def,
-			description
-		});
-	}
-	pipe(target) {
-		return ZodPipeline.create(this, target);
-	}
-	readonly() {
-		return ZodReadonly.create(this);
-	}
-	isOptional() {
-		return this.safeParse(void 0).success;
-	}
-	isNullable() {
-		return this.safeParse(null).success;
+	isNullable() {
+		return this.safeParse(null).success;
 	}
 };
 const cuidRegex = /^c[^\s-]{8,}$/i;
@@ -4534,6 +3898,16 @@ objectType({
 	type: literalType("plain"),
 	content: stringType()
 });
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/bmodel/block_kind_ref.js
+/**
+* Compose a {@link BlockKindReference} from a kind's `name`/`version`.
+*
+* The single place that decides how the reference is assembled. If global
+* uniqueness later requires the name segment to be org-qualified, this is the
+* one line that changes.
+*/
+const formatKindRef = (k) => `${k.name}@${k.version}`;
 objectType({
 	/** Included left border. */
 	from: numberType().min(0),
@@ -4541,7 +3915,7 @@ objectType({
 	to: numberType().min(1)
 });
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/util.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/util.js
 function assertNever(x) {
 	throw new Error("Unexpected object: " + x);
 }
@@ -4553,7 +3927,7 @@ function uniqueBy(array, makeId) {
 	return [...new Map(array.map((e) => [makeId(e), e])).values()];
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.js
 /**
 * Type guard function that checks if the given value is a valid DataInfo.
 *
@@ -4742,7 +4116,7 @@ function entriesToDataInfo(dataInfoEntries) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/errors.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/errors.js
 var ServiceError = class extends Error {
 	name = "ServiceError";
 };
@@ -4766,7 +4140,7 @@ function ensureError(value) {
 	return new Error(stringifyValue(value));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/json.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/json.js
 var import_canonicalize = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = function serialize(object) {
 		if (typeof object === "number" && isNaN(object)) throw new Error("NaN is not allowed");
@@ -4799,7 +4173,7 @@ function parseJsonSafely(value, fallback) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.js
 function readMetadata(metadata, key) {
 	return metadata?.[key];
 }
@@ -5091,7 +4465,7 @@ function matchAxisId(query, target) {
 	return query.name === target.name && matchDomain$1(query.domain, target.domain) && matchDomain$1(query.contextDomain, target.contextDomain);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/utils.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/utils.js
 const BOOLEAN_TYPES = /* @__PURE__ */ new Set([
 	"numericComparison",
 	"stringEquals",
@@ -5196,7 +4570,7 @@ function collectSpecQueryColumns(query) {
 	return result;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.js
 function mapPTableDef(def, cb) {
 	return {
 		...def,
@@ -5239,7 +4613,7 @@ function mapJoinEntry(entry, cb) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.js
 function getPTableColumnId(spec) {
 	switch (spec.type) {
 		case "axis": return {
@@ -5253,7 +4627,7 @@ function getPTableColumnId(spec) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/filtered_column.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/filtered_column.js
 function stringifyColumnFilteredId(key) {
 	return canonicalizeJson(createColumnFilteredKey(key));
 }
@@ -5286,7 +4660,7 @@ function applyAxisFilters(spec, axisFilters) {
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/pool/spec.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/pool/spec.js
 function isPObjectId(value) {
 	if (typeof value !== "string") return false;
 	return isPObjectKey(parseJsonSafely(value));
@@ -5408,7 +4782,7 @@ function throwError(v) {
 	else throw v;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/discovered_column.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/discovered_column.js
 function isColumnDiscoveredKey(obj) {
 	return typeof obj === "object" && obj !== null && "__isDiscovered" in obj;
 }
@@ -5638,7 +5012,7 @@ function isString(value) {
 	return typeof value === "string";
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.js
 /**
 * Canonically serializes a column key to a branded string id. Accepts both
 * the new {@link ColumnUniversalKey} and the deprecated {@link UniversalPColumnId}
@@ -5654,6 +5028,149 @@ function parseColumnIdSafely(str, fallback = void 0) {
 		return fallback;
 	}
 }
+/** Whether `value` is any of the five key forms a {@link ColumnUniversalId} serializes. */
+function isColumnUniversalKey(value) {
+	return isPObjectKey(value) || isColumnFilteredKey(value) || isColumnDiscoveredKey(value) || isColumnOverriddenKey(value);
+}
+/**
+* Take a value out of however many `JSON.stringify` passes wrapped it, or `undefined`
+* when `s` is not JSON at all.
+*
+* The one definition of "how a value can be hiding inside a string" — a block id can sit
+* under several layers of escaping, and a walk over object properties reaches none of
+* them. Callers differ in what they do at the bottom (this deliberately says nothing
+* about which values count as identifiers), but they must agree on the mechanics, or
+* "what carries a block id" ends up with two answers that drift.
+*
+* The gate is cheap and does NOT require any marker in the body: a filtered id whose
+* innermost leaf is a {@link LocalPObjectKey} carries no `__isRef`, so demanding one
+* would miss it.
+*/
+function peelJsonLayers(s) {
+	let current = s;
+	let layers = 0;
+	for (;;) {
+		const c0 = current.charCodeAt(0);
+		if (c0 !== 123 && c0 !== 34) return void 0;
+		let parsed;
+		try {
+			parsed = JSON.parse(current);
+		} catch {
+			return;
+		}
+		if (isString(parsed)) {
+			if (parsed.length >= current.length) return void 0;
+			current = parsed;
+			layers++;
+			continue;
+		}
+		return {
+			value: parsed,
+			layers
+		};
+	}
+}
+/**
+* Rewrite every block id buried inside a column id.
+*
+* A {@link GlobalPObjectKey} leaf names its upstream by block id, and the wrapper key forms
+* nest by *string* id rather than by object — so a block id can sit under several layers of
+* JSON escaping, and `queriesQualifications` carries one in a map *key*. A caller that only
+* walks object properties never reaches any of them, which is why moving a column id between
+* projects needs this rather than a generic walk.
+*
+* Recursion re-canonicalizes bottom-up, so every level is canonical afterwards — including
+* the rebuilt `queriesQualifications`, whose keys the canonical form sorts. That is the
+* property a textual rewrite cannot have: redirecting an id that is a map key changes what
+* the sorted order should be, and only rebuilding restores it.
+*
+* Returns the input itself when no block id changed, so a caller mapping ids to themselves
+* gets its value back byte-for-byte and never re-serializes a stored id. Any `string` is
+* accepted for the same reason: a caller sweeping a params object cannot know which of its
+* strings are ids, and one that is not is returned as-is.
+*
+* @param remapBlockId old block id → new block id. Throw from it to reject an id that cannot
+*   be mapped.
+*/
+function remapColumnIdBlockIds(id, remapBlockId) {
+	return (isString(id) ? remapIdString(id, remapBlockId) : remapKey(id, remapBlockId)) ?? id;
+}
+/**
+* The string half of {@link remapColumnIdBlockIds}. `undefined` means "nothing to change",
+* which is what keeps an unaffected id from being re-serialized.
+*
+* Escape padding is peeled and put back, so an id that reached params through an extra
+* `JSON.stringify` is rewritten in place and comes back wrapped as it was found. A string
+* that does not peel to a column key is left alone: params hold ordinary strings too.
+*/
+function remapIdString(id, remapBlockId) {
+	const peeled = peelJsonLayers(id);
+	if (peeled === void 0 || !isColumnUniversalKey(peeled.value)) return void 0;
+	const remappedKey = remapKey(peeled.value, remapBlockId);
+	if (remappedKey === void 0) return void 0;
+	let rebuilt = stringifyColumnId(remappedKey);
+	for (let layer = 0; layer < peeled.layers; layer++) rebuilt = JSON.stringify(rebuilt);
+	return rebuilt;
+}
+/** The key half of {@link remapColumnIdBlockIds}. `undefined` means "nothing to change". */
+function remapKey(key, remapBlockId) {
+	if (isGlobalPObjectKey(key)) {
+		const blockId = remapBlockId(key.blockId);
+		return blockId === key.blockId ? void 0 : {
+			...key,
+			blockId
+		};
+	}
+	if (isLocalPObjectKey(key)) return void 0;
+	if (isColumnFilteredKey(key)) {
+		const source = remapIdString(key.source, remapBlockId);
+		return source === void 0 ? void 0 : {
+			...key,
+			source
+		};
+	}
+	if (isColumnOverriddenKey(key)) {
+		const source = remapIdString(key.source, remapBlockId);
+		return source === void 0 ? void 0 : {
+			...key,
+			source
+		};
+	}
+	if (isColumnDiscoveredKey(key)) return remapDiscoveredKey(key, remapBlockId);
+	throw new Error(`remapColumnIdBlockIds: unrecognized column id structure: ${JSON.stringify(key)}`);
+}
+/**
+* Discovered is the only key form carrying more than one nested id: the column it
+* discovered, one per linker hop, and one per entry in `queriesQualifications` — where the
+* id is the map key, not the value.
+*/
+function remapDiscoveredKey(key, remapBlockId) {
+	const column = remapIdString(key.column, remapBlockId);
+	let pathChanged = false;
+	const path = key.path?.map((item) => {
+		const itemColumn = remapIdString(item.column, remapBlockId);
+		if (itemColumn === void 0) return item;
+		pathChanged = true;
+		return {
+			...item,
+			column: itemColumn
+		};
+	});
+	let queriesChanged = false;
+	const queriesQualifications = key.queriesQualifications && Object.fromEntries(Object.entries(key.queriesQualifications).map(([queryId, qualifications]) => {
+		const remappedId = remapIdString(queryId, remapBlockId);
+		if (remappedId === void 0) return [queryId, qualifications];
+		queriesChanged = true;
+		return [remappedId, qualifications];
+	}));
+	if (column === void 0 && !pathChanged && !queriesChanged) return void 0;
+	return {
+		...key,
+		...column !== void 0 ? { column } : {},
+		...pathChanged ? { path } : {},
+		...queriesChanged ? { queriesQualifications } : {}
+	};
+}
 /**
 * Walk a rich column id down to its terminal leaf {@link PObjectId}.
 */
@@ -5669,7 +5186,7 @@ function extractPObjectId(id) {
 	throw new Error(`extractPObjectId: unrecognized column id structure: ${JSON.stringify(id)}`);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/overridden.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/overridden.js
 function isColumnOverriddenKey(obj) {
 	return typeof obj === "object" && obj !== null && "__isOverridden" in obj;
 }
@@ -5791,7 +5308,7 @@ function mergeRecord(a, b) {
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/anchored.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/anchored.js
 function axisKey(axis) {
 	return (0, import_canonicalize.default)(getAxisId(axis));
 }
@@ -6037,7 +5554,15 @@ function isAnchorAxisRef(value) {
 	return typeof value === "object" && "anchor" in value;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.js
+/**
+* Checks if a given value is an anchored column identifier
+* @param id - The value to check
+* @returns True if the value is an anchored column identifier, false otherwise
+*/
+function isAnchoredPColumnId(id) {
+	return typeof id === "object" && id !== null && "name" in id && "axes" in id;
+}
 /**
 * Determines if an axis ID matches an axis selector.
 *
@@ -6118,7 +5643,7 @@ function legacyColumnSelectorsToPredicate(predicateOrSelectors) {
 	else return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/native_id.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/native_id.js
 function deriveNativeId(spec) {
 	const result = {
 		kind: spec.kind,
@@ -6130,7 +5655,7 @@ function deriveNativeId(spec) {
 	return (0, import_canonicalize.default)(result);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/linker_columns.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/linker_columns.js
 var LinkerMap = class LinkerMap {
 	/** Graph of linkers connected by axes (single or grouped by parents) */
 	data;
@@ -6307,14 +5832,14 @@ var LinkerMap = class LinkerMap {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.js
 /**
 * Required PFrames version. Bump this in lockstep with the `@milaboratories/pframes-rs-*`
 * version in `pnpm-workspace.yaml` so blocks built against the new SDK refuse to load on
 * older desktop apps.
 */
 const REQUIRES_PFRAMES_VERSION = 1001031;
-stringType().length(24).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+stringType().length(24).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/);
 objectType({
 	__isRef: literalType(true).describe("Crucial marker for the block dependency tree reconstruction"),
 	blockId: stringType().describe("Upstream block id"),
@@ -6350,7 +5875,7 @@ function withEnrichments(ref, requireEnrichments = true) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/value_or_error.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/value_or_error.js
 function mapValueInVOE(voe, cb) {
 	return voe.ok ? {
 		ok: true,
@@ -6358,7 +5883,7 @@ function mapValueInVOE(voe, cb) {
 	} : voe;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/resource_types.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/resource_types.js
 /** Well-known resource type names used across the platform. */
 const ResourceTypeName = {
 	StreamManager: "StreamManager",
@@ -6402,7 +5927,7 @@ const ResourceTypeName = {
 	SharedEnvelope: "SharedEnvelope"
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/services/service_types.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_types.js
 const SERVICE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9]*$/;
 const { service, isNodeService, isWasmService, isMainService, getServiceKind, getServiceModelMethods, getServiceUiMethods } = (() => {
 	const typeMap = /* @__PURE__ */ new Map();
@@ -6441,7 +5966,7 @@ const { service, isNodeService, isWasmService, isMainService, getServiceKind, ge
 	};
 })();
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.js
 const Services = {
 	PFrameSpec: service()({
 		type: "wasm",
@@ -6523,271 +6048,1111 @@ const Services = {
 		]
 	})
 };
-Object.keys(Services).map((key) => `requires${key}`);
-/**
-* Resolve which services are required by the given feature flags.
-* Accepts Record<string, unknown> so it works with both BlockCodeKnownFeatureFlags
-* (from middle layer) and Zod-parsed records (from preload).
-*/
-function resolveRequiredServices(flags) {
-	if (!flags) return [];
-	return Object.keys(Services).filter((key) => flags[`requires${key}`] === true).map((key) => Services[key]);
-}
-Object.fromEntries(Object.keys(Services).map((key) => [`requires${key}`, true]));
+Object.keys(Services).map((key) => `requires${key}`);
+/**
+* Resolve which services are required by the given feature flags.
+* Accepts Record<string, unknown> so it works with both BlockCodeKnownFeatureFlags
+* (from middle layer) and Zod-parsed records (from preload).
+*/
+function resolveRequiredServices(flags) {
+	if (!flags) return [];
+	return Object.keys(Services).filter((key) => flags[`requires${key}`] === true).map((key) => Services[key]);
+}
+Object.fromEntries(Object.keys(Services).map((key) => [`requires${key}`, true]));
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_injectors.js
+function buildMethodMap(pick) {
+	const result = {};
+	for (const id of Object.values(Services)) result[id] = [...pick(id)];
+	return result;
+}
+buildMethodMap(getServiceUiMethods);
+buildMethodMap(getServiceModelMethods);
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/accessor_traversal.js
+/** Resource types that hold column collections — DFS stops here and collects. */
+const COLLECT_TYPES = [ResourceTypeName.PFrame];
+/** Resource types DFS descends through when looking for PFrames. */
+const DESCEND_TYPES = [ResourceTypeName.StdMap, ResourceTypeName.StdMapSlash];
+/**
+* Enumerate column names backing a PFrame accessor — derived from
+* `<name>.spec` field names, without resolving the spec resources.
+*/
+function listColumnNames(accessor, prefix = "") {
+	if (accessor.resourceType.name !== ResourceTypeName.PFrame) return [];
+	const out = [];
+	for (const field of accessor.listInputFields()) {
+		if (!field.endsWith(".spec")) continue;
+		const raw = field.slice(0, -5);
+		if (!raw.startsWith(prefix)) continue;
+		out.push(raw.slice(prefix.length));
+	}
+	return out;
+}
+/**
+* DFS over the input-field subtree of `root`. Collects nodes whose resource
+* type ∈ `collectTypes`. Descends only through `descendTypes`
+* (default: StdMap / StdMapSlash). Collected nodes are not descended into.
+*
+* Threads the field-name path from `rootPath` to each hit, so callers can
+* build canonical {@link createLocalPObjectId}s without relying on the
+* accessor itself to remember its path.
+*
+* Includes `root` itself in the walk.
+*/
+function findDescendantsByType(opts) {
+	const { root, rootPath, collectTypes, descendTypes = DESCEND_TYPES } = opts;
+	const collectSet = new Set(collectTypes);
+	const descendSet = new Set(descendTypes);
+	const result = [];
+	const stack = [{
+		node: root,
+		path: rootPath
+	}];
+	while (stack.length > 0) {
+		const { node, path } = stack.pop();
+		const typeName = node.resourceType.name;
+		if (collectSet.has(typeName)) {
+			result.push({
+				node,
+				path
+			});
+			continue;
+		}
+		if (!descendSet.has(typeName)) continue;
+		const fields = node.listInputFields();
+		for (let i = fields.length - 1; i >= 0; i--) {
+			const child = node.traverse({
+				field: fields[i],
+				assertFieldType: "Input",
+				ignoreError: true
+			});
+			if (child !== void 0) stack.push({
+				node: child,
+				path: [...path, fields[i]]
+			});
+		}
+	}
+	return result;
+}
+/**
+* Walk an accessor root and return one {@link LeafEntry} per discovered column.
+* Ids are {@link createLocalPObjectId}-shaped: `{resolvePath, name}`. The
+* `resolvePath` is derived from `rootPath` extended by the DFS traversal.
+*/
+function indexAccessorRoot(root, rootPath) {
+	const result = [];
+	for (const { node, path } of findDescendantsByType({
+		root,
+		rootPath,
+		collectTypes: COLLECT_TYPES,
+		descendTypes: DESCEND_TYPES
+	})) for (const name of listColumnNames(node)) result.push({
+		accessor: node,
+		name,
+		id: createLocalPObjectId([...path], name)
+	});
+	return result;
+}
+/**
+* Walk one upstream-block ctx pair (`prodCtx` then `stagingCtx`) and return one
+* {@link LeafEntry} per column. First-wins dedup by name (prod precedes staging).
+* Ids are {@link createGlobalPObjectId}-shaped — `resolvePath` is not involved.
+*/
+function indexPoolBlock(block) {
+	const accessors = [];
+	if (block.prodCtx) accessors.push(block.prodCtx);
+	if (block.stagingCtx) accessors.push(block.stagingCtx);
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const accessor of accessors) for (const name of listColumnNames(accessor)) {
+		if (seen.has(name)) continue;
+		seen.add(name);
+		result.push({
+			accessor,
+			name,
+			id: createGlobalPObjectId(block.blockId, name)
+		});
+	}
+	return result;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/column_registry.js
+/**
+* Id-index over a set of {@link ColumnEntriesProvider}s. Sole job:
+* {@link PObjectId} → {@link LeafEntry}. Generic over the accessor flavour, so
+* the same class backs both sandbox (`TreeNodeAccessor`) and host
+* (`PlTreeNodeAccessor`) usage.
+*
+* Stateless beyond the provider list — every lookup goes through each
+* provider's `getPObjectEntries()` (cached inside the provider). Instantiate
+* directly at the call site that has the providers; there is no ambient
+* singleton.
+*/
+var ColumnRegistry = class {
+	providers;
+	constructor(providers) {
+		this.providers = providers;
+	}
+	/**
+	* Resolve a {@link PObjectId} to its backing {@link LeafEntry}. Returns
+	* `undefined` if the column is not reachable from any provider — caller
+	* decides whether that's `absent` or `resolving` via {@link isFinal}.
+	*/
+	resolve(id) {
+		return this.lookupById(id);
+	}
+	/** Whether every indexed source has finished enumerating its columns. */
+	isFinal() {
+		return this.providers.every((p) => p.isFinal());
+	}
+	lookupById(id) {
+		for (const p of this.providers) {
+			const hit = p.getPObjectEntries().get(id);
+			if (hit !== void 0) return hit;
+		}
+	}
+};
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/dedup.js
+/**
+* Two-track dedup over an item stream keyed by `ColumnUniversalId`:
+*
+* - **Raw `PObjectId`s** are deduped by `deriveNativeId(spec)`. The same
+*   physical column reached via outputs vs. result_pool has different
+*   id shapes but identical nativeId — first occurrence wins so the
+*   provider order (outputs before pool) decides which id is canonical.
+* - **Non-`PObjectId` ids** (e.g. `SUniversalPColumnUniversalId`,
+*   `ColumnDiscoveredId`) keep raw-id dedup — they legitimately share
+*   nativeId with siblings.
+*
+* When `getSpec` returns `undefined` for a `PObjectId`, falls back to raw-id
+* dedup (so an unresolvable id still survives instead of dropping silently).
+*
+* Shared by sandbox-side `extractColumns` (column_providers) and host-side
+* `ColumnsCollectionDriverImpl.getColumns` — both layers need identical
+* dedup semantics, but operate on different concrete item types (DataColumnRecipe
+* vs. raw ColumnUniversalId).
+*/
+function dedupColumns(items, getId, getSpec) {
+	const seenNative = /* @__PURE__ */ new Set();
+	const seenId = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const item of items) {
+		const id = getId(item);
+		if (seenId.has(id)) continue;
+		if (isPObjectId(id)) {
+			const spec = getSpec(item);
+			if (spec !== void 0) {
+				const nativeId = deriveNativeId(spec);
+				if (seenNative.has(nativeId)) continue;
+				seenNative.add(nativeId);
+			}
+		}
+		seenId.add(id);
+		out.push(item);
+	}
+	return out;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/providers.js
+/**
+* Generic entries provider over a single accessor root. Walks `<root>` once
+* from the supplied `rootPath`, builds an id → {@link LeafEntry} map and
+* exposes `isFinal()` via the root's `getInputsLocked()`.
+*
+* Used directly on the host side; sandbox extends it with `getColumns()`
+* returning {@link DataColumnRecipe}s — see `AccessorColumnsProvider` in
+* `@platforma-sdk/model`.
+*/
+var AccessorEntriesProvider = class {
+	root;
+	entries;
+	constructor(root, rootPath) {
+		this.root = root;
+		const map = /* @__PURE__ */ new Map();
+		for (const entry of indexAccessorRoot(root, rootPath)) if (!map.has(entry.id)) map.set(entry.id, entry);
+		this.entries = map;
+	}
+	getPObjectEntries() {
+		return this.entries;
+	}
+	isFinal() {
+		return this.root.getInputsLocked();
+	}
+};
+/**
+* Generic entries provider over a list of upstream-block ctx pairs.
+*
+* Per-block merge: iterate `prod` then `staging`, dedupe by name with
+* first-wins semantics (prod takes precedence).
+*
+* `isFinal()` is the AND of `getInputsLocked()` over every present ctx
+* accessor and `!prodIncomplete && !stagingIncomplete` over every block.
+*/
+var ResultPoolEntriesProvider = class {
+	blocks;
+	cachedEntries;
+	constructor(blocks) {
+		this.blocks = blocks;
+	}
+	getPObjectEntries() {
+		if (this.cachedEntries !== void 0) return this.cachedEntries;
+		const map = /* @__PURE__ */ new Map();
+		for (const block of this.blocks) for (const entry of indexPoolBlock(block)) if (!map.has(entry.id)) map.set(entry.id, entry);
+		return this.cachedEntries = map;
+	}
+	isFinal() {
+		for (const block of this.blocks) {
+			if (block.prodIncomplete || block.stagingIncomplete) return false;
+			if (block.prodCtx && !block.prodCtx.getInputsLocked()) return false;
+			if (block.stagingCtx && !block.stagingCtx.getInputsLocked()) return false;
+		}
+		return true;
+	}
+};
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/template/template_ref_form.js
+/**
+* Whether `value` is a reference in the readable spelling.
+*
+* Exact about its keys, because the shape lives inside params a kind owns: `{ block, name }`
+* and nothing else. A value carrying `__isRef` is a `PlRef` already and is not this — the two
+* are told apart by shape and never overlap.
+*/
+function isTemplatePlRef(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const keys = Object.keys(value);
+	if (keys.length !== 2 || !keys.includes("block") || !keys.includes("name")) return false;
+	const { block, name } = value;
+	return typeof block === "string" && typeof name === "string";
+}
+/**
+* Expand every readable reference form in `params` into the form the system stores.
+*
+* Named for the job and not for today's only case. One readable form exists so far —
+* {@link TemplatePlRef}, the leaf reference — and the rest of the identifier system is meant to
+* follow: `TemplateCUId` / `TemplateCUKey`, readable spellings of the filtered, discovered and
+* overridden column keys, whose long forms are far worse to type than a `PlRef`'s.
+*
+* **Adding one is a recognizer plus an expander**, checked before the generic object case, the
+* way `isTemplatePlRef` / `expandTemplatePlRef` are below. Two rules a nesting form has to
+* respect, both consequences of how the stored forms are built:
+*
+* - **Expand bottom-up.** A wrapper key holds its source as a canonical *string*, not as an
+*   object, so the inner reference must be expanded and serialized before the outer key can be
+*   assembled. Descending after building the outer form would leave the inner spelling inside a
+*   string nothing looks at again.
+* - **Canonicalize what you build.** An identifier IS its canonical string; a key assembled
+*   with keys in another order is a different identifier for the same column.
+*
+* What comes out names its upstreams by template-local entry id — the same thing a `PlRef` in a
+* template file means. Turning those into the ids of real blocks is {@link relocateBlockIds},
+* which runs right after and treats an expanded reference exactly like one the file spelled out
+* in full.
+*
+* Needs nothing but the params. That is a property of the forms, not a coincidence: a readable
+* spelling carries the same information as the form it stands for, so expansion is a rewrite and
+* never a lookup. A form that needed the document to expand — a reference by position, say —
+* would have to be resolved somewhere that knows the document, and would drag that knowledge
+* into every caller of this. Keep them information-preserving.
+*/
+function expandTemplateRefs(params) {
+	const walk = (node) => {
+		if (isTemplatePlRef(node)) return expandTemplatePlRef(node);
+		if (Array.isArray(node)) return node.map(walk);
+		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([k, v]) => [k, walk(v)]));
+		return node;
+	};
+	return walk(params);
+}
+/**
+* The leaf form's expander: `{ block, name }` becomes the `PlRef` it stands for.
+*
+* An id naming no entry is passed through, like a hand-written `PlRef` would be: an id naming
+* nothing and an id naming an entry created later are indistinguishable, and both are meant to
+* arrive at a block that reports itself as missing references.
+*/
+function expandTemplatePlRef(ref) {
+	return {
+		__isRef: true,
+		blockId: ref.block,
+		name: ref.name
+	};
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/template/template_relocate.js
+/**
+* Point every column identifier in a block's params at the blocks of the project being built.
+*
+* The whole of what a template does about references, and it lives here — in the package the
+* block's own bundle imports — because knowing which values carry block ids is knowing the
+* reference system. The engine carrying the params neither marks them, reads them, nor
+* rewrites them: it hands the block its params and this map, and takes back what comes out.
+*
+* Params travel verbatim precisely so that this is possible. A file holds a `PlRef` as the
+* object the block stored and a column id as the canonical string the block stored, with no
+* marker of any kind, and the identifiers are found here by recognizing them — the same way
+* the project's own dependency detector finds them in live args.
+*
+* Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields
+* are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*
+* like an id — a `domain` entry, an axis filter — from being rewritten along with it, and
+* what re-sorts a qualifications map whose keys are identifiers.
+*
+* An id the map does not mention is left as it is. That is the ordering rule doing its work:
+* a caller building the map as it creates blocks passes only the entries already created, so
+* a reference to an entry further down the file stays pointing at a block that does not
+* exist, and the applied block reports itself as missing references rather than being wired
+* to something below it.
+*
+* @param params Whatever the block projected, as the document stored it
+* @param blockIds template-local entry id → the block id that entry was given
+*/
+function relocateBlockIds(params, blockIds) {
+	if (blockIds.size === 0) return params;
+	const remapBlockId = (blockId) => blockIds.get(blockId) ?? blockId;
+	const walk = (node) => {
+		if (typeof node === "string") return remapColumnIdBlockIds(node, remapBlockId);
+		if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);
+		if (Array.isArray(node)) return node.map(walk);
+		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [remapColumnIdBlockIds(key, remapBlockId), walk(value)]));
+		return node;
+	};
+	return walk(params);
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_migrations.js
+/** Create a DataVersioned wrapper with correct shape */
+function makeVersionedData(version, data) {
+	return {
+		version,
+		data
+	};
+}
+/** Thrown by recover() to signal unrecoverable data. */
+var DataUnrecoverableError = class extends Error {
+	name = "DataUnrecoverableError";
+	constructor(dataVersion) {
+		super(`Unknown version '${dataVersion}'`);
+	}
+};
+function isDataUnrecoverableError(error) {
+	return error instanceof Error && error.name === "DataUnrecoverableError";
+}
+/**
+* Default recover function for unknown versions.
+* Use as fallback at the end of custom recover functions.
+*
+* @example
+* .recover((version, data) => {
+*   if (version === 'legacy') {
+*     return transformLegacyData(data);
+*   }
+*   return defaultRecover(version, data);
+* })
+*/
+const defaultRecover = (version, _data) => {
+	throw new DataUnrecoverableError(version);
+};
+/** Symbol for internal builder creation method */
+const FROM_BUILDER = Symbol("fromBuilder");
+/**
+* Abstract base for both migration chain types.
+* Holds shared state, buildStep() helper, and init().
+* migrate() cannot be shared due to a TypeScript limitation: when the base class
+* migrate() return type is abstract, subclasses cannot narrow it without losing type safety.
+* Each subclass therefore owns its migrate() with the correct concrete return type.
+*
+* @internal
+*/
+var MigrationChainBase = class {
+	versionChain;
+	migrationSteps;
+	transferSteps;
+	/** Kind reference seeded by the builder, threaded through the chain into init(). */
+	kindRef;
+	/** The kind's runtime params check, carried for `init()` to hand to the DataModel. */
+	parseInitializationParams;
+	constructor(state) {
+		this.versionChain = state.versionChain;
+		this.migrationSteps = state.steps;
+		this.transferSteps = state.transferSteps ?? [];
+		this.kindRef = state.kindRef;
+		this.parseInitializationParams = state.parseInitializationParams;
+	}
+	/** Appends a migration step and returns the new versionChain and steps arrays. */
+	buildStep(nextVersion, fn) {
+		if (this.versionChain.includes(nextVersion)) throw new Error(`Duplicate version '${nextVersion}' in migration chain`);
+		const step = {
+			fromVersion: this.versionChain[this.versionChain.length - 1],
+			toVersion: nextVersion,
+			migrate: fn
+		};
+		return {
+			versionChain: [...this.versionChain, nextVersion],
+			steps: [...this.migrationSteps, step]
+		};
+	}
+	/** Validates uniqueness and records a TransferStep. */
+	buildTransfer(target, extract) {
+		if (this.transferSteps.some((t) => t.pluginId === target.id)) throw new Error(`Duplicate transfer for plugin '${target.id}'`);
+		const entry = {
+			pluginId: target.id,
+			beforeStepIndex: this.migrationSteps.length,
+			extract,
+			targetVersion: target.transferVersion
+		};
+		return { transferSteps: [...this.transferSteps, entry] };
+	}
+	/** Returns recover-specific fields for DataModel construction. Overridden by WithRecover. */
+	recoverState() {
+		return {};
+	}
+	/**
+	* Finalize the DataModel with initial data factory.
+	*
+	* @param initialData - Factory function returning the initial state
+	* @returns Finalized DataModel instance
+	*/
+	init(initialData) {
+		return DataModel[FROM_BUILDER]({
+			versionChain: this.versionChain,
+			steps: this.migrationSteps,
+			transferSteps: this.transferSteps,
+			initialDataFn: initialData,
+			kindRef: this.kindRef,
+			parseInitializationParams: this.parseInitializationParams,
+			...this.recoverState()
+		});
+	}
+};
+/**
+* Migration chain after recover() or upgradeLegacy() has been called.
+* Further migrate() and transfer() calls are allowed; recover() and upgradeLegacy() are not
+* (enforced by type — no such methods on this class).
+*
+* @typeParam Current - Data type at the current point in the chain
+* @typeParam Transfers - Accumulated transfer types keyed by plugin ID
+* @internal
+*/
+var DataModelMigrationChainWithRecover = class DataModelMigrationChainWithRecover extends MigrationChainBase {
+	recoverFn;
+	recoverFromIndex;
+	/** @internal */
+	constructor(state) {
+		super(state);
+		this.recoverFn = state.recoverFn;
+		this.recoverFromIndex = state.recoverFromIndex;
+	}
+	recoverState() {
+		return {
+			recoverFn: this.recoverFn,
+			recoverFromIndex: this.recoverFromIndex
+		};
+	}
+	/**
+	* Add a migration step. Same semantics as on the base chain.
+	* recover() and upgradeLegacy() are not available — one has already been called.
+	*/
+	migrate(nextVersion, fn) {
+		const { versionChain, steps } = this.buildStep(nextVersion, fn);
+		return new DataModelMigrationChainWithRecover({
+			versionChain,
+			steps,
+			transferSteps: this.transferSteps,
+			kindRef: this.kindRef,
+			parseInitializationParams: this.parseInitializationParams,
+			recoverFn: this.recoverFn,
+			recoverFromIndex: this.recoverFromIndex
+		});
+	}
+	/**
+	* Extract data at the current chain position for seeding a new plugin.
+	* The extract function's return type must match the plugin's transfer data type.
+	* Duplicate plugin IDs are rejected at both type and runtime level.
+	*/
+	transfer(target, extract) {
+		const { transferSteps } = this.buildTransfer(target, extract);
+		return new DataModelMigrationChainWithRecover({
+			versionChain: this.versionChain,
+			steps: this.migrationSteps,
+			transferSteps,
+			kindRef: this.kindRef,
+			parseInitializationParams: this.parseInitializationParams,
+			recoverFn: this.recoverFn,
+			recoverFromIndex: this.recoverFromIndex
+		});
+	}
+};
+/**
+* Migration chain builder.
+* Each migrate() call advances the current data type. recover() can be called once
+* at any point — it removes itself from the returned chain so it cannot be called again.
+* Duplicate version keys throw at runtime.
+*
+* @typeParam Current - Data type at the current point in the migration chain
+* @typeParam Transfers - Accumulated transfer types keyed by plugin ID
+* @internal
+*/
+var DataModelMigrationChain = class DataModelMigrationChain extends MigrationChainBase {
+	/** @internal */
+	constructor({ versionChain, steps = [], transferSteps = [], kindRef, parseInitializationParams }) {
+		super({
+			versionChain,
+			steps,
+			transferSteps,
+			kindRef,
+			parseInitializationParams
+		});
+	}
+	/**
+	* Add a migration step transforming data from the current version to the next.
+	*
+	* @typeParam Next - Data type of the next version
+	* @param nextVersion - Version key to migrate to (must be unique in the chain)
+	* @param fn - Migration function
+	* @returns Builder with the next version as current
+	*
+	* @example
+	* .migrate<BlockDataV2>("v2", (v1) => ({ ...v1, labels: [] }))
+	*/
+	migrate(nextVersion, fn) {
+		const { versionChain, steps } = this.buildStep(nextVersion, fn);
+		return new DataModelMigrationChain({
+			versionChain,
+			steps,
+			transferSteps: this.transferSteps,
+			kindRef: this.kindRef,
+			parseInitializationParams: this.parseInitializationParams
+		});
+	}
+	/**
+	* Extract data at the current chain position for seeding a new plugin.
+	* The extract function's return type must match the plugin's transfer data type.
+	* Duplicate plugin IDs are rejected at both type and runtime level.
+	*
+	* Calling .transfer() on DataModelInitialChain returns DataModelMigrationChain,
+	* which removes .upgradeLegacy() from the chain (preventing a problematic combination).
+	*
+	* @example
+	* .from<V1>("v1")
+	* .transfer(tablePlugin, (v1) => ({ state: v1.tableState }))
+	* .migrate<V2>("v2", ({ tableState: _, ...rest }) => rest)
+	*/
+	transfer(target, extract) {
+		const { transferSteps } = this.buildTransfer(target, extract);
+		return new DataModelMigrationChain({
+			versionChain: this.versionChain,
+			steps: this.migrationSteps,
+			transferSteps,
+			kindRef: this.kindRef,
+			parseInitializationParams: this.parseInitializationParams
+		});
+	}
+	/**
+	* Set a recovery handler for unknown or legacy versions.
+	*
+	* The recover function is called when data has a version not in the migration chain.
+	* It must return data of the type at this point in the chain (Current). Any migrate()
+	* steps added after recover() will then run on the recovered data.
+	*
+	* Can only be called once — the returned chain has no recover() method.
+	*
+	* @param fn - Recovery function returning Current (the type at this chain position)
+	* @returns Builder with migrate() and init() but without recover()
+	*
+	* @example
+	* // Recover between migrations — recovered data goes through v3 migration
+	* new DataModelBuilder<V1>("v1")
+	*   .migrate<V2>("v2", (v1) => ({ ...v1, label: "" }))
+	*   .recover((version, data) => {
+	*     if (version === 'legacy') return transformLegacy(data); // returns V2
+	*     return defaultRecover(version, data);
+	*   })
+	*   .migrate<V3>("v3", (v2) => ({ ...v2, description: "" }))
+	*   .init(() => ({ count: 0, label: "", description: "" }));
+	*/
+	recover(fn) {
+		return new DataModelMigrationChainWithRecover({
+			versionChain: this.versionChain,
+			steps: this.migrationSteps,
+			transferSteps: this.transferSteps,
+			kindRef: this.kindRef,
+			parseInitializationParams: this.parseInitializationParams,
+			recoverFn: fn,
+			recoverFromIndex: this.migrationSteps.length
+		});
+	}
+};
+/**
+* Initial migration chain returned by `.from()`.
+* Extends DataModelMigrationChain with `upgradeLegacy()` — available only before
+* any `.migrate()` calls, since legacy data always arrives at the initial version.
+*
+* @typeParam Current - Data type at the initial version
+* @typeParam Transfers - Accumulated transfer types keyed by plugin ID
+* @internal
+*/
+var DataModelInitialChain = class extends DataModelMigrationChain {
+	/**
+	* Handle legacy V1 model state ({ args, uiState }) when upgrading a block from
+	* BlockModel V1 to BlockModelV3.
+	*
+	* When a V1 block is upgraded, its stored state `{ args, uiState }` is normalized
+	* to the internal default version. This method inserts a migration step from that
+	* internal version to the version specified in `.from()`, using the provided typed
+	* callback to transform the legacy shape. Non-legacy data passes through unchanged.
+	*
+	* Must be called right after `.from()` — not available after `.migrate()` calls.
+	* Any `.migrate()` steps added after `upgradeLegacy()` will run on the transformed result.
+	*
+	* Can only be called once — the returned chain has no upgradeLegacy() method.
+	* Mutually exclusive with recover().
+	*
+	* @typeParam Args - Type of the legacy block args
+	* @typeParam UiState - Type of the legacy block uiState
+	* @param fn - Typed transform from { args, uiState } to Current
+	* @returns Builder with migrate() and init() but without recover() or upgradeLegacy()
+	*
+	* @example
+	* type OldArgs = { inputFile: string; threshold: number };
+	* type OldUiState = { selectedTab: string };
+	* type BlockData = { inputFile: string; threshold: number; selectedTab: string };
+	*
+	* const dataModel = new DataModelBuilder()
+	*   .from<BlockData>("v1")
+	*   .upgradeLegacy<OldArgs, OldUiState>(({ args, uiState }) => ({
+	*     inputFile: args.inputFile,
+	*     threshold: args.threshold,
+	*     selectedTab: uiState.selectedTab,
+	*   }))
+	*   .init(() => ({ inputFile: '', threshold: 0, selectedTab: 'main' }));
+	*/
+	upgradeLegacy(fn) {
+		const wrappedFn = (data) => {
+			if (data !== null && typeof data === "object" && "args" in data) return fn(data);
+			return data;
+		};
+		const step = {
+			fromVersion: DATA_MODEL_LEGACY_VERSION,
+			toVersion: this.versionChain[0],
+			migrate: wrappedFn
+		};
+		return new DataModelMigrationChainWithRecover({
+			versionChain: [DATA_MODEL_LEGACY_VERSION, ...this.versionChain],
+			steps: [step, ...this.migrationSteps],
+			kindRef: this.kindRef,
+			parseInitializationParams: this.parseInitializationParams,
+			transferSteps: this.transferSteps.map((t) => ({
+				...t,
+				beforeStepIndex: t.beforeStepIndex + 1
+			}))
+		});
+	}
+};
+/**
+* Builder entry point for creating DataModel with type-safe migrations.
+*
+* @example
+* // Simple (no migrations):
+* const dataModel = new DataModelBuilder()
+*   .from<BlockData>("v1")
+*   .init(() => ({ numbers: [] }));
+*
+* @example
+* // With migrations:
+* const dataModel = new DataModelBuilder()
+*   .from<BlockDataV1>("v1")
+*   .migrate<BlockDataV2>("v2", (v1) => ({ ...v1, labels: [] }))
+*   .migrate<BlockDataV3>("v3", (v2) => ({ ...v2, description: '' }))
+*   .init(() => ({ numbers: [], labels: [], description: '' }));
+*
+* @example
+* // With recover() between migrations — recovered data goes through remaining migrations:
+* const dataModelChain = new DataModelBuilder()
+*   .from<BlockDataV1>("v1")
+*   .migrate<BlockDataV2>("v2", (v1) => ({ ...v1, labels: [] }));
+*
+* // recover() placed before the v3 migration: recovered data goes through v3
+* const dataModel = dataModelChain
+*   .recover((version, data) => {
+*     if (version === 'legacy' && isLegacyData(data)) return transformLegacy(data); // returns V2
+*     return defaultRecover(version, data);
+*   })
+*   .migrate<BlockDataV3>("v3", (v2) => ({ ...v2, description: '' }))
+*   .init(() => ({ numbers: [], labels: [], description: '' }));
+*
+* @example
+* // With upgradeLegacy() — typed upgrade from BlockModel V1 state:
+* type OldArgs = { inputFile: string };
+* type OldUiState = { selectedTab: string };
+* type BlockData = { inputFile: string; selectedTab: string };
+*
+* const dataModel = new DataModelBuilder()
+*   .from<BlockData>("v1")
+*   .upgradeLegacy<OldArgs, OldUiState>(({ args, uiState }) => ({
+*     inputFile: args.inputFile,
+*     selectedTab: uiState.selectedTab,
+*   }))
+*   .init(() => ({ inputFile: '', selectedTab: 'main' }));
+*/
+var DataModelBuilder = class {
+	#kindRef;
+	#parseInitializationParams;
+	/**
+	* @param opts.kind - The block kind this data model implements. Its reference
+	*   is captured and baked into the config so the manifest can advertise which
+	*   kind the block satisfies, and its `Params` type flows into `.init()`.
+	*   Optional during the transition window while existing V3 blocks are
+	*   migrated to kind-carrying builders; a kind-less builder simply carries no
+	*   reference and the reconciler can't project it yet. Object form mirrors
+	*   `BlockModelV3.create({ dataModel, kind })`.
+	*/
+	constructor(opts) {
+		this.#kindRef = opts?.kind ? formatKindRef(opts.kind) : void 0;
+		this.#parseInitializationParams = opts?.kind?.parseInitializationParams;
+	}
+	/**
+	* Start the migration chain with the given initial data type and version key.
+	*
+	* @typeParam T - Data type for the initial version
+	* @param initialVersion - Version key string (e.g. "v1")
+	* @returns Migration chain builder
+	*/
+	from(initialVersion) {
+		return new DataModelInitialChain({
+			versionChain: [initialVersion],
+			kindRef: this.#kindRef,
+			parseInitializationParams: this.#parseInitializationParams
+		});
+	}
+};
+/**
+* DataModel defines the block's data structure, initial values, and migrations.
+* Used by BlockModelV3 to manage data state.
+*
+* Use `new DataModelBuilder()` to create a DataModel.
+*
+* @example
+* // With recover() between migrations:
+* // Recovered data (V2) goes through the v2→v3 migration automatically.
+* const dataModel = new DataModelBuilder()
+*   .from<V1>("v1")
+*   .migrate<V2>("v2", (v1) => ({ ...v1, label: "" }))
+*   .recover((version, data) => {
+*     if (version === "legacy") return transformLegacy(data); // returns V2
+*     return defaultRecover(version, data);
+*   })
+*   .migrate<V3>("v3", (v2) => ({ ...v2, description: "" }))
+*   .init(() => ({ count: 0, label: "", description: "" }));
+*/
+var DataModel = class DataModel {
+	/** Latest version key — O(1) access for the common "already current" check. */
+	latestVersion;
+	/** Maps each known version key to the index of the first step to run from it. O(1) lookup. */
+	stepsByFromVersion;
+	steps;
+	transferSteps;
+	initialDataFn;
+	recoverFn;
+	recoverFromIndex;
+	/** Reference to the block kind this data model was built for, if any. */
+	_kindRef;
+	/** The kind's runtime params check, if it declares one. */
+	_parseInitializationParams;
+	constructor({ versionChain, steps, transferSteps = [], initialDataFn, kindRef, parseInitializationParams, recoverFn = defaultRecover, recoverFromIndex }) {
+		if (versionChain.length === 0) throw new Error("DataModel requires at least one version key");
+		this.latestVersion = versionChain[versionChain.length - 1];
+		this.stepsByFromVersion = new Map(versionChain.map((v, i) => [v, i]));
+		this.steps = steps;
+		this.transferSteps = transferSteps;
+		this.initialDataFn = initialDataFn;
+		this._kindRef = kindRef;
+		this._parseInitializationParams = parseInitializationParams;
+		this.recoverFn = recoverFn;
+		this.recoverFromIndex = recoverFromIndex ?? steps.length;
+	}
+	/**
+	* Internal method for creating DataModel from builder.
+	* Uses Symbol key to prevent external access.
+	* @internal
+	*/
+	static [FROM_BUILDER](state) {
+		return new DataModel(state);
+	}
+	/**
+	* Reference to the block kind this data model was built for, or `undefined`
+	* for a kind-less builder. Used by `BlockModelV3.create` to cross-check that
+	* the kind handed to the builder matches the kind handed to `create`.
+	* @internal
+	*/
+	get kindRef() {
+		return this._kindRef;
+	}
+	/**
+	* The kind's runtime params check, or `undefined` if the kind declares none (or
+	* there is no kind). Read by `BlockModelV3.done()` to register the check, and
+	* carried here rather than only on the model because `init` — the one place params
+	* are consumed — lives on this side.
+	* @internal
+	*/
+	get templateParamsParser() {
+		return this._parseInitializationParams;
+	}
+	/**
+	* The latest (current) version key in the migration chain.
+	*/
+	get version() {
+		return this.latestVersion;
+	}
+	/**
+	* Get a fresh copy of the initial data.
+	*/
+	initialData() {
+		return this.initialDataFn({});
+	}
+	/**
+	* Get initial data wrapped with current version.
+	* Used when creating new blocks or resetting to defaults.
+	*/
+	getDefaultData() {
+		return makeVersionedData(this.latestVersion, this.initialDataFn({}));
+	}
+	/**
+	* Get initial data built from params, wrapped with current version.
+	*
+	* The counterpart of {@link getDefaultData} for a block created from a template
+	* entry: the factory receives the entry's params instead of nothing. A factory
+	* that ignores its argument produces the same result as `getDefaultData`, which
+	* is why the two are separate methods rather than one optional argument — the
+	* caller decides which contract it is asking for, and a block that cannot honour
+	* params must not silently look like one that can.
+	*
+	* References inside `params` are already resolved to the target project's
+	* concrete ids by the time they get here; the factory never sees a
+	* template-local one.
+	*/
+	getDataFromParams(params) {
+		return makeVersionedData(this.latestVersion, this.initialDataFn({ params }));
+	}
+	recoverFrom(data, version) {
+		let currentData = this.recoverFn(version, data);
+		for (let i = this.recoverFromIndex; i < this.steps.length; i++) currentData = this.steps[i].migrate(currentData);
+		return {
+			version: this.latestVersion,
+			data: currentData
+		};
+	}
+	/**
+	* Migrate versioned data from any version to the latest.
+	* Collects transfer extractions at their designated chain positions.
+	*
+	* - If version is in chain, applies needed migrations (O(1) lookup)
+	* - If version is unknown, attempts recovery; falls back to initial data
+	* - If a migration step fails, throws so the caller can preserve original data
+	*
+	* Transfers only fire during normal step-by-step migration:
+	* - Recovery path: returns empty transfers
+	* - Fast-path (already at latest): returns empty transfers
+	*
+	* @param versioned - Data with version tag
+	* @returns Migrated data at the latest version with transfer record
+	* @throws If a migration step from a known version fails
+	*/
+	migrate(versioned) {
+		const { version: fromVersion, data } = versioned;
+		if (fromVersion === this.latestVersion) return {
+			version: this.latestVersion,
+			data,
+			transfers: {}
+		};
+		const startIndex = this.stepsByFromVersion.get(fromVersion);
+		if (startIndex === void 0) try {
+			return {
+				...this.recoverFrom(data, fromVersion),
+				transfers: {}
+			};
+		} catch {
+			return {
+				...this.getDefaultData(),
+				transfers: {}
+			};
+		}
+		let currentData = data;
+		const transfers = {};
+		for (let i = startIndex; i < this.steps.length; i++) {
+			for (const t of this.transferSteps) if (t.beforeStepIndex === i) transfers[t.pluginId] = {
+				version: t.targetVersion,
+				data: t.extract(currentData)
+			};
+			currentData = this.steps[i].migrate(currentData);
+		}
+		for (const t of this.transferSteps) if (t.beforeStepIndex >= this.steps.length && t.beforeStepIndex >= startIndex) transfers[t.pluginId] = {
+			version: t.targetVersion,
+			data: t.extract(currentData)
+		};
+		return {
+			version: this.latestVersion,
+			data: currentData,
+			transfers
+		};
+	}
+};
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/services/service_injectors.js
-function buildMethodMap(pick) {
-	const result = {};
-	for (const id of Object.values(Services)) result[id] = [...pick(id)];
-	return result;
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/internal.js
+/** Utility code helping to identify whether the code is running in actual UI environment */
+function isInUI() {
+	return typeof globalThis.getPlatforma !== "undefined" || typeof globalThis.platforma !== "undefined";
 }
-buildMethodMap(getServiceUiMethods);
-buildMethodMap(getServiceModelMethods);
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/columns/accessor_traversal.js
-/** Resource types that hold column collections — DFS stops here and collects. */
-const COLLECT_TYPES = [ResourceTypeName.PFrame];
-/** Resource types DFS descends through when looking for PFrames. */
-const DESCEND_TYPES = [ResourceTypeName.StdMap, ResourceTypeName.StdMapSlash];
-/**
-* Enumerate column names backing a PFrame accessor — derived from
-* `<name>.spec` field names, without resolving the spec resources.
-*/
-function listColumnNames(accessor, prefix = "") {
-	if (accessor.resourceType.name !== ResourceTypeName.PFrame) return [];
-	const out = [];
-	for (const field of accessor.listInputFields()) {
-		if (!field.endsWith(".spec")) continue;
-		const raw = field.slice(0, -5);
-		if (!raw.startsWith(prefix)) continue;
-		out.push(raw.slice(prefix.length));
-	}
-	return out;
+/** Utility code helping to retrieve a platforma instance form the environment */
+function getPlatformaInstance(config) {
+	if (config && typeof globalThis.getPlatforma === "function") return globalThis.getPlatforma(config);
+	else if (typeof globalThis.platforma !== "undefined") return globalThis.platforma;
+	else throw new Error("Can't get platforma instance.");
+}
+function tryGetCfgRenderCtx() {
+	if (typeof globalThis.cfgRenderCtx !== "undefined") return globalThis.cfgRenderCtx;
+	else return void 0;
+}
+function getCfgRenderCtx() {
+	if (typeof globalThis.cfgRenderCtx !== "undefined") return globalThis.cfgRenderCtx;
+	else throw new Error("Not in config rendering context");
+}
+function tryRegisterCallback(key, callback) {
+	const ctx = tryGetCfgRenderCtx();
+	if (ctx === void 0) return false;
+	if (key in ctx.callbackRegistry) throw new Error(`Callback with key ${key} already registered.`);
+	ctx.callbackRegistry[key] = callback;
+	return true;
 }
 /**
-* DFS over the input-field subtree of `root`. Collects nodes whose resource
-* type ∈ `collectTypes`. Descends only through `descendTypes`
-* (default: StdMap / StdMapSlash). Collected nodes are not descended into.
-*
-* Threads the field-name path from `rootPath` to each hit, so callers can
-* build canonical {@link createLocalPObjectId}s without relying on the
-* accessor itself to remember its path.
+* Registers a callback, replacing any existing callback with the same key.
+* Use this for callbacks that have a default value but can be overridden.
 *
-* Includes `root` itself in the walk.
+* @param key - The callback registry key
+* @param callback - The callback function to register
+* @returns true if registered, false if not in render context
 */
-function findDescendantsByType(opts) {
-	const { root, rootPath, collectTypes, descendTypes = DESCEND_TYPES } = opts;
-	const collectSet = new Set(collectTypes);
-	const descendSet = new Set(descendTypes);
-	const result = [];
-	const stack = [{
-		node: root,
-		path: rootPath
-	}];
-	while (stack.length > 0) {
-		const { node, path } = stack.pop();
-		const typeName = node.resourceType.name;
-		if (collectSet.has(typeName)) {
-			result.push({
-				node,
-				path
-			});
-			continue;
-		}
-		if (!descendSet.has(typeName)) continue;
-		const fields = node.listInputFields();
-		for (let i = fields.length - 1; i >= 0; i--) {
-			const child = node.traverse({
-				field: fields[i],
-				assertFieldType: "Input",
-				ignoreError: true
-			});
-			if (child !== void 0) stack.push({
-				node: child,
-				path: [...path, fields[i]]
-			});
-		}
-	}
-	return result;
+function replaceCallback(key, callback) {
+	const ctx = tryGetCfgRenderCtx();
+	if (ctx === void 0) return false;
+	ctx.callbackRegistry[key] = callback;
+	return true;
 }
-/**
-* Walk an accessor root and return one {@link LeafEntry} per discovered column.
-* Ids are {@link createLocalPObjectId}-shaped: `{resolvePath, name}`. The
-* `resolvePath` is derived from `rootPath` extended by the DFS traversal.
-*/
-function indexAccessorRoot(root, rootPath) {
-	const result = [];
-	for (const { node, path } of findDescendantsByType({
-		root,
-		rootPath,
-		collectTypes: COLLECT_TYPES,
-		descendTypes: DESCEND_TYPES
-	})) for (const name of listColumnNames(node)) result.push({
-		accessor: node,
-		name,
-		id: createLocalPObjectId([...path], name)
+/** Creates a ConfigRenderLambda descriptor without registering a callback. */
+function createRenderLambda(opts) {
+	const { handle, ...flags } = opts;
+	return {
+		__renderLambda: true,
+		handle,
+		...flags
+	};
+}
+/** Registers a callback and returns a ConfigRenderLambda descriptor. */
+function createAndRegisterRenderLambda(opts, replace) {
+	const { handle, lambda, ...flags } = opts;
+	if (replace) replaceCallback(handle, lambda);
+	else tryRegisterCallback(handle, lambda);
+	return createRenderLambda({
+		handle,
+		...flags
 	});
-	return result;
 }
-/**
-* Walk one upstream-block ctx pair (`prodCtx` then `stagingCtx`) and return one
-* {@link LeafEntry} per column. First-wins dedup by name (prod precedes staging).
-* Ids are {@link createGlobalPObjectId}-shaped — `resolvePath` is not involved.
-*/
-function indexPoolBlock(block) {
-	const accessors = [];
-	if (block.prodCtx) accessors.push(block.prodCtx);
-	if (block.stagingCtx) accessors.push(block.stagingCtx);
-	const result = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const accessor of accessors) for (const name of listColumnNames(accessor)) {
-		if (seen.has(name)) continue;
-		seen.add(name);
-		result.push({
-			accessor,
-			name,
-			id: createGlobalPObjectId(block.blockId, name)
-		});
+const futureResolves = /* @__PURE__ */ new Map();
+function registerFutureAwait(handle, onResolve) {
+	if (!(handle in getCfgRenderCtx().callbackRegistry)) {
+		getCfgRenderCtx().callbackRegistry[handle] = (value) => {
+			for (const res of futureResolves.get(handle)) res(value);
+		};
+		futureResolves.set(handle, []);
 	}
-	return result;
+	futureResolves.get(handle).push(onResolve);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/columns/column_registry.js
-/**
-* Id-index over a set of {@link ColumnEntriesProvider}s. Sole job:
-* {@link PObjectId} → {@link LeafEntry}. Generic over the accessor flavour, so
-* the same class backs both sandbox (`TreeNodeAccessor`) and host
-* (`PlTreeNodeAccessor`) usage.
-*
-* Stateless beyond the provider list — every lookup goes through each
-* provider's `getPObjectEntries()` (cached inside the provider). Instantiate
-* directly at the call site that has the providers; there is no ambient
-* singleton.
-*/
-var ColumnRegistry = class {
-	providers;
-	constructor(providers) {
-		this.providers = providers;
-	}
-	/**
-	* Resolve a {@link PObjectId} to its backing {@link LeafEntry}. Returns
-	* `undefined` if the column is not reachable from any provider — caller
-	* decides whether that's `absent` or `resolving` via {@link isFinal}.
-	*/
-	resolve(id) {
-		return this.lookupById(id);
-	}
-	/** Whether every indexed source has finished enumerating its columns. */
-	isFinal() {
-		return this.providers.every((p) => p.isFinal());
-	}
-	lookupById(id) {
-		for (const p of this.providers) {
-			const hit = p.getPObjectEntries().get(id);
-			if (hit !== void 0) return hit;
-		}
-	}
-};
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/columns/dedup.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_storage_facade.js
 /**
-* Two-track dedup over an item stream keyed by `ColumnUniversalId`:
-*
-* - **Raw `PObjectId`s** are deduped by `deriveNativeId(spec)`. The same
-*   physical column reached via outputs vs. result_pool has different
-*   id shapes but identical nativeId — first occurrence wins so the
-*   provider order (outputs before pool) decides which id is canonical.
-* - **Non-`PObjectId` ids** (e.g. `SUniversalPColumnUniversalId`,
-*   `ColumnDiscoveredId`) keep raw-id dedup — they legitimately share
-*   nativeId with siblings.
-*
-* When `getSpec` returns `undefined` for a `PObjectId`, falls back to raw-id
-* dedup (so an unresolvable id still survives instead of dropping silently).
+* All facade callback names as constants.
+* These are the source of truth - the interface is derived from these.
 *
-* Shared by sandbox-side `extractColumns` (column_providers) and host-side
-* `ColumnsCollectionDriverImpl.getColumns` — both layers need identical
-* dedup semantics, but operate on different concrete item types (ColumnLazy
-* vs. raw ColumnUniversalId).
+* IMPORTANT: When adding a new callback:
+* 1. Add the constant here
+* 2. Add the callback signature to FacadeCallbackTypes below
+* 3. The BlockStorageFacade type will automatically include it
 */
-function dedupColumns(items, getId, getSpec) {
-	const seenNative = /* @__PURE__ */ new Set();
-	const seenId = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const item of items) {
-		const id = getId(item);
-		if (seenId.has(id)) continue;
-		if (isPObjectId(id)) {
-			const spec = getSpec(item);
-			if (spec !== void 0) {
-				const nativeId = deriveNativeId(spec);
-				if (seenNative.has(nativeId)) continue;
-				seenNative.add(nativeId);
-			}
-		}
-		seenId.add(id);
-		out.push(item);
-	}
-	return out;
+const BlockStorageFacadeCallbacks = {
+	StorageApplyUpdate: "__pl_storage_applyUpdate",
+	StorageDebugView: "__pl_storage_debugView",
+	StorageMigrate: "__pl_storage_migrate",
+	ArgsDerive: "__pl_args_derive",
+	PrerunArgsDerive: "__pl_prerunArgs_derive",
+	StorageInitial: "__pl_storage_initial",
+	InitializationParamsDerive: "__pl_initializationParams_derive",
+	StorageInitialFromParams: "__pl_storage_initialFromParams",
+	InitializationParamsValidate: "__pl_initializationParams_validate"
+};
+/**
+* Creates a map of lambda handles from a callbacks constant object.
+* Keys are the callback string values (e.g., '__pl_storage_applyUpdate').
+*/
+function createFacadeHandles(callbacks) {
+	return Object.fromEntries(Object.values(callbacks).map((handle) => [handle, createRenderLambda({ handle })]));
 }
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.3/node_modules/@milaboratories/pl-model-common/dist/columns/providers.js
 /**
-* Generic entries provider over a single accessor root. Walks `<root>` once
-* from the supplied `rootPath`, builds an id → {@link LeafEntry} map and
-* exposes `isFinal()` via the root's `getInputsLocked()`.
-*
-* Used directly on the host side; sandbox extends it with `getColumns()`
-* returning {@link ColumnLazy}s — see `AccessorColumnsProvider` in
-* `@platforma-sdk/model`.
+* Lambda handles for facade callbacks.
+* Used by the middle layer to invoke callbacks via executeSingleLambda().
 */
-var AccessorEntriesProvider = class {
-	root;
-	entries;
-	constructor(root, rootPath) {
-		this.root = root;
-		const map = /* @__PURE__ */ new Map();
-		for (const entry of indexAccessorRoot(root, rootPath)) if (!map.has(entry.id)) map.set(entry.id, entry);
-		this.entries = map;
-	}
-	getPObjectEntries() {
-		return this.entries;
-	}
-	isFinal() {
-		return this.root.getInputsLocked();
-	}
-};
+const BlockStorageFacadeHandles = createFacadeHandles(BlockStorageFacadeCallbacks);
+/** Register all facade callbacks at once. Ensures all required callbacks are provided. */
+function registerFacadeCallbacks(callbacks) {
+	for (const key of Object.values(BlockStorageFacadeCallbacks)) tryRegisterCallback(key, callbacks[key]);
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/services/block_services.js
 /**
-* Generic entries provider over a list of upstream-block ctx pairs.
-*
-* Per-block merge: iterate `prod` then `staging`, dedupe by name with
-* first-wins semantics (prod takes precedence).
+* Services required by all V3 blocks by default.
+* Edit this when a new service should be available to all blocks.
 *
-* `isFinal()` is the AND of `getInputsLocked()` over every present ctx
-* accessor and `!prodIncomplete && !stagingIncomplete` over every block.
+* Standalone module to avoid circular dependencies between block_model.ts
+* and service type resolution.
 */
-var ResultPoolEntriesProvider = class {
-	blocks;
-	cachedEntries;
-	constructor(blocks) {
-		this.blocks = blocks;
+const BLOCK_SERVICE_FLAGS = {
+	requiresPFrameSpec: true,
+	requiresPFrame: true,
+	requiresDialog: true,
+	requiresColumnsCollection: true
+};
+resolveRequiredServices(BLOCK_SERVICE_FLAGS);
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/render/future.js
+var FutureRef = class FutureRef {
+	handle;
+	postProcess;
+	isResolved = false;
+	resolvedValue;
+	constructor(handle, postProcess = (v) => v) {
+		this.handle = handle;
+		this.postProcess = postProcess;
+		registerFutureAwait(handle, (value) => {
+			this.resolvedValue = postProcess(value);
+			this.isResolved = true;
+		});
 	}
-	getPObjectEntries() {
-		if (this.cachedEntries !== void 0) return this.cachedEntries;
-		const map = /* @__PURE__ */ new Map();
-		for (const block of this.blocks) for (const entry of indexPoolBlock(block)) if (!map.has(entry.id)) map.set(entry.id, entry);
-		return this.cachedEntries = map;
+	map(mapping) {
+		return new FutureRef(this.handle, (v) => mapping(this.postProcess(v)));
 	}
-	isFinal() {
-		for (const block of this.blocks) {
-			if (block.prodIncomplete || block.stagingIncomplete) return false;
-			if (block.prodCtx && !block.prodCtx.getInputsLocked()) return false;
-			if (block.stagingCtx && !block.stagingCtx.getInputsLocked()) return false;
-		}
-		return true;
+	mapDefined(mapping) {
+		return new FutureRef(this.handle, (v) => {
+			const vv = this.postProcess(v);
+			return vv ? mapping(vv) : void 0;
+		});
+	}
+	toJSON() {
+		return this.isResolved ? this.resolvedValue : { __awaited_futures__: [this.handle] };
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/render/accessor.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/render/accessor.js
 function ifDef(value, cb) {
 	return value === void 0 ? void 0 : cb(value);
 }
@@ -7037,11 +7402,11 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/render/internal.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/render/internal.js
 const MainAccessorName = "main";
 const StagingAccessorName = "staging";
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/render/util/axis_filtering.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/render/util/axis_filtering.js
 function filterDataInfoEntries(dataInfoEntries, axisFilters) {
 	const sortedFilters = [...axisFilters].sort((a, b) => b[0] - a[0]);
 	const { type } = dataInfoEntries;
@@ -7105,7 +7470,7 @@ function filterDataInfoEntries(dataInfoEntries, axisFilters) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/labels/linked_column_postfix.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/labels/linked_column_postfix.js
 /**
 * Structural postfix derivation for linked columns (phase 2 of `deriveDistinctLabels`).
 *
@@ -7288,7 +7653,7 @@ function derivePostfixes(entries, format = defaultLinkerFormatter) {
 	});
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/labels/derive_distinct_labels.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/labels/derive_distinct_labels.js
 const DISTANCE_PENALTY = .001;
 const LABEL_TYPE = "__LABEL__";
 const LABEL_TYPE_FULL = "__LABEL__@1";
@@ -7576,7 +7941,7 @@ function repairBareByPresence(labels, minimized, records, stats, forcedSet, forc
 	return patched;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/render/util/label.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/render/util/label.js
 /** @deprecated Use deriveDistinctLabels */
 function deriveLabels(values, getSpec, options = {}) {
 	return deriveDistinctLabels(values.map(getSpec), options).map((label, i) => ({
@@ -7585,7 +7950,7 @@ function deriveLabels(values, getSpec, options = {}) {
 	}));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/render/util/pcolumn_data.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/render/util/pcolumn_data.js
 const RT_RESOURCE_MAP = "PColumnData/ResourceMap";
 const RT_RESOURCE_MAP_PARTITIONED = "PColumnData/Partitioned/ResourceMap";
 const RT_JSON_PARTITIONED = "PColumnData/JsonPartitioned";
@@ -7879,7 +8244,7 @@ function allPColumnsReady(columns) {
 	return columns.every(isPColumnReady);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/render/util/column_collection.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/render/util/column_collection.js
 function isPColumnValues(value) {
 	if (!Array.isArray(value)) return false;
 	if (value.length === 0) return true;
@@ -8157,23 +8522,7 @@ var PColumnCollection = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/services/block_services.js
-/**
-* Services required by all V3 blocks by default.
-* Edit this when a new service should be available to all blocks.
-*
-* Standalone module to avoid circular dependencies between block_model.ts
-* and service type resolution.
-*/
-const BLOCK_SERVICE_FLAGS = {
-	requiresPFrameSpec: true,
-	requiresPFrame: true,
-	requiresDialog: true,
-	requiresColumnsCollection: true
-};
-resolveRequiredServices(BLOCK_SERVICE_FLAGS);
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/services/service_bridge.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/services/service_bridge.js
 /**
 * Builds a ServiceProxy from a ServiceDispatch.
 * Each service method call is forwarded to dispatch.callServiceMethod.
@@ -8182,7 +8531,7 @@ function createServiceProxy(dispatch) {
 	return ((serviceId) => Object.freeze(Object.fromEntries(dispatch.getServiceMethods(serviceId).map((method) => [method, (...args) => dispatch.callServiceMethod(serviceId, method, ...args)]))));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/services/get_services.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/services/get_services.js
 const cachedServices = /* @__PURE__ */ new WeakMap();
 function getService(name, deps) {
 	const ctx = deps?.ctx ?? getCfgRenderCtx();
@@ -8196,7 +8545,7 @@ function getService(name, deps) {
 	})();
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/render/util/pframe_upgraders.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/render/util/pframe_upgraders.js
 function patchInSetFilters(filters) {
 	const inSetToOrEqual = (predicate) => {
 		if (predicate.operator !== "InSet") return predicate;
@@ -8234,7 +8583,7 @@ function patchInSetFilters(filters) {
 	return filters.map((filter) => mapFilter(filter, inSetToOrEqual));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/render/api.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/render/api.js
 /**
 * Helper function to match domain objects
 * @param query Optional domain to match against
@@ -8683,27 +9032,27 @@ var PluginRenderCtx = class extends RenderCtxBase {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/version.js
-const PlatformaSDKVersion = "1.81.1";
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/plugin_model.js
+/** Internal plugin↔block handshake. `Symbol.for` (not `Symbol`) so it stays
+* identical across multiple `@platforma-sdk/model` copies in one process. */
+const CREATE_PLUGIN_MODEL = Symbol.for("@platforma-sdk/model:createPluginModel");
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/version.js
+const PlatformaSDKVersion = "1.83.0";
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/bconfig/types.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/bconfig/types.js
 function isConfigLambda(cfgOrFh) {
 	return cfgOrFh.__renderLambda === true;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/bconfig/normalization.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/bconfig/normalization.js
 function downgradeCfgOrLambda(data) {
 	if (data === void 0) return void 0;
 	if (isConfigLambda(data)) return data.handle;
 	return data;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/plugin_model.js
-/** Internal plugin↔block handshake. `Symbol.for` (not `Symbol`) so it stays
-* identical across multiple `@platforma-sdk/model` copies in one process. */
-const CREATE_PLUGIN_MODEL = Symbol.for("@platforma-sdk/model:createPluginModel");
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/block_storage_callbacks.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_storage_callbacks.js
 /**
 * BlockStorage Callback Implementations - wired to facade callbacks in BlockModelV3.done().
 *
@@ -8823,7 +9172,16 @@ function migrateStorage(currentStorageJson, hooks) {
 * @throws If initialDataFn or createPluginData throws
 */
 function createInitialStorage(hooks) {
-	const blockDefault = hooks.getDefaultBlockData();
+	return assembleStorage(hooks.getDefaultBlockData(), hooks);
+}
+/**
+* Wraps freshly created block data and freshly created plugin data into storage.
+*
+* Shared by the two ways a block's first storage comes into being — from defaults
+* and from template params. Only the block's own data differs between them:
+* plugins have no params channel, so they are always created at their defaults.
+*/
+function assembleStorage(blockData, hooks) {
 	const pluginRegistry = hooks.getPluginRegistry();
 	const plugins = {};
 	for (const handle of Object.keys(pluginRegistry)) {
@@ -8835,52 +9193,220 @@ function createInitialStorage(hooks) {
 	}
 	return stringifyJson({
 		[BLOCK_STORAGE_KEY]: "v1",
-		__dataVersion: blockDefault.version,
-		__data: blockDefault.data,
+		__dataVersion: blockData.version,
+		__data: blockData.data,
 		__pluginRegistry: pluginRegistry,
 		__plugins: plugins
 	});
 }
 /**
+* Check params against their kind's declared shape.
+*
+* The kind owns this rather than the block because the params contract belongs to the
+* kind: many block versions implement one kind, and a per-block check would let them
+* drift from each other and from the type.
+*
+* A parser rejects by throwing and accepts by returning the params to use, so its
+* output — not the input — is what flows onward. That is what lets a kind strip keys
+* it does not declare, which is the difference between a typo being ignored and a typo
+* being reported.
+*
+* Every kind declares a parser, so every set of params that reaches here is checked;
+* there is no pass-through path.
+*
+* @param value The params to check, references already in live form
+* @param parseInitializationParams The kind's parser
+*/
+function validateTemplateParams(value, parseInitializationParams) {
+	try {
+		return { value: parseInitializationParams(value) };
+	} catch (e) {
+		return { error: `params do not match this block's kind: ${describeRejection(e)}` };
+	}
+}
+/**
+* Render whatever a parser threw as one readable line.
+*
+* An error carrying an `issues` array is unpacked rather than printed: that is the
+* shape zod (and several others) use, and its `message` is the whole issue list as
+* JSON — technically complete and unreadable in a dialog. Duck-typed on purpose, since
+* this package prescribes no schema library and takes no dependency on one; anything
+* else falls back to its own message.
+*/
+function describeRejection(e) {
+	const issues = e.issues;
+	if (!Array.isArray(issues) || issues.length === 0) return messageOf(e);
+	return issues.map((issue) => {
+		const { path, message } = issue;
+		const what = typeof message === "string" ? message : "is invalid";
+		const where = Array.isArray(path) ? formatPath(path) : "";
+		return where === "" ? what : `${where}: ${what}`;
+	}).join("; ");
+}
+/** `["numbers", 0]` → `numbers[0]` — how the params are written, not how they parse. */
+function formatPath(path) {
+	return path.reduce((acc, segment) => {
+		if (typeof segment === "number") return `${acc}[${segment}]`;
+		return acc === "" ? String(segment) : `${acc}.${String(segment)}`;
+	}, "");
+}
+/**
+* Check params that crossed into the model VM as text.
+*
+* The pre-flight entry point: a caller asks this before creating anything, once per
+* template entry, so params a kind rejects are reported while there is still no
+* project to half-build.
+*
+* The readable reference spelling is expanded here too, so what the kind checks is the shape it
+* declared. The ids it sees are the file's own — no block exists yet — which is why a kind must
+* not read meaning into a specific id.
+*
+* @param paramsJson The entry's params as JSON string
+* @param parseInitializationParams The kind's parser
+*/
+function validateTemplateParamsJson(paramsJson, parseInitializationParams) {
+	let params;
+	try {
+		params = JSON.parse(paramsJson);
+	} catch (e) {
+		return { error: `params are not valid JSON: ${messageOf(e)}` };
+	}
+	const result = validateTemplateParams(expandTemplateRefs(params), parseInitializationParams);
+	if (result.error !== void 0) return { error: result.error };
+	return {};
+}
+function messageOf(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+/**
+* Creates complete initial storage for a block being created from template params.
+*
+* The inverse of {@link deriveTemplateParamsFromStorage}: that projects storage
+* into params, this builds storage from them. The params are handed to the block's
+* init factory, whose output is versioned and wrapped exactly as
+* {@link createInitialStorage} wraps the defaults — so a block created from a
+* template is indistinguishable from one created in the UI and then edited.
+*
+* **This is where a template's references become the block's own**, and it is the only place in
+* a template's life where a reference is recognized at all. Params travel from the file
+* untouched — the engine carrying them neither marks a reference nor reads one, because
+* recognizing one means knowing the reference system, and that knowledge is here.
+*
+* Two things happen, in this order. The readable spelling a person may have written
+* (`{ block, name }`) is expanded into the `PlRef` it stands for. Then every reference naming
+* an entry that has a block is repointed at it: `blockIds` maps each template-local entry id to
+* the block id it was given, and an id it does not name is left alone, which is how a reference
+* to an entry created later ends up naming nothing rather than naming the wrong block.
+*
+* Relocation happens before the kind's parser and before the factory, so both see the ids the
+* block will actually hold. It is one step of this function rather than a callback of its own
+* precisely because nothing else wants its result: every VM call re-instantiates the runtime
+* and re-evaluates the whole model bundle, so a separate call would parse the block twice per
+* entry to produce a value only the next line reads.
+*
+* Params arrive as JSON text because this runs across the model-VM boundary, where
+* only strings pass. Anything the factory rejects is returned as an error rather
+* than thrown: applying a hand-written template is expected to surface bad params,
+* and the applier reports every entry's problem in one pass.
+*
+* @param paramsJson - The entry's params as JSON string, exactly as the file held them
+* @param blockIdsJson - template-local entry id → assigned block id, as a JSON object
+* @param hooks - The block's init factory plus plugin creation
+* @returns The storage to write, or why the params could not produce any
+*/
+function createInitialStorageFromParams(paramsJson, blockIdsJson, hooks) {
+	let params;
+	try {
+		params = JSON.parse(paramsJson);
+	} catch (e) {
+		return { error: `params are not valid JSON: ${messageOf(e)}` };
+	}
+	let blockIds;
+	try {
+		blockIds = new Map(Object.entries(JSON.parse(blockIdsJson)));
+	} catch (e) {
+		return { error: `this block was not told which blocks the template's references should point at (${messageOf(e)}). The application applying the template is older than the block; rebuild or update it.` };
+	}
+	try {
+		params = relocateBlockIds(expandTemplateRefs(params), blockIds);
+	} catch (e) {
+		return { error: `this entry's references could not be relocated: ${messageOf(e)}` };
+	}
+	const checked = validateTemplateParams(params, hooks.parseInitializationParams);
+	if (checked.error !== void 0) return { error: checked.error };
+	try {
+		return { storageJson: assembleStorage(hooks.getBlockDataFromParams(checked.value), hooks) };
+	} catch (e) {
+		return { error: `init() threw on the given params: ${messageOf(e)}` };
+	}
+}
+/**
 * Derives args from storage using the provided args function.
 * This extracts data from storage and passes it to the block's args() function.
 *
 * @param storageJson - Storage as JSON string
-* @param argsFunction - The block's args derivation function
+* @param deriveArgs - The block's args derivation function
 * @returns ArgsDeriveResult with derived args or error
 */
-function deriveArgsFromStorage(storageJson, argsFunction) {
+function deriveArgsFromStorage(storageJson, deriveArgs) {
 	const { data } = normalizeStorage(storageJson);
 	try {
-		return { value: argsFunction(data) };
+		return { value: deriveArgs(data) };
 	} catch (e) {
 		return { error: `args() threw: ${e instanceof Error ? e.message : String(e)}` };
 	}
 }
 /**
 * Derives prerunArgs from storage.
-* Uses prerunArgsFunction if provided, otherwise falls back to argsFunction.
+* Uses derivePrerunArgs if provided, otherwise falls back to deriveArgs.
 *
 * @param storageJson - Storage as JSON string
-* @param argsFunction - The block's args derivation function (fallback)
-* @param prerunArgsFunction - Optional prerun args derivation function
+* @param deriveArgs - The block's args derivation function (fallback)
+* @param derivePrerunArgs - Optional prerun args derivation function
 * @returns ArgsDeriveResult with derived prerunArgs or error
 */
-function derivePrerunArgsFromStorage(storageJson, argsFunction, prerunArgsFunction) {
+function derivePrerunArgsFromStorage(storageJson, deriveArgs, derivePrerunArgs) {
 	const { data } = normalizeStorage(storageJson);
-	if (prerunArgsFunction) try {
-		return { value: prerunArgsFunction(data) };
+	if (derivePrerunArgs) try {
+		return { value: derivePrerunArgs(data) };
 	} catch (e) {
 		return { error: `prerunArgs() threw: ${e instanceof Error ? e.message : String(e)}` };
 	}
 	try {
-		return { value: argsFunction(data) };
+		return { value: deriveArgs(data) };
 	} catch (e) {
 		return { error: `args() threw (fallback): ${e instanceof Error ? e.message : String(e)}` };
 	}
 }
+/**
+* Derives this block's template-entry params from storage.
+*
+* The inverse of the data model's `init`: `init` turns `params` into data, this
+* turns data back into the params that would recreate it.
+*
+* The lambda returns ordinary live params — references as `PlRef`s, column identifiers as they
+* are stored — and that is exactly what gets written. Nothing is marked, normalized or
+* rewritten on the way out: a template holds what the block holds. Repointing those references
+* at another project is the business of {@link createInitialStorageFromParams}, on the way back
+* in, where the ids to point at are known.
+*
+* Every block declares the lambda, so every export produces params; a block with
+* nothing worth restoring returns `{}` rather than declining.
+*
+* @param storageJson - Storage as JSON string
+* @param deriveTemplateParams - The block's templateParams lambda
+* @returns ArgsDeriveResult holding the params exactly as the block projected them
+*/
+function deriveTemplateParamsFromStorage(storageJson, deriveTemplateParams) {
+	const { data } = normalizeStorage(storageJson);
+	try {
+		return { value: deriveTemplateParams(data) };
+	} catch (e) {
+		return { error: `templateParams() threw: ${e instanceof Error ? e.message : String(e)}` };
+	}
+}
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/block_model.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/block_model.js
 /**
 * Merges two feature flag objects with type-aware logic:
 * - `supports*` (boolean): OR — `true` if either side is `true`
@@ -8917,24 +9443,33 @@ var BlockModelV3 = class BlockModelV3 {
 	/** @deprecated Use FEATURE_FLAGS */
 	static INITIAL_BLOCK_FEATURE_FLAGS = BlockModelV3.FEATURE_FLAGS;
 	/**
-	* Creates a new BlockModelV3 builder with the specified data model.
+	* Creates a new BlockModelV3 builder bound to a data model and a block kind.
+	*
+	* The `kind` argument is cross-checked against the kind handed to the
+	* builder: its `Params` type must match at compile time (via
+	* `BlockKind<Params>`), and its reference value must match at runtime. The
+	* reference is baked into the config so the published manifest can advertise
+	* which kind the block implements.
 	*
 	* @example
-	* const dataModel = new DataModelBuilder()
+	* const dataModel = new DataModelBuilder({ kind })
 	*   .from<BlockData>("v1")
-	*   .init(() => ({ numbers: [], labels: [] }));
+	*   .init(({ params }) => params ?? { numbers: [], labels: [] });
 	*
-	* BlockModelV3.create(dataModel)
+	* BlockModelV3.create({ dataModel, kind })
 	*   .args((data) => ({ numbers: data.numbers }))
 	*   .sections(() => [{ type: 'link', href: '/', label: 'Main' }])
 	*   .done();
-	*
-	* @param dataModel The data model that defines initial data and migrations
 	*/
-	static create(dataModel) {
+	static create(args) {
+		const { dataModel, kind } = args;
+		const kindRef = formatKindRef(kind);
+		if (dataModel.kindRef && dataModel.kindRef !== kindRef) throw new Error(`Block kind mismatch: data model built for '${dataModel.kindRef}' but create() got '${kindRef}'`);
 		return new BlockModelV3({
 			renderingMode: "Heavy",
 			dataModel,
+			kind: kindRef,
+			parseInitializationParams: kind.parseInitializationParams,
 			outputs: {},
 			sections: createAndRegisterRenderLambda({
 				handle: "sections",
@@ -8945,8 +9480,9 @@ var BlockModelV3 = class BlockModelV3 {
 			tags: void 0,
 			enrichmentTargets: void 0,
 			featureFlags: { ...BlockModelV3.FEATURE_FLAGS },
-			argsFunction: void 0,
-			prerunArgsFunction: void 0,
+			deriveArgs: void 0,
+			derivePrerunArgs: void 0,
+			deriveTemplateParams: void 0,
 			plugins: {}
 		});
 	}
@@ -8987,7 +9523,7 @@ var BlockModelV3 = class BlockModelV3 {
 	args(lambda) {
 		return new BlockModelV3({
 			...this.config,
-			argsFunction: lambda
+			deriveArgs: lambda
 		});
 	}
 	/**
@@ -9013,7 +9549,41 @@ var BlockModelV3 = class BlockModelV3 {
 	prerunArgs(fn) {
 		return new BlockModelV3({
 			...this.config,
-			prerunArgsFunction: fn
+			derivePrerunArgs: fn
+		});
+	}
+	/**
+	* Sets the function that projects block data back to this kind's params, for
+	* exporting the project as a template.
+	*
+	* The inverse of the data model's `init`: `init` builds data from `params`, this
+	* recovers the `params` that would rebuild the current data. Return only params
+	* — runtime and derived state is dropped, and the exporter supplies the rest of
+	* the entry (`id`, `kind`), which this lambda cannot set.
+	*
+	* References are returned as ordinary `PlRef`s; the SDK rewrites them into
+	* template-local form on the way out, so a block never deals with the file
+	* representation.
+	*
+	* Required: `done()` throws without it. A block whose state cannot be reduced to
+	* params returns `{}` and says so explicitly, rather than exporting an entry with
+	* no params that silently applies as a default-initialized block.
+	*
+	* The return type is the kind's `Params`, so a block whose projection drifts
+	* from its own init contract fails to compile. Available only on a
+	* kind-carrying model — `create(dataModel)` without a kind leaves `Params` as
+	* `unknown` and this method cannot be type-checked against anything.
+	*
+	* @example
+	* BlockModelV3.create({ dataModel, kind })
+	*   .args((data) => ({ numbers: data.numbers }))
+	*   .templateParams((data) => ({ sources: data.sources }))
+	*   .done();
+	*/
+	templateParams(fn) {
+		return new BlockModelV3({
+			...this.config,
+			deriveTemplateParams: fn
 		});
 	}
 	/** Sets the lambda to generate list of sections in the left block overviews panel. */
@@ -9105,13 +9675,14 @@ var BlockModelV3 = class BlockModelV3 {
 	* before calling `.done()`.
 	*/
 	done(..._) {
-		if (this.config.argsFunction === void 0) throw new Error("Args rendering function not set.");
+		if (this.config.deriveArgs === void 0) throw new Error("Args rendering function not set.");
+		if (this.config.deriveTemplateParams === void 0) throw new Error("templateParams() not set. Every block must project its state back to its kind's params, so a project can be exported as a template and re-applied; a block whose state carries nothing worth restoring returns {}.");
 		const apiVersion = 3;
 		const { plugins } = this.config;
 		const pluginRegistry = {};
 		const pluginHandles = Object.keys(plugins);
 		for (const handle of pluginHandles) pluginRegistry[handle] = plugins[handle].model.name;
-		const { dataModel, argsFunction, prerunArgsFunction } = this.config;
+		const { dataModel, deriveArgs, derivePrerunArgs, deriveTemplateParams, parseInitializationParams } = this.config;
 		function getPlugin(handle) {
 			const plugin = plugins[handle];
 			if (!plugin) throw new Error(`Plugin model not found for '${handle}'`);
@@ -9134,8 +9705,16 @@ var BlockModelV3 = class BlockModelV3 {
 				getPluginRegistry: () => pluginRegistry,
 				createPluginData: (handle) => getPlugin(handle).model.getDefaultData()
 			}),
-			[BlockStorageFacadeCallbacks.ArgsDerive]: (storageJson) => deriveArgsFromStorage(storageJson, argsFunction),
-			[BlockStorageFacadeCallbacks.PrerunArgsDerive]: (storageJson) => derivePrerunArgsFromStorage(storageJson, argsFunction, prerunArgsFunction)
+			[BlockStorageFacadeCallbacks.ArgsDerive]: (storageJson) => deriveArgsFromStorage(storageJson, deriveArgs),
+			[BlockStorageFacadeCallbacks.PrerunArgsDerive]: (storageJson) => derivePrerunArgsFromStorage(storageJson, deriveArgs, derivePrerunArgs),
+			[BlockStorageFacadeCallbacks.InitializationParamsDerive]: (storageJson) => deriveTemplateParamsFromStorage(storageJson, deriveTemplateParams),
+			[BlockStorageFacadeCallbacks.StorageInitialFromParams]: (paramsJson, blockIdsJson) => createInitialStorageFromParams(paramsJson, blockIdsJson, {
+				getBlockDataFromParams: (params) => dataModel.getDataFromParams(params),
+				getPluginRegistry: () => pluginRegistry,
+				createPluginData: (handle) => getPlugin(handle).model.getDefaultData(),
+				parseInitializationParams
+			}),
+			[BlockStorageFacadeCallbacks.InitializationParamsValidate]: (paramsJson) => validateTemplateParamsJson(paramsJson, parseInitializationParams)
 		});
 		const pluginOutputs = {};
 		for (const handle of pluginHandles) {
@@ -9172,6 +9751,7 @@ var BlockModelV3 = class BlockModelV3 {
 				featureFlags: this.config.featureFlags,
 				blockLifecycleCallbacks: { ...BlockStorageFacadeHandles }
 			},
+			kind: this.config.kind,
 			sdkVersion: PlatformaSDKVersion,
 			renderingMode: this.config.renderingMode,
 			sections: this.config.sections,
@@ -9192,7 +9772,7 @@ var BlockModelV3 = class BlockModelV3 {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/pframe_utils/axes.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/pframe_utils/axes.js
 /** Create id for column copy with added keys in axes domains */
 const colId = (id, domains, contextDomains) => {
 	let wid = id.toString();
@@ -9298,7 +9878,7 @@ function getAdditionalColumnsForColumn(blockAxes, column) {
 	})];
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/leaf_rebrand.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/leaf_rebrand.js
 /**
 * Replace every column leaf whose id equals `fromId` with `toId`, leaving
 * other column refs (linkers, sub-anchors) intact. Wrapper recipes
@@ -9966,7 +10546,7 @@ var U = class d {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/column_providers/providers.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/column_providers/providers.js
 /**
 * Unified memoised factory dispatching to the right provider flavour by the
 * source shape:
@@ -10055,7 +10635,7 @@ function hashRawPool(rawPool) {
 	return rawPool.map((b) => `${b.blockId}\x1f${b.prodCtx ?? ""}\x1f${b.stagingCtx ?? ""}\x1f${b.prodIncomplete ? 1 : 0}\x1f${b.stagingIncomplete ? 1 : 0}`).join("");
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/column_providers/index.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/column_providers/index.js
 /**
 * Build the default set of ColumnsProviders for the ambient render ctx:
 *  - `AccessorColumnsProvider` over `outputs` (if present)
@@ -10090,7 +10670,7 @@ function isColumnProvider(source) {
 	return typeof p.getColumns === "function" && typeof p.isFinal === "function";
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/data_column.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/data_column.js
 /**
 * Thrown by leaf-recipe factories when the requested column is provably
 * absent in the active render ctx — i.e. every relevant accessor reports
@@ -10330,7 +10910,7 @@ function memoizeByEntry(fn) {
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_overrided_recipe.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_overrided_recipe.js
 /**
 * Recipe wrapper that overlays {@link SpecOverrides} on top of any other
 * recipe. The id is `ColumnOverriddenKey { source: inner.id, specOverrides }`.
@@ -10468,7 +11048,7 @@ var DataColumnOverriddenRecipe = class extends ColumnOverriddenRecipe {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_filtered_recipe.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_filtered_recipe.js
 /**
 * Recipe wrapper that fixes the values of selected axes of an inner recipe
 * (axis slicing). The id is `FilteredPColumnId { source: inner.id,
@@ -10594,7 +11174,7 @@ function toAxisSelector(axis) {
 	return selector;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/index.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/index.js
 /**
 * Build a `ColumnRecipe` from a stringified id. Dispatches to the matching
 * concrete recipe variant based on the id's encoding and recurses on
@@ -10645,7 +11225,7 @@ function ColumnRecipeGetStatus(id, opts = {}) {
 }
 const ColumnRecipe = Object.assign(ColumnRecipeBuild, { getStatus: ColumnRecipeGetStatus });
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_discovered_recipe.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_discovered_recipe.js
 /**
 * Recipe for columns identified by a {@link ColumnDiscoveredKey}: a base
 * column + a `path` of linkers + qualifications.
@@ -10816,7 +11396,7 @@ function referencedUniIdsOf(key) {
 	return /* @__PURE__ */ new Set([key.column, ...(key.path ?? []).map((item) => item.column)]);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/column.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/column.js
 /**
 * Unified entry point — routes between the two top-level dispatchers:
 *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}
@@ -10830,7 +11410,7 @@ function Column(source, opts) {
 	return DataColumn(source, opts);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/columns_collection.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/columns_collection.js
 /**
 * Build a {@link ColumnsCollection} from sandbox-side source descriptors.
 * Resolves the `columnsCollection` driver (either from `deps.driver` or via
@@ -10939,7 +11519,7 @@ function defaultCtxSources(ctx) {
 	return [...currentBlockSources(ctx), { kind: "result_pool" }];
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/columns/utils.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/columns/utils.js
 /**
 * PObjectIds of every non-hit column referenced by `recipe.getQuery()`,
 * deduped in traversal order. The hit column is
@@ -11070,7 +11650,7 @@ function hasSingleDataColumn(recipe) {
 	return recipe.getReferencedIds().length === 1;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/pframe_utils/columns.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/pframe_utils/columns.js
 function getAllRelatedColumns(ctx, predicate) {
 	const columns = new PColumnCollection();
 	columns.addColumnProvider(ctx.resultPool);
@@ -11146,7 +11726,7 @@ function discoverIntegrableColumnIds(ctx, rootColumns) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/components/PFrameForGraphs.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/components/PFrameForGraphs.js
 function isHiddenFromGraphColumn(column) {
 	return !!readAnnotationJson(column, Annotation.HideDataFromGraphs);
 }
@@ -11175,7 +11755,7 @@ function createPFrameForGraphs(ctx, blockColumns) {
 	}));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/filters/traverse.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/filters/traverse.js
 /**
 * Recursively traverses a FilterSpec tree bottom-up, applying visitor callbacks.
 *
@@ -11214,7 +11794,7 @@ function collectFilterSpecColumns(filter) {
 	});
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/filters/converters/filterToQuery.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/filters/converters/filterToQuery.js
 /** Converts a QueryColumnId object into a SpecQueryExpression reference. */
 function resolveColumnRef(col) {
 	return col.type === "axis" ? {
@@ -11601,7 +12181,7 @@ function isEmpty(value) {
 	return true;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/filters/distill.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/filters/distill.js
 /**
 * Strips non-FilterSpec metadata (whitelist approach) and removes
 * unfilled leaves (type is undefined or any required field is undefined).
@@ -11706,7 +12286,7 @@ const REQUIRED_KEYS_BY_TYPE = {
 	greaterThanColumnOrEqual: ["column", "rhs"]
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/state-migration.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/components/PlDataTable/state-migration.js
 /** Upgrade PlDataTableStateV2 to the latest version */
 function upgradePlDataTableStateV2(state) {
 	if (!state) return createPlDataTableStateV2();
@@ -12064,7 +12644,7 @@ function parseLegacyLeafColumn(s) {
 	return parsed;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/utils.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/utils.js
 /** Adapt a {@link ColumnRecipe} to the plain {@link RuleColumn} shape. */
 function toRuleColumn(col) {
 	return {
@@ -12162,7 +12742,7 @@ function deriveAllLabels(options) {
 	})), deriveLabelsOptions).reduce((acc, label, index) => (acc[columns[index].id] = label, acc), {});
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPTableDefV3.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPTableDefV3.js
 /**
 * Assemble a ptable def directly from recipes. Each secondary recipe is its own
 * outer-joined subtree: `getQuery()` encodes its linker chain, and its
@@ -12226,7 +12806,7 @@ function columnToJoinEntry(col, qualifications) {
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/columnResolver.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/components/PlDataTable/columnResolver.js
 function createColumnResolver(columns, deps) {
 	const axisIds = [];
 	for (const c of columns) for (const ax of c.getSpec().axesSpec) axisIds.push(getAxisId(ax));
@@ -12250,7 +12830,7 @@ function createColumnResolver(columns, deps) {
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/discoverColumns.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/discoverColumns.js
 /**
 * Discover columns from sources/anchors and split them into primary
 * (direct anchor hits — zero-hop, query is a bare column) and secondary
@@ -12296,7 +12876,7 @@ function discoverLabelColumns(ctx, primary) {
 	}).getColumns();
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.81.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPlDataTableV3.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.0/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPlDataTableV3.js
 function createPlDataTableV3(ctx, options) {
 	const state = upgradePlDataTableStateV2(options.tableState);
 	const primaryJoinType = options.primaryJoinType ?? "full";
@@ -12659,6 +13239,180 @@ const ErrorShape = objectType({
 	errors: lazyType(() => ErrorShape.array()).optional()
 });
 //#endregion
+//#region ../kind/dist/package.js
+var name = "@platforma-open/milaboratories.sort-seq-analysis.kind";
+var version = "1.0.1";
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+block-kind@1.1.0/node_modules/@platforma-sdk/block-kind/dist/params.js
+/**
+* Establish that a value is an object whose fields a kind can read — the half of a params
+* check every kind needs and no two kinds differ on.
+*
+* Params that arrived from a template file are `unknown`, and before a single field can be
+* read the value has to be an object. Worth a shared function because the check is easy to
+* get wrong by hand: `typeof null` is `"object"`, `Object.keys(5)` is `[]` and
+* `Object.keys(["a"])` is `["0"]`, so a naive test lets `null`, a number and an array through
+* as if they were empty params.
+*
+* What each field must *be* is the kind's own business and stays in the kind, as plain
+* TypeScript: this package deliberately carries no validation library, so a kind author owes
+* it no schema.
+*
+* A key the kind does not declare is NOT refused. A parser returns the params to use, so a
+* field it never read is dropped and never reaches the block — the only question was whether
+* to also complain, and complaining costs more than it catches. It would mean each kind
+* restating its own field list as strings, with nothing checking that the list stayed in step
+* with the type: a field added to the contract and read by the parser, but missed in the list,
+* would turn into a kind that refuses files that are correct. What an unexpected key can
+* actually mean is a params contract from a different version of the kind, and that is
+* guarded where it belongs — by the version in the entry's `{name}@{selector}` reference.
+*
+* An assertion rather than a parser that returns a copy, so a kind reads its fields off the
+* value it was handed:
+*
+* ```ts
+* function parseInitializationParams(value: unknown): BlockParams {
+*   assertParamsObject(value);
+*
+*   const { numbers } = value;
+*   if (numbers !== undefined && !isNumberArray(numbers)) {
+*     throw new Error("'numbers' must be an array of numbers.");
+*   }
+*   return { numbers };
+* }
+* ```
+*
+* Messages are finished sentences addressed to whoever wrote the file, because that is who
+* reads them: a kind's rejection is reported against the entry that carried the params.
+*
+* @param value The params as they arrived
+* @throws if `value` is not an object
+*/
+function assertParamsObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Params must be an object, not ${describe(value)}.`);
+}
+/** What a value is, for a message that has to say why it is not an object. */
+function describe(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "nothing";
+	if (Array.isArray(value)) return "an array";
+	return `a ${typeof value} (${JSON.stringify(value) ?? String(value)})`;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+block-kind@1.1.0/node_modules/@platforma-sdk/block-kind/dist/index.js
+/**
+* Define a block kind.
+*
+* `meta` is the kind's identity — its own `{ name, version }`. Source it from
+* the package's `package.json` rather than hand-typing literals, so the on-wire
+* `{name}@{version}` cannot drift from what npm publishes and what the S3
+* manifest records (all read the same `package.json`):
+*
+* ```ts
+* // a kind package's src/index.ts
+* import { name, version } from "../package.json" with { type: "json" };
+* export const kind = defineBlockKind<Params>({ name, version });
+* ```
+*
+* rolldown inlines the JSON import (tree-shaken to the two strings) into the
+* bundled `kind.js`, so no build-time injection is needed.
+*
+* A kind must also declare `parseInitializationParams` — the runtime check applied to params
+* that came from a template file rather than from typed code. See
+* {@link CompiledBlockKind} for what it must do.
+*
+* @typeParam BlockParams - shape of the params a block of this kind reads. Pinned both
+*   as a type and by `parseInitializationParams`, whose return type is checked against it.
+*/
+function defineBlockKind(meta) {
+	return Object.freeze({
+		kindSchema: "v1",
+		name: meta.name,
+		version: meta.version,
+		parseInitializationParams: meta.parseInitializationParams
+	});
+}
+//#endregion
+//#region ../kind/dist/index.js
+/**
+* The same contract at runtime, for params arriving from a template file rather than from typed
+* code — the only point that can catch a hand-written entry being wrong.
+*
+* Each field the contract names is read and checked; nothing else is. A key this function never
+* reads is dropped rather than refused, so a misspelled key in a template file is not caught
+* here — it surfaces later as a block that started on its defaults. That cost is accepted: a
+* key-set check would mean this file keeping its own field names as strings, and nothing holds
+* that list in step with the type above.
+*
+* The checks stop at the shape of a value. That `gateOrder` names only values `gateValues`
+* carries, that a gate column is not also the condition column — those are refused by
+* `settingsIssues` in the model, where the whole configuration is in view. A parser stricter
+* than the settings drawer would make this block export a template its own kind then refuses to
+* apply.
+*/
+function parseInitializationParams(value) {
+	assertParamsObject(value);
+	const { conditionColumnRef, gateColumnRef, sortFractionColumnRef, gateOrder, gateValues, gateColumnLabel, conditionValues } = value;
+	return {
+		conditionColumnRef: optionalColumnRef(conditionColumnRef, "conditionColumnRef"),
+		gateColumnRef: optionalColumnRef(gateColumnRef, "gateColumnRef"),
+		sortFractionColumnRef: optionalColumnRef(sortFractionColumnRef, "sortFractionColumnRef"),
+		gateOrder: optionalStringList(gateOrder, "gateOrder"),
+		gateValues: optionalStringList(gateValues, "gateValues"),
+		gateColumnLabel: optionalString(gateColumnLabel, "gateColumnLabel"),
+		conditionValues: optionalStringList(conditionValues, "conditionValues")
+	};
+}
+/**
+* A column ref is a canonically serialized id, not a free string, so this checks the string
+* parses and that what comes out is a shape the SDK recognizes as a column id.
+*
+* **Not `isColumnUniversalId`, which is the obvious choice and the wrong one.** The block stores
+* what `AnchoredIdDeriver.deriveS` returns — an *anchored* id, `{name, type, domain, axes}` with
+* `{anchor, idx}` refs in the axes. `ColumnUniversalId` is a union of the PObject / filtered /
+* discovered / overridden key forms and does not include the anchored one, so
+* `isColumnUniversalId` returns `false` for every id this block actually holds. (The
+* `SUniversalPColumnId` name is a deprecated alias of `ColumnUniversalId`, which is what makes
+* the mistake look correct.) Verified against pl-model-common 1.48.0: an anchored id fails
+* `isColumnUniversalId` and passes `isAnchoredPColumnId`.
+*
+* `isColumnUniversalKey` is kept alongside so a ref that arrives in one of the other forms is
+* not refused for a reason that has nothing to do with the template being wrong.
+*
+* The cast is over a real check: both guards narrow the *parsed* value, and nothing in the SDK
+* narrows the string that carried it.
+*/
+function optionalColumnRef(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new Error(`'${field}' must be a column id.`);
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		throw new Error(`'${field}' must be a column id.`);
+	}
+	if (!isAnchoredPColumnId(parsed) && !isColumnUniversalKey(parsed)) throw new Error(`'${field}' must be a column id.`);
+	return value;
+}
+function optionalString(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new Error(`'${field}' must be a string.`);
+	return value;
+}
+function optionalStringList(value, field) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw new Error(`'${field}' must be a list.`);
+	return value.map((entry, index) => {
+		if (typeof entry !== "string") throw new Error(`'${field}[${index}]' must be a string.`);
+		return entry;
+	});
+}
+const kind = defineBlockKind({
+	name,
+	version,
+	parseInitializationParams
+});
+//#endregion
 //#region ../model/dist/dataModel.js
 /**
 * `readFloor` is deliberately absent rather than 0: those are different runs. Absent applies no
@@ -12666,12 +13420,16 @@ const ErrorShape = objectType({
 *
 * Later shape changes add `.migrate<Next>("Ver_…", prev => …)` links rather than editing this.
 */
-const blockDataModel = new DataModelBuilder().from("Ver_2026_08_07").init(() => ({
-	gateOrder: [],
+const blockDataModel = new DataModelBuilder({ kind }).from("Ver_2026_08_07").init(({ params }) => ({
+	conditionColumnRef: params?.conditionColumnRef,
+	gateColumnRef: params?.gateColumnRef,
+	sortFractionColumnRef: params?.sortFractionColumnRef,
+	gateOrder: params?.gateOrder ?? [],
+	gateValues: params?.gateValues ?? [],
+	gateColumnLabel: params?.gateColumnLabel,
+	conditionValues: params?.conditionValues ?? [],
 	excludedConditions: [],
-	gateValues: [],
 	customBlockLabel: "",
-	conditionValues: [],
 	resultsTableState: createPlDataTableStateV2(),
 	distributionGraphStates: {}
 }));
@@ -12681,10 +13439,9 @@ const blockDataModel = new DataModelBuilder().from("Ver_2026_08_07").init(() =>
 * Every configuration rule, checked here and **nowhere else**. These six are decidable from the
 * arguments and snapshotted column values alone, so they are refused before the run starts.
 *
-* The two data-value rules — sort fractions, one sample per condition-and-gate group — belong
-* to the computation and are deliberately not approximated here: a duplicated rule is one that
-* will disagree, and it fails by drifting looser, so the settings pass and the run fails anyway
-* with a different message.
+* The one data-value rule — sort fractions — belongs to the computation and is deliberately not
+* approximated here: a duplicated rule is one that will disagree, and it fails by drifting
+* looser, so the settings pass and the run fails anyway with a different message.
 */
 function settingsIssues(data) {
 	const issues = [];
@@ -12742,7 +13499,10 @@ function distributionConditionsOf(columns) {
 function distributionPlotTitle(condition, entry) {
 	return entry !== void 0 && entry.variantsPlotted < entry.variantsScored ? `Variant Frequency Top ${entry.variantsPlotted} — ${condition}` : `Variant Frequency — ${condition}`;
 }
-const platforma$1 = BlockModelV3.create(blockDataModel).args((data) => {
+const platforma$1 = BlockModelV3.create({
+	dataModel: blockDataModel,
+	kind
+}).args((data) => {
 	const issues = settingsIssues(data);
 	if (issues.length > 0) throw new Error(issues.join("; "));
 	return {
@@ -12772,16 +13532,35 @@ const platforma$1 = BlockModelV3.create(blockDataModel).args((data) => {
 	const columns = ctx.resultPool.getAnchoredPColumns({ main: anchor }, [metadataSelector]);
 	if (!columns || columns.length === 0) return void 0;
 	return ctx.createPFrame(columns);
+}).output("sampleLabelPframe", (ctx) => {
+	const anchor = ctx.data.abundanceRef;
+	if (!anchor) return void 0;
+	const columns = ctx.resultPool.getAnchoredPColumns({ main: anchor }, [sampleLabelSelector]);
+	if (!columns || columns.length === 0) return void 0;
+	return ctx.createPFrame(columns);
+}).output("sampleLabelColumnId", (ctx) => {
+	const anchor = ctx.data.abundanceRef;
+	if (!anchor) return void 0;
+	return ctx.resultPool.getAnchoredPColumns({ main: anchor }, [sampleLabelSelector])?.[0]?.id;
 }).outputWithStatus("resultsTable", (ctx) => {
-	const columns = ctx.outputs?.resolve("scoresPf")?.getPColumns();
-	if (!columns) return void 0;
-	const anchor = columns.filter((column) => column.spec.name === FacsBin.GateRankMean).sort((a, b) => (a.spec.domain?.[FacsBin.ConditionDomain] ?? "").localeCompare(b.spec.domain?.[FacsBin.ConditionDomain] ?? ""))[0];
+	const own = ctx.outputs?.resolve("scoresPf")?.getPColumns();
+	if (!own) return void 0;
+	const anchor = own.filter((column) => column.spec.name === FacsBin.GateRankMean).sort((a, b) => (a.spec.domain?.[FacsBin.ConditionDomain] ?? "").localeCompare(b.spec.domain?.[FacsBin.ConditionDomain] ?? ""))[0];
 	if (!anchor) return void 0;
+	const primaryColumns = own.map((column) => DataColumn.fromColumn(column));
+	const { primary, secondary } = discoverTableColumns(ctx, {
+		anchors: { main: anchor.spec },
+		selector: {
+			mode: "exact",
+			exclude: [{ name: [{
+				type: "regex",
+				value: "^pl7\\.app/facsBin/.*$"
+			}] }]
+		}
+	});
 	return createPlDataTableV3(ctx, {
-		columns: {
-			anchors: { main: anchor.spec },
-			selector: { mode: "exact" }
-		},
+		primaryColumns,
+		columns: [...primary, ...secondary],
 		tableState: ctx.data.resultsTableState,
 		displayOptions: { 
 		/**
@@ -12792,6 +13571,9 @@ const platforma$1 = BlockModelV3.create(blockDataModel).args((data) => {
 		* `optional` rather than `hidden` for the remainder: they stay one click away in the
 		* column picker. Hiding a column a user wants, with no way to bring it back, is the
 		* worse failure.
+		*
+		* The two score rules are the block's own columns, which are primary and therefore
+		* always on screen; the rules state their visibility for the column picker's sake.
 		*/
 visibility: [
 			{
@@ -12831,7 +13613,15 @@ visibility: [
 		id: column.id,
 		spec: column.spec
 	}));
-}).output("manifest", (ctx) => ctx.outputs?.resolve("manifest")?.getDataAsJsonOrUndefined()).output("logHandle", (ctx) => ctx.outputs?.resolve("logHandle")?.getLogHandle()).output("isRunning", (ctx) => ctx.outputs?.getIsReadyOrError() === false).output("settingsIssues", (ctx) => settingsIssues(ctx.data)).output("defaultBlockLabel", (ctx) => deriveBlockLabel(ctx.data)).title(() => "Sort-Seq Analysis").subtitle((ctx) => ctx.data.customBlockLabel || deriveBlockLabel(ctx.data)).sections((ctx) => {
+}).output("manifest", (ctx) => ctx.outputs?.resolve("manifest")?.getDataAsJsonOrUndefined()).output("logHandle", (ctx) => ctx.outputs?.resolve("logHandle")?.getLogHandle()).output("isRunning", (ctx) => ctx.outputs?.getIsReadyOrError() === false).output("settingsIssues", (ctx) => settingsIssues(ctx.data)).output("defaultBlockLabel", (ctx) => deriveBlockLabel(ctx.data)).templateParams((data) => ({
+	conditionColumnRef: data.conditionColumnRef,
+	gateColumnRef: data.gateColumnRef,
+	sortFractionColumnRef: data.sortFractionColumnRef,
+	gateOrder: data.gateOrder,
+	gateValues: data.gateValues,
+	gateColumnLabel: data.gateColumnLabel,
+	conditionValues: data.conditionValues
+})).title(() => "Sort-Seq Analysis").subtitle((ctx) => ctx.data.customBlockLabel || deriveBlockLabel(ctx.data)).sections((ctx) => {
 	const columns = ctx.outputs?.resolve("distributionPf")?.getPColumns();
 	return [{
 		type: "link",