@platforma-open/milaboratories.sequence-embeddings 1.2.0 → 1.3.0

package/dist/index.js

@@ -27,10 +27,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 * prep). Wired so far: ESM-2, CurrAb, VHHBERT, H3BERTa and TCR-BERT (all HF
 * checkpoints via the shared `AutoModel` loader), PeptideCLM-2 (HF custom model via
 * trust_remote_code) and AbLang2 (the `ablang2` pip model with asset-shipped
-* weights). Input prep per model: AA as-is (ESM-2/CurrAb/VHHBERT/AbLang2), CDR3
-* flank-trim (H3BERTa, `aa-cdr3-trimmed`), space-separated residues (TCR-BERT,
-* `aa-spaced`), or AA→SMILES (PeptideCLM-2, `smiles`) — all applied in the Python
-* step. Only SCEPTR (pass 2) remains: it needs paired V-gene + CDR assembly the
+* weights). Input prep per model: AA as-is (ESM-2/CurrAb/AbLang2), CDR3
+* flank-trim (H3BERTa, `aa-cdr3-trimmed`), space-separated residues (TCR-BERT and
+* VHHBERT, `aa-spaced` — their tokenizers need one token per residue), or AA→SMILES
+* (PeptideCLM-2, `smiles`) — all applied in the Python step. Only SCEPTR (pass 2) remains: it needs paired V-gene + CDR assembly the
 * block does not yet gather. Add a model's id here as its asset/runenv/routing
 * lands — the UI and matrix pick it up automatically.
 */
@@ -47,7 +47,6 @@ const EMBEDDING_MODELS = {
 	esm2: {
 		id: "esm2",
 		label: "ESM-2 (universal)",
-		inputKind: "aa",
 		receptors: [
 			"IG",
 			"TCRAB",
@@ -60,92 +59,61 @@ const EMBEDDING_MODELS = {
 			"Fv",
 			"scFv"
 		],
-		dim: "varies",
-		asset: true,
-		pass: 1,
 		priority: 0
 	},
 	currab: {
 		id: "currab",
 		label: "CurrAb (antibody)",
-		inputKind: "aa",
 		receptors: ["IG"],
 		features: ["VDJRegion", "Fv"],
-		dim: 1280,
-		asset: true,
-		pass: 1,
 		priority: 50
 	},
 	ablang2: {
 		id: "ablang2",
 		label: "AbLang2 (antibody)",
-		inputKind: "aa",
 		receptors: ["IG"],
 		features: ["VDJRegion", "Fv"],
-		dim: 480,
-		asset: false,
-		pass: 1,
 		priority: 40
 	},
 	vhhbert: {
 		id: "vhhbert",
 		label: "VHHBERT (nanobody)",
-		inputKind: "aa",
 		receptors: ["IG"],
 		features: ["VDJRegion"],
 		heavyOnly: true,
-		dim: 768,
-		asset: true,
-		pass: 1,
 		priority: 45
 	},
 	h3berta: {
 		id: "h3berta",
 		label: "H3BERTa (CDR-H3)",
-		inputKind: "aa-cdr3-trimmed",
 		receptors: ["IG"],
 		features: ["CDR3"],
 		heavyOnly: true,
-		dim: 768,
-		asset: true,
-		pass: 1,
 		priority: 50
 	},
 	"tcr-bert": {
 		id: "tcr-bert",
 		label: "TCR-BERT (CDR3)",
-		inputKind: "aa-spaced",
 		receptors: ["TCRAB"],
 		features: ["CDR3"],
-		dim: 768,
-		asset: true,
-		pass: 1,
 		priority: 50
 	},
 	peptideclm2: {
 		id: "peptideclm2",
 		label: "PeptideCLM-2 (peptide)",
-		inputKind: "smiles",
 		receptors: [
 			"IG",
 			"TCRAB",
 			"TCRGD"
 		],
 		features: ["peptide"],
-		dim: 1024,
-		asset: true,
-		pass: 1,
 		priority: 50
 	},
 	sceptr: {
 		id: "sceptr",
 		label: "SCEPTR (paired αβ)",
-		inputKind: "paired-structured",
 		receptors: ["TCRAB"],
 		features: ["VDJRegion", "Fv"],
-		dim: 64,
-		asset: false,
-		pass: 2,
 		priority: 60
 	}
 };
@@ -162,14 +130,14 @@ function isCompatible(feature, isHeavy, receptor, model) {
 	return modelSupports(EMBEDDING_MODELS[model], feature, isHeavy, receptor);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/plugin_handle.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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.79.24/node_modules/@platforma-sdk/model/dist/block_storage.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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.
@@ -411,7 +379,7 @@ function getPluginData(rawStorage, handle) {
 	return pluginEntry.__data;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/block_migrations.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_migrations.js
 /** Create a DataVersioned wrapper with correct shape */
 function makeVersionedData(version, data) {
 	return {
@@ -906,7 +874,7 @@ var DataModel = class DataModel {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/internal.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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";
@@ -976,7 +944,7 @@ function registerFutureAwait(handle, onResolve) {
 	futureResolves.get(handle).push(onResolve);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/block_storage_facade.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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.
@@ -1011,7 +979,7 @@ function registerFacadeCallbacks(callbacks) {
 	for (const key of Object.values(BlockStorageFacadeCallbacks)) tryRegisterCallback(key, callbacks[key]);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/render/future.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/render/future.js
 var FutureRef = class FutureRef {
 	handle;
 	postProcess;
@@ -4592,12 +4560,12 @@ objectType({
 	to: numberType().min(1)
 });
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/util.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/util.js
 function assertNever(x) {
 	throw new Error("Unexpected object: " + x);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/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.
 *
@@ -4788,7 +4756,7 @@ function entriesToDataInfo(dataInfoEntries) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/errors.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/errors.js
 var ServiceError = class extends Error {
 	name = "ServiceError";
 };
@@ -4812,7 +4780,7 @@ function ensureError(value) {
 	return new Error(stringifyValue(value));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/json.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/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");
@@ -4837,8 +4805,15 @@ function canonicalizeJson(value) {
 function parseJson(value) {
 	return JSON.parse(value);
 }
+function parseJsonSafely(value, fallback) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return fallback;
+	}
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.js
 function readMetadata(metadata, key) {
 	return metadata?.[key];
 }
@@ -5127,7 +5102,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.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/utils.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/utils.js
 /**
 * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.
 *
@@ -5177,20 +5152,23 @@ function traverseQuerySpec(query, visitor) {
 				secondary: query.secondary.map(traverseEntry)
 			};
 			break;
-		case "linkerJoin":
+		case "linkerJoin": {
+			const linker = "type" in query.linker ? query.linker : {
+				type: "column",
+				column: query.linker.column
+			};
 			result = {
 				...query,
-				linker: {
-					...query.linker,
-					column: visitor.column(query.linker.column)
-				},
+				linker: traverseQuerySpec(linker, visitor),
 				secondary: query.secondary.map(traverseEntry)
 			};
 			break;
+		}
 		case "filter":
 		case "sort":
 		case "sliceAxes":
 		case "transformColumns":
+		case "specOverride":
 			result = {
 				...query,
 				input: traverseQuerySpec(query.input, visitor)
@@ -5201,19 +5179,19 @@ function traverseQuerySpec(query, visitor) {
 	return visitor.node ? visitor.node(result) : result;
 }
 /** Recursively maps all column references in a SpecQuery tree. */
-function mapSpecQueryColumns(query, cb) {
-	return traverseQuerySpec(query, { column: cb });
+function mapSpecQueryColumns(query, visitor) {
+	return traverseQuerySpec(query, visitor);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.js
 function mapPTableDef(def, cb) {
 	return {
 		...def,
 		src: mapJoinEntry(def.src, cb)
 	};
 }
-function mapPTableDefV2(def, cb) {
-	return { query: mapSpecQueryColumns(def.query, cb) };
+function mapPTableDefV2(def, visitor) {
+	return { query: mapSpecQueryColumns(def.query, visitor) };
 }
 function mapJoinEntry(entry, cb) {
 	switch (entry.type) {
@@ -5248,17 +5226,367 @@ function mapJoinEntry(entry, cb) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/filtered_column.js
+function stringifyColumnFilteredId(key) {
+	return canonicalizeJson(createColumnFilteredKey(key));
+}
+function isColumnFilteredKey(obj) {
+	return typeof obj === "object" && obj !== null && "__isFiltered" in obj;
+}
+function createColumnFilteredKey(props) {
+	const axisFilters = props.axisFilters.toSorted((a, b) => a[0] - b[0]);
+	return {
+		__isFiltered: true,
+		source: props.source,
+		axisFilters
+	};
+}
+/**
+* Drop the axes pinned by `axisFilters` from a {@link PColumnSpec}'s
+* `axesSpec`. Indices are positional against `spec.axesSpec`. Returns `spec`
+* unchanged when there are no filters.
+*
+* Single source of the Filtered-layer spec math — shared by
+* `reconstructSpecFromId` (host, id-walking) and `ColumnFilteredRecipe.getSpec`
+* (sandbox, recipe-graph walking).
+*/
+function applyAxisFilters(spec, axisFilters) {
+	if (axisFilters.length === 0) return spec;
+	const fixed = new Set(axisFilters.map(([i]) => i));
+	return {
+		...spec,
+		axesSpec: spec.axesSpec.filter((_, i) => !fixed.has(i))
+	};
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/pool/spec.js
+function isPObjectId(value) {
+	if (typeof value !== "string") return false;
+	return isPObjectKey(parseJsonSafely(value));
+}
+function isPObjectKey(value) {
+	return isLocalPObjectKey(value) || isGlobalPObjectKey(value);
+}
+function createPObjectId(obj) {
+	if (isLocalPObjectKey(obj)) return createLocalPObjectId(obj.resolvePath, obj.name);
+	if (isGlobalPObjectKey(obj)) return createGlobalPObjectId(obj.blockId, obj.name);
+	throw new Error(`createPObjectId: unrecognized object key structure: ${JSON.stringify(obj)}`);
+}
+function createLocalPObjectId(resolvePath, name) {
+	return canonicalizeJson({
+		resolvePath,
+		name
+	});
+}
+function isLocalPObjectKey(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const v = value;
+	return Array.isArray(v.resolvePath) && typeof v.name === "string";
+}
+function createGlobalPObjectId(blockId, exportName) {
+	return canonicalizeJson({
+		__isRef: true,
+		blockId,
+		name: exportName
+	});
+}
+function isGlobalPObjectKey(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return "__isRef" in value && "blockId" in value && "name" in value;
+}
+function isPObject(obj) {
+	return typeof obj === "object" && obj !== null && "id" in obj && "spec" in obj && "data" in obj;
+}
+function isPColumn(obj) {
+	return isPObject(obj) && isPColumnSpec(obj.spec);
+}
+function isPColumnSpec(spec) {
+	return spec.kind === "PColumn";
+}
+function ensurePColumn(obj) {
+	if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);
+	return obj;
+}
+function mapPObjectData(pObj, cb) {
+	return pObj === void 0 ? void 0 : {
+		...pObj,
+		data: cb(pObj.data)
+	};
+}
+function extractAllColumns(entry) {
+	const columns = /* @__PURE__ */ new Map();
+	const addAllColumns = (entry) => {
+		switch (entry.type) {
+			case "column":
+				columns.set(entry.column.id, entry.column);
+				return;
+			case "slicedColumn":
+				columns.set(entry.column.id, entry.column);
+				return;
+			case "artificialColumn":
+				columns.set(entry.column.id, entry.column);
+				return;
+			case "inlineColumn": return;
+			case "full":
+			case "inner":
+				for (const e of entry.entries) addAllColumns(e);
+				return;
+			case "outer":
+				addAllColumns(entry.primary);
+				for (const e of entry.secondary) addAllColumns(e);
+				return;
+			default: assertNever(entry);
+		}
+	};
+	addAllColumns(entry);
+	return [...columns.values()];
+}
+Array.isArray;
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.4/node_modules/@milaboratories/helpers/dist/error.js
+function throwError(v) {
+	if (typeof v === "string") throw new Error(v);
+	else throw v;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/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;
+}
+function distillColumnDiscoveredKey(props) {
+	return {
+		__isDiscovered: true,
+		column: props.column,
+		path: Array.isArray(props.path) && props.path.length > 0 ? props.path : void 0,
+		columnQualifications: Array.isArray(props.columnQualifications) && props.columnQualifications.length > 0 ? props.columnQualifications : void 0,
+		queriesQualifications: props.queriesQualifications && Object.keys(props.queriesQualifications).length > 0 ? props.queriesQualifications : void 0
+	};
+}
+function stringifyColumnDiscoveredId(id) {
+	return canonicalizeJson(distillColumnDiscoveredKey({
+		__isDiscovered: true,
+		...id
+	}));
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isFunction.mjs
+/**
+* Checks if `value` is a function.
+*
+* @param {any} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a function, else `false`.
+*
+* @example
+* isFunction(Array.prototype.slice); // true
+* isFunction(async function () {}); // true
+* isFunction(function* () {}); // true
+* isFunction(Proxy); // true
+* isFunction(Int8Array); // true
+*/
+function isFunction(value) {
+	return typeof value === "function";
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isNil.mjs
+/**
+* Checks if a given value is null or undefined.
+*
+* This function tests whether the provided value is either `null` or `undefined`.
+* It returns `true` if the value is `null` or `undefined`, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.
+*
+* @param {unknown} x - The value to test for null or undefined.
+* @returns {boolean} `true` if the value is null or undefined, `false` otherwise.
+*
+* @example
+* const value1 = null;
+* const value2 = undefined;
+* const value3 = 42;
+* const result1 = isNil(value1); // true
+* const result2 = isNil(value2); // true
+* const result3 = isNil(value3); // false
+*/
+function isNil(x) {
+	return x == null;
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isString.mjs
+/**
+* Checks if a given value is string.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `string`.
+*
+* @param {unknown} value The value to check if it is string.
+* @returns {value is string} Returns `true` if `value` is a string, else `false`.
+*
+* @example
+* const value1 = 'abc';
+* const value2 = 123;
+* const value3 = true;
+*
+* console.log(isString(value1)); // true
+* console.log(isString(value2)); // false
+* console.log(isString(value3)); // false
+*/
+function isString(value) {
+	return typeof value === "string";
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.js
 /**
-* Canonically serializes a {@link UniversalPColumnId} to a string.
-* @param id - The column identifier to serialize
-* @returns The canonically serialized string
+* Canonically serializes a column key to a branded string id. Accepts both
+* the new {@link ColumnUniversalKey} and the deprecated {@link UniversalPColumnId}
+* (anchored / old filtered object form).
 */
 function stringifyColumnId(id) {
-	return (0, import_canonicalize.default)(id);
+	return canonicalizeJson(id);
+}
+function parseColumnIdSafely(str, fallback = void 0) {
+	try {
+		return JSON.parse(str);
+	} catch {
+		return fallback;
+	}
+}
+/**
+* Walk a rich column id down to its terminal leaf {@link PObjectId}.
+*/
+function extractPObjectId(id) {
+	if (isString(id)) {
+		if (isPObjectId(id)) return id;
+		return extractPObjectId(parseColumnIdSafely(id) ?? throwError(`extractPObjectId: id "${id}" is not a valid canonical column id`));
+	}
+	if (isPObjectKey(id)) return createPObjectId(id);
+	if (isColumnFilteredKey(id)) return extractPObjectId(id.source);
+	if (isColumnOverriddenKey(id)) return extractPObjectId(id.source);
+	if (isColumnDiscoveredKey(id)) return extractPObjectId(id.column);
+	throw new Error(`extractPObjectId: unrecognized column id structure: ${JSON.stringify(id)}`);
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/overridden.js
+function isColumnOverriddenKey(obj) {
+	return typeof obj === "object" && obj !== null && "__isOverridden" in obj;
+}
+function distillColumnOverriddenKey(props) {
+	return {
+		__isOverridden: true,
+		source: props.source,
+		specOverrides: props.specOverrides
+	};
+}
+function createColumnOverriddenId(props) {
+	return stringifyColumnOverriddenId(createColumnOverriddenKey(props));
+}
+function createColumnOverriddenKey(props) {
+	const { source, specOverrides } = props;
+	const unwrapped = unwrapOverrides(source);
+	return {
+		__isOverridden: true,
+		source: unwrapped ? unwrapped.source : source,
+		specOverrides: unwrapped ? mergeSpecOverrides(unwrapped.specOverrides, specOverrides) : specOverrides
+	};
+}
+function stringifyColumnOverriddenId(id) {
+	return canonicalizeJson(distillColumnOverriddenKey(id));
+}
+/**
+* Peel one override-wrap layer.
+*
+* Invariant: `{source, specOverrides}` can only appear at the top level —
+* the inner `source` is never itself an override-wrap. Anything else throws.
+*/
+function unwrapOverrides(id) {
+	const parsed = parseColumnIdSafely(id);
+	if (parsed === void 0 || !isColumnOverriddenKey(parsed)) return void 0;
+	const inner = parseColumnIdSafely(parsed.source);
+	if (inner !== void 0 && isColumnOverriddenKey(inner)) throw new Error("nested override-wrap detected — invariant broken");
+	return parsed;
+}
+/**
+* Apply `specOverrides` from a rich id (`SUniversalPColumnId`) on top of a
+* resolved {@link PColumnSpec}. Returns `base` unchanged when the id carries
+* no overrides.
+*/
+function applySpecOverrides(base, idOrOverride) {
+	if (isNil(idOrOverride)) return base;
+	const overrides = isString(idOrOverride) ? unwrapOverrides(idOrOverride)?.specOverrides : idOrOverride;
+	if (isNil(overrides)) return base;
+	const result = { ...base };
+	if (overrides.annotations) result.annotations = mergeRecord(base.annotations, overrides.annotations);
+	if (overrides.domain) result.domain = mergeRecord(base.domain, overrides.domain);
+	if (overrides.contextDomain) result.contextDomain = mergeRecord(base.contextDomain, overrides.contextDomain);
+	if (overrides.axesSpec) result.axesSpec = applyAxesPatches(base.axesSpec, overrides.axesSpec);
+	return result;
+}
+/**
+* Compose two override patches: applying `mergeSpecOverrides(prior, next)` on
+* top of a base spec produces the same result as applying `prior` then `next`.
+*/
+function mergeSpecOverrides(prior, next) {
+	const result = {};
+	const axesSpec = mergeAxesPatches(prior.axesSpec, next.axesSpec);
+	if (axesSpec !== void 0) result.axesSpec = axesSpec;
+	const annotations = mergeRecord(prior.annotations, next.annotations);
+	if (annotations !== void 0) result.annotations = annotations;
+	const domain = mergeRecord(prior.domain, next.domain);
+	if (domain !== void 0) result.domain = domain;
+	const contextDomain = mergeRecord(prior.contextDomain, next.contextDomain);
+	if (contextDomain !== void 0) result.contextDomain = contextDomain;
+	return result;
+}
+/**
+* Apply positional `patches` onto `base.axesSpec`. Patches deep-merge
+* `annotations` / `domain` / `contextDomain` and shallow-override `name` /
+* `type` at their slot. Indices `>= base.length` append new axes; intermediate
+* gaps (if any) are filled with the patch itself, so callers should not leave
+* holes between base.length and the highest patched index.
+*/
+function applyAxesPatches(base, patches) {
+	const result = base.slice();
+	for (const [k, p] of Object.entries(patches)) {
+		const i = Number(k);
+		const existing = result[i];
+		result[i] = existing === void 0 ? p : mergeAxisPatch(existing, p);
+	}
+	return result;
+}
+/**
+* Compose two positional patch maps: `mergeAxesPatches(prior, next)` applied to
+* a base spec must equal applying `prior` then `next`. Patches sharing an
+* index deep-merge field-by-field.
+*/
+function mergeAxesPatches(prior, next) {
+	if (!prior || Object.keys(prior).length === 0) return next;
+	if (!next || Object.keys(next).length === 0) return prior;
+	const result = { ...prior };
+	for (const [k, p] of Object.entries(next)) {
+		const i = Number(k);
+		const existing = result[i];
+		result[i] = existing === void 0 ? p : mergeAxisPatch(existing, p);
+	}
+	return result;
+}
+function mergeAxisPatch(axis, patch) {
+	const result = {
+		...axis,
+		...patch
+	};
+	if (patch.annotations) result.annotations = mergeRecord(axis.annotations, patch.annotations);
+	if (patch.domain) result.domain = mergeRecord(axis.domain, patch.domain);
+	if (patch.contextDomain) result.contextDomain = mergeRecord(axis.contextDomain, patch.contextDomain);
+	return result;
+}
+function mergeRecord(a, b) {
+	if (!b) return a;
+	if (!a) return b;
+	return {
+		...a,
+		...b
+	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/anchored.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/anchored.js
 function axisKey(axis) {
 	return (0, import_canonicalize.default)(getAxisId(axis));
 }
@@ -5504,53 +5832,7 @@ function isAnchorAxisRef(value) {
 	return typeof value === "object" && "anchor" in value;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/pool/spec.js
-function isPColumnSpec(spec) {
-	return spec.kind === "PColumn";
-}
-function isPColumn(obj) {
-	return isPColumnSpec(obj.spec);
-}
-function ensurePColumn(obj) {
-	if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);
-	return obj;
-}
-function mapPObjectData(pObj, cb) {
-	return pObj === void 0 ? void 0 : {
-		...pObj,
-		data: cb(typeof pObj.data === "function" ? pObj.data() : pObj.data)
-	};
-}
-function extractAllColumns(entry) {
-	const columns = /* @__PURE__ */ new Map();
-	const addAllColumns = (entry) => {
-		switch (entry.type) {
-			case "column":
-				columns.set(entry.column.id, entry.column);
-				return;
-			case "slicedColumn":
-				columns.set(entry.column.id, entry.column);
-				return;
-			case "artificialColumn":
-				columns.set(entry.column.id, entry.column);
-				return;
-			case "inlineColumn": return;
-			case "full":
-			case "inner":
-				for (const e of entry.entries) addAllColumns(e);
-				return;
-			case "outer":
-				addAllColumns(entry.primary);
-				for (const e of entry.secondary) addAllColumns(e);
-				return;
-			default: assertNever(entry);
-		}
-	};
-	addAllColumns(entry);
-	return [...columns.values()];
-}
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.js
 /**
 * Determines if an axis ID matches an axis selector.
 *
@@ -5631,7 +5913,7 @@ function legacyColumnSelectorsToPredicate(predicateOrSelectors) {
 	else return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/native_id.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/native_id.js
 function deriveNativeId(spec) {
 	const result = {
 		kind: spec.kind,
@@ -5642,15 +5924,8 @@ function deriveNativeId(spec) {
 	if (isPColumnSpec(spec)) result.axesSpec = getAxesId(spec.axesSpec);
 	return (0, import_canonicalize.default)(result);
 }
-Array.isArray;
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.2/node_modules/@milaboratories/helpers/dist/error.js
-function throwError(v) {
-	if (typeof v === "string") throw new Error(v);
-	else throw v;
-}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/linker_columns.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/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;
@@ -5828,7 +6103,7 @@ var LinkerMap = class LinkerMap {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/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
@@ -5871,7 +6146,7 @@ function withEnrichments(ref, requireEnrichments = true) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/value_or_error.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/value_or_error.js
 function mapValueInVOE(voe, cb) {
 	return voe.ok ? {
 		ok: true,
@@ -5879,7 +6154,51 @@ function mapValueInVOE(voe, cb) {
 	} : voe;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/services/service_types.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/resource_types.js
+/** Well-known resource type names used across the platform. */
+const ResourceTypeName = {
+	StreamManager: "StreamManager",
+	StdMap: "StdMap",
+	StdMapSlash: "std/map",
+	EphStdMap: "EphStdMap",
+	PFrame: "PFrame",
+	ParquetChunk: "ParquetChunk",
+	BContext: "BContext",
+	BlockPackCustom: "BlockPackCustom",
+	BinaryMap: "BinaryMap",
+	BinaryValue: "BinaryValue",
+	BlobMap: "BlobMap",
+	BResolveSingle: "BResolveSingle",
+	BResolveSingleNoResult: "BResolveSingleNoResult",
+	BQueryResult: "BQueryResult",
+	TengoTemplate: "TengoTemplate",
+	TengoLib: "TengoLib",
+	SoftwareInfo: "SoftwareInfo",
+	Dummy: "Dummy",
+	JsonResourceError: "json/resourceError",
+	JsonObject: "json/object",
+	JsonGzObject: "json-gz/object",
+	JsonString: "json/string",
+	JsonArray: "json/array",
+	JsonNumber: "json/number",
+	BContextEnd: "BContextEnd",
+	FrontendFromUrl: "Frontend/FromUrl",
+	FrontendFromFolder: "Frontend/FromFolder",
+	BObjectSpec: "BObjectSpec",
+	Blob: "Blob",
+	Null: "Null",
+	Binary: "binary",
+	LSProvider: "LSProvider",
+	WorkingDirectory: "WorkingDirectory",
+	UserProject: "UserProject",
+	Projects: "Projects",
+	ClientRoot: "ClientRoot",
+	SharingOutbox: "SharingOutbox",
+	SharingState: "SharingState",
+	SharedEnvelope: "SharedEnvelope"
+};
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/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();
@@ -5918,7 +6237,7 @@ const { service, isNodeService, isWasmService, isMainService, getServiceKind, ge
 	};
 })();
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.js
 const Services = {
 	PFrameSpec: service()({
 		type: "wasm",
@@ -5976,6 +6295,28 @@ const Services = {
 		name: "dialog",
 		modelMethods: [],
 		uiMethods: ["showSaveDialog"]
+	}),
+	ColumnsCollection: service()({
+		type: "wasm",
+		name: "columnsCollection",
+		modelMethods: [
+			"create",
+			"isEmpty",
+			"isFinal",
+			"getColumns",
+			"addSource",
+			"discover",
+			"filter"
+		],
+		uiMethods: [
+			"create",
+			"isEmpty",
+			"isFinal",
+			"getColumns",
+			"addSource",
+			"discover",
+			"filter"
+		]
 	})
 };
 Object.keys(Services).map((key) => `requires${key}`);
@@ -5990,7 +6331,7 @@ function resolveRequiredServices(flags) {
 }
 Object.fromEntries(Object.keys(Services).map((key) => [`requires${key}`, true]));
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/services/service_injectors.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/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)];
@@ -5999,24 +6340,226 @@ function buildMethodMap(pick) {
 buildMethodMap(getServiceUiMethods);
 buildMethodMap(getServiceModelMethods);
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/render/accessor.js
-function ifDef(value, cb) {
-	return value === void 0 ? void 0 : cb(value);
-}
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/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];
 /**
-* Decode an error node's content into a display message. The backend serializes
-* a resource error as `{"message": "..."}` (`ResourceError`); unwrap that to the
-* human-readable message. Falls back to the raw string when the content is not
-* that envelope (e.g. plain text, or an unexpected shape).
+* Enumerate column names backing a PFrame accessor — derived from
+* `<name>.spec` field names, without resolving the spec resources.
 */
-function decodeErrorMessage(raw) {
-	try {
-		const parsed = JSON.parse(raw);
-		if (typeof parsed?.message === "string") return parsed.message;
-	} catch {}
-	return raw;
+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;
 }
-/** Represent resource tree node accessor */
+/**
+* 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.47.1/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.1/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`.
+*/
+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/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/render/accessor.js
+function ifDef(value, cb) {
+	return value === void 0 ? void 0 : cb(value);
+}
+/**
+* Decode an error node's content into a display message. The backend serializes
+* a resource error as `{"message": "..."}` (`ResourceError`); unwrap that to the
+* human-readable message. Falls back to the raw string when the content is not
+* that envelope (e.g. plain text, or an unexpected shape).
+*/
+function decodeErrorMessage(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed?.message === "string") return parsed.message;
+	} catch {}
+	return raw;
+}
+/** Represent resource tree node accessor */
 var TreeNodeAccessor = class TreeNodeAccessor {
 	handle;
 	resolvePath;
@@ -6045,7 +6588,7 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 		}));
 		return this.resolveWithCommon({}, ...transformedSteps);
 	}
-	resolveAny(...steps) {
+	traverse(...steps) {
 		return this.resolveWithCommon({}, ...steps);
 	}
 	resolveWithCommon(commonOptions, ...steps) {
@@ -6091,6 +6634,9 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 		if (content == void 0) throw new Error("Resource has no content.");
 		return JSON.parse(content);
 	}
+	hasData() {
+		return getCfgRenderCtx().hasData(this.handle);
+	}
 	getDataBase64() {
 		return getCfgRenderCtx().getDataBase64(this.handle);
 	}
@@ -6127,9 +6673,16 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 		}
 		return this.getDataAsJson();
 	}
-	/**
-	*
-	*/
+	getFileContentAsBase64(range) {
+		return new FutureRef(getCfgRenderCtx().getBlobContentAsBase64(this.handle, range));
+	}
+	getFileContentAsString(range) {
+		return new FutureRef(getCfgRenderCtx().getBlobContentAsString(this.handle, range));
+	}
+	getFileContentAsJson(range) {
+		return new FutureRef(getCfgRenderCtx().getBlobContentAsString(this.handle, range)).mapDefined((v) => JSON.parse(v));
+	}
+	/** @deprecated */
 	getPColumns(errorOnUnknownField = false, prefix = "") {
 		const result = this.parsePObjectCollection(errorOnUnknownField, prefix);
 		if (result === void 0) return void 0;
@@ -6138,9 +6691,7 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 			return obj;
 		});
 	}
-	/**
-	*
-	*/
+	/** @deprecated */
 	parsePObjectCollection(errorOnUnknownField = false, prefix = "") {
 		const pObjects = getCfgRenderCtx().parsePObjectCollection(this.handle, errorOnUnknownField, prefix, ...this.resolvePath);
 		if (pObjects === void 0) return void 0;
@@ -6151,15 +6702,6 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 		}
 		return result;
 	}
-	getFileContentAsBase64(range) {
-		return new FutureRef(getCfgRenderCtx().getBlobContentAsBase64(this.handle, range));
-	}
-	getFileContentAsString(range) {
-		return new FutureRef(getCfgRenderCtx().getBlobContentAsString(this.handle, range));
-	}
-	getFileContentAsJson(range) {
-		return new FutureRef(getCfgRenderCtx().getBlobContentAsString(this.handle, range)).mapDefined((v) => JSON.parse(v));
-	}
 	/**
 	* @deprecated use getFileContentAsBase64
 	*/
@@ -6250,11 +6792,11 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/render/internal.js
-const StagingAccessorName = "staging";
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/render/internal.js
 const MainAccessorName = "main";
+const StagingAccessorName = "staging";
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/render/util/axis_filtering.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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;
@@ -6318,49 +6860,7 @@ function filterDataInfoEntries(dataInfoEntries, axisFilters) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isFunction.mjs
-/**
-* Checks if `value` is a function.
-*
-* @param {any} value The value to check.
-* @returns {boolean} Returns `true` if `value` is a function, else `false`.
-*
-* @example
-* isFunction(Array.prototype.slice); // true
-* isFunction(async function () {}); // true
-* isFunction(function* () {}); // true
-* isFunction(Proxy); // true
-* isFunction(Int8Array); // true
-*/
-function isFunction(value) {
-	return typeof value === "function";
-}
-//#endregion
-//#region ../node_modules/.pnpm/es-toolkit@1.47.0/node_modules/es-toolkit/dist/predicate/isNil.mjs
-/**
-* Checks if a given value is null or undefined.
-*
-* This function tests whether the provided value is either `null` or `undefined`.
-* It returns `true` if the value is `null` or `undefined`, and `false` otherwise.
-*
-* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.
-*
-* @param {unknown} x - The value to test for null or undefined.
-* @returns {boolean} `true` if the value is null or undefined, `false` otherwise.
-*
-* @example
-* const value1 = null;
-* const value2 = undefined;
-* const value3 = 42;
-* const result1 = isNil(value1); // true
-* const result2 = isNil(value2); // true
-* const result3 = isNil(value3); // false
-*/
-function isNil(x) {
-	return x == null;
-}
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/labels/derive_distinct_labels.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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";
@@ -6626,7 +7126,7 @@ function minimizeTypeSet(typeSet, records, stats, forceTraceElements, forcedSet,
 	return result;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/render/util/label.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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) => ({
@@ -6635,7 +7135,7 @@ function deriveLabels(values, getSpec, options = {}) {
 	}));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/render/util/pcolumn_data.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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";
@@ -6922,7 +7422,7 @@ function isPColumnReady(c) {
 	const isValues = (d) => Array.isArray(d);
 	const isAccessor = (d) => d instanceof TreeNodeAccessor;
 	let ready = true;
-	const data = typeof c.data === "function" ? c.data() : c.data;
+	const data = c.data;
 	if (data == null) return false;
 	else if (isAccessor(data)) ready &&= data.getIsReadyOrError();
 	else if (isDataInfo(data)) visitDataInfo(data, (v) => ready &&= v.getIsReadyOrError());
@@ -6933,7 +7433,7 @@ function allPColumnsReady(columns) {
 	return columns.every(isPColumnReady);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/render/util/column_collection.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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;
@@ -6943,7 +7443,7 @@ function isPColumnValues(value) {
 /**
 * A simple implementation of {@link ColumnProvider} backed by a pre-defined array of columns.
 */
-var ArrayColumnProvider = class {
+var ArrayColumnsProvider = class {
 	columns;
 	constructor(columns) {
 		this.columns = columns;
@@ -6995,7 +7495,7 @@ function getSplitAxisIndices(selector) {
 }
 var PColumnCollection = class {
 	defaultProviderStore = [];
-	providers = [new ArrayColumnProvider(this.defaultProviderStore)];
+	providers = [new ArrayColumnsProvider(this.defaultProviderStore)];
 	axisLabelProviders = [];
 	constructor() {}
 	addColumnProvider(provider) {
@@ -7158,7 +7658,9 @@ var PColumnCollection = class {
 			result.push({
 				id: finalId,
 				spec: finalSpec,
-				data: () => entry.type === "split" ? entriesToDataInfo(filterDataInfoEntries(entry.dataEntries, axisFiltersTuple)) : entry.originalColumn.data,
+				get data() {
+					return entry.type === "split" ? entriesToDataInfo(filterDataInfoEntries(entry.dataEntries, axisFiltersTuple)) : entry.originalColumn.data;
+				},
 				label
 			});
 		}
@@ -7194,7 +7696,7 @@ var PColumnCollection = class {
 		if (!entries) return void 0;
 		const columns = [];
 		for (const entry of entries) {
-			const data = entry.data();
+			const data = entry.data;
 			if (!data) {
 				if (opts?.dontWaitAllData) continue;
 				return;
@@ -7209,7 +7711,7 @@ var PColumnCollection = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/services/block_services.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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.
@@ -7220,11 +7722,12 @@ var PColumnCollection = class {
 const BLOCK_SERVICE_FLAGS = {
 	requiresPFrameSpec: true,
 	requiresPFrame: true,
-	requiresDialog: true
+	requiresDialog: true,
+	requiresColumnsCollection: true
 };
 resolveRequiredServices(BLOCK_SERVICE_FLAGS);
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/services/service_bridge.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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.
@@ -7233,10 +7736,10 @@ 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.79.24/node_modules/@platforma-sdk/model/dist/services/get_services.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/services/get_services.js
 const cachedServices = /* @__PURE__ */ new WeakMap();
-function getService(name) {
-	const ctx = getCfgRenderCtx();
+function getService(name, deps) {
+	const ctx = deps?.ctx ?? getCfgRenderCtx();
 	const map = cachedServices.has(ctx) ? cachedServices.get(ctx) : (() => {
 		cachedServices.set(ctx, /* @__PURE__ */ new Map());
 		return cachedServices.get(ctx);
@@ -7247,7 +7750,7 @@ function getService(name) {
 	})();
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/render/util/pframe_upgraders.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/render/util/pframe_upgraders.js
 function patchInSetFilters(filters) {
 	const inSetToOrEqual = (predicate) => {
 		if (predicate.operator !== "InSet") return predicate;
@@ -7285,7 +7788,7 @@ function patchInSetFilters(filters) {
 	return filters.map((filter) => mapFilter(filter, inSetToOrEqual));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/render/api.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/render/api.js
 /**
 * Helper function to match domain objects
 * @param query Optional domain to match against
@@ -7300,24 +7803,35 @@ function matchDomain(query, target) {
 }
 /**
 * Transforms PColumn data into the internal representation expected by the platform
-* @param data Data from a PColumn to transform
+* @param column Data from a PColumn to transform
 * @returns Transformed data compatible with platform API
 */
-function transformPColumnData(data) {
-	return mapPObjectData(data, (d) => {
-		if (d instanceof TreeNodeAccessor) return d.handle;
-		else if (isDataInfo(d)) return mapDataInfo(d, (accessor) => accessor.handle);
-		else return d ?? [];
+function finalizePColumnData(column) {
+	return mapPObjectData(column, (data) => {
+		if (data instanceof TreeNodeAccessor) return data.handle;
+		else if (isDataInfo(data)) {
+			let ready = true;
+			visitDataInfo(data, (accessor) => ready &&= accessor?.getIsReadyOrError() ?? false);
+			if (!ready) return [];
+			return mapDataInfo(data, (accessor) => accessor?.handle ?? throwError("Accessor handle is undefined"));
+		} else return data ?? [];
 	});
 }
+/**
+* @deprecated use the direct `ctx.*` methods on `RenderCtxBase` instead.
+*
+* Migration map:
+* - `getSpecs` → `ctx.getSpecs`
+* - `getSpecByRef` / `getPColumnSpecByRef` → `ctx.getSpecByRef` / `ctx.getPColumnSpecByRef`
+* - `getDataByRef` / `getPColumnByRef` → `ctx.getDataByRef` / `ctx.getPColumnByRef`
+* - `getOptions` → `ctx.getOptions`
+*
+* Eager methods `selectColumns` / `getData` / `getDataWithErrors` should be
+* replaced by `ctx.getSpecs` + on-demand `ctx.getStatusByRef` /
+* `ctx.getPColumnByRef` so that the data resource is not subscribed up-front.
+*/
 var ResultPool = class {
 	ctx = getCfgRenderCtx();
-	/**
-	* @deprecated use getOptions()
-	*/
-	calculateOptions(predicate) {
-		return this.ctx.calculateOptions(predicate);
-	}
 	getOptions(predicateOrSelector, opts) {
 		const predicate = typeof predicateOrSelector === "function" ? predicateOrSelector : legacyColumnSelectorsToPredicate(predicateOrSelector);
 		const filtered = this.getSpecs().entries.filter((s) => predicate(s.obj));
@@ -7461,7 +7975,6 @@ var ResultPool = class {
 	* @returns data associated with the ref
 	*/
 	getDataByRef(ref) {
-		if (typeof this.ctx.getDataFromResultPoolByRef === "undefined") return this.getData().entries.find((f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name)?.obj;
 		const data = this.ctx.getDataFromResultPoolByRef(ref.blockId, ref.name);
 		if (!data) return void 0;
 		return mapPObjectData(data, (handle) => new TreeNodeAccessor(handle, [ref.blockId, ref.name]));
@@ -7542,6 +8055,9 @@ var ResultPool = class {
 	*
 	* @param selectors - A predicate function, a single selector, or an array of selectors.
 	* @returns An array of PColumn objects matching the selectors. Data is loaded on first access.
+	* @deprecated use `RenderCtxBase.rawResultPool` + `ResultPoolColumnsProvider` +
+	* `discoverColumns` instead. This eager path materializes column data
+	* unnecessarily for callers that only filter by spec.
 	*/
 	selectColumns(selectors) {
 		const predicate = typeof selectors === "function" ? selectors : legacyColumnSelectorsToPredicate(selectors);
@@ -7619,20 +8135,8 @@ var RenderCtxBase = class {
 	get outputs() {
 		return this.getNamedAccessor(MainAccessorName);
 	}
+	/** @deprecated use `rawResultPool` + `ResultPoolColumnsProvider` instead. */
 	resultPool = new ResultPool();
-	/**
-	* Find labels data for a given axis id. It will search for a label column and return its data as a map.
-	* @returns a map of axis value => label
-	* @deprecated Use resultPool.findLabels instead
-	*/
-	findLabels(axis) {
-		return this.resultPool.findLabels(axis);
-	}
-	verifyInlineAndExplicitColumnsSupport(columns) {
-		const hasInlineColumns = columns.some((c) => !(c.data instanceof TreeNodeAccessor) || isDataInfo(c.data));
-		const inlineColumnsSupport = this.ctx.featureFlags?.inlineColumnsSupport === true;
-		if (hasInlineColumns && !inlineColumnsSupport) throw Error(`Inline or explicit columns not supported`);
-	}
 	patchPTableDef(def) {
 		if (!this.ctx.featureFlags?.pTablePartitionFiltersSupport) def = {
 			...def,
@@ -7647,7 +8151,7 @@ var RenderCtxBase = class {
 		return def;
 	}
 	createPFrame(def) {
-		return this.ctx.createPFrame(def.map((c) => transformPColumnData(c)));
+		return this.ctx.createPFrame(def.map((v) => isString(v) ? v : finalizePColumnData(v)));
 	}
 	createPTable(def) {
 		let rawDef;
@@ -7664,17 +8168,11 @@ var RenderCtxBase = class {
 			sorting: def.sorting ?? []
 		});
 		else rawDef = this.patchPTableDef(def);
-		const columns = extractAllColumns(rawDef.src);
-		this.verifyInlineAndExplicitColumnsSupport(columns);
-		if (!allPColumnsReady(columns)) return void 0;
-		return this.ctx.createPTable(mapPTableDef(rawDef, (po) => transformPColumnData(po)));
+		if (!allPColumnsReady(extractAllColumns(rawDef.src))) return void 0;
+		return this.ctx.createPTable(mapPTableDef(rawDef, finalizePColumnData));
 	}
 	createPTableV2(def) {
-		return this.ctx.createPTableV2(mapPTableDefV2(def, (po) => transformPColumnData(po)));
-	}
-	/** @deprecated scheduled for removal from SDK */
-	getBlockLabel(blockId) {
-		return this.ctx.getBlockLabel(blockId);
+		return this.ctx.createPTableV2(mapPTableDefV2(def, { column: (v) => isString(v) ? v : finalizePColumnData(v) }));
 	}
 	getCurrentUnstableMarker() {
 		return this.ctx.getCurrentUnstableMarker();
@@ -7739,27 +8237,27 @@ var PluginRenderCtx = class extends RenderCtxBase {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/version.js
-const PlatformaSDKVersion = "1.79.24";
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/version.js
+const PlatformaSDKVersion = "1.80.2";
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/bconfig/types.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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.79.24/node_modules/@platforma-sdk/model/dist/bconfig/normalization.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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.79.24/node_modules/@platforma-sdk/model/dist/plugin_model.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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.79.24/node_modules/@platforma-sdk/model/dist/block_storage_callbacks.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_storage_callbacks.js
 /**
 * BlockStorage Callback Implementations - wired to facade callbacks in BlockModelV3.done().
 *
@@ -7936,7 +8434,7 @@ function derivePrerunArgsFromStorage(storageJson, argsFunction, prerunArgsFuncti
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/block_model.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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`
@@ -8247,6 +8745,1466 @@ var BlockModelV3 = class BlockModelV3 {
 		};
 	}
 };
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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
+* (Overridden / Filtered) and Discovered use this to lift their own id onto
+* the hit leaf, so per-variant uniqueness propagates to the engine and
+* resolver-emitted ids match leaves in the emitted SpecQuery.
+*
+* Generic over all SpecQuery node shapes — including `linkerJoin`, which
+* occurs when a wrapper sits over a {@link ColumnDiscoveredRecipe}: only
+* the deepest hit leaf carries `fromId`, every linker leaf has a different
+* id and is left untouched.
+*/
+function rebrandLeafId(node, fromId, toId) {
+	if (fromId === toId) return node;
+	return mapSpecQueryColumns(node, { column: (id) => id === fromId ? toId : id });
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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 }`.
+*
+* Flat-merge invariant: `inner` is never another {@link ColumnOverriddenRecipe}.
+* Repeated overrides go through {@link wrap} / {@link withSpecs}, which merge
+* `specOverrides` at the current level and keep wrapper depth constant.
+*
+* This invariant matches the one enforced inside `unwrapOverrides` from
+* pl-model-common: it explicitly throws on a nested override-wrap.
+*/
+var ColumnOverriddenRecipe = class ColumnOverriddenRecipe {
+	inner;
+	overrides;
+	/**
+	* Wrap any recipe with overrides. If `inner` is already a
+	* {@link ColumnOverriddenRecipe}, merges `overrides` into the existing ones
+	* and returns a new Overridden sharing the original `inner`. No
+	* `Overridden<Overridden<X>>` is produced.
+	*/
+	static wrap(col, overrides) {
+		if (col instanceof ColumnOverriddenRecipe) return new ColumnOverriddenRecipe(col.inner, mergeSpecOverrides(col.overrides, overrides));
+		return new ColumnOverriddenRecipe(col, overrides);
+	}
+	/**
+	* Static counterpart to {@link wrap}: returns the resolution status of a
+	* {@link ColumnOverriddenKey} without constructing the recipe. Overrides
+	* do not add references — status collapses to the source's status.
+	*/
+	static getStatusByKey(key, opts = {}) {
+		return ColumnRecipe.getStatus(key.source, opts);
+	}
+	id;
+	specCache;
+	queryCache;
+	dataStatusCache;
+	constructor(inner, overrides) {
+		this.inner = inner;
+		this.overrides = overrides;
+		this.id = createColumnOverriddenId({
+			source: inner.id,
+			specOverrides: overrides
+		});
+	}
+	/** Wrapped recipe — exposed so external walkers can descend. */
+	getInner() {
+		return this.inner;
+	}
+	/**
+	* `inner` owns all references; overrides are a pure spec patch and do not
+	* introduce new column refs.
+	*/
+	getReferencedIds() {
+		return this.inner.getReferencedIds();
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: this.inner.getDataStatus() };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Take the inner spec and overlay our overrides. `applySpecOverrides`
+	* extracts the overrides from `this.id` itself.
+	*/
+	getSpec() {
+		if (this.specCache === void 0) this.specCache = { value: applySpecOverrides(this.inner.getSpec(), this.id) };
+		return this.specCache.value;
+	}
+	/**
+	* Emit a client-side `specOverride` node wrapping the inner query.
+	*
+	* This is a structural-but-collapsible node: it carries the override
+	* patch through the query tree so consumers see the full recipe shape,
+	* but it is collapsed at the host boundary (`resolvePColumn`) before
+	* the query reaches pframe-engine. The engine never sees this node.
+	*
+	* Overrides do not change query topology — they are a pure spec patch.
+	*/
+	getQuery() {
+		if (this.queryCache === void 0) this.queryCache = { value: {
+			type: "specOverride",
+			input: rebrandLeafId(this.inner.getQuery(), this.inner.id, this.id),
+			override: this.overrides
+		} };
+		return this.queryCache.value;
+	}
+	/**
+	* Flat merge: new overrides merge with existing ones; `inner` is unchanged.
+	* The result is an Overridden of the same depth.
+	*/
+	withSpecs(overrides) {
+		return ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+};
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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.
+*
+* Specifics:
+*  - References more than one column (`column` + each `path[i].column`);
+*    {@link getDataStatus} aggregates across the whole set.
+*  - {@link getQuery} assembles the {@link SpecQuery} locally
+*    ({@link buildSpecQuery}) — the hit is inlined as its own recipe's query
+*    tree, linkers fold inside-out into nested `linkerJoin` nodes.
+*  - {@link getSpec} passes through to the hit column's own spec: the linker
+*    chain only enables co-indexing and does not remap the hit's `axesSpec`, so
+*    no engine round-trip is needed (mirrors the Discovered branch of
+*    `reconstructSpecFromId` on the host side).
+*/
+var ColumnDiscoveredRecipe = class ColumnDiscoveredRecipe {
+	key;
+	columns;
+	/**
+	* Validate the key + resolve every referenced column via
+	* {@link ColumnLazy.fromId} (which itself checks the leaf accessor reports
+	* `hasData()`). Returns `undefined` if the key is malformed or any
+	* referenced column is not yet spec-resolvable.
+	*
+	* Spec JSON is deserialized lazily on first {@link getSpec}/{@link getQuery}.
+	*/
+	static fromKey(key, opts = {}) {
+		const distilled = distillColumnDiscoveredKey(key);
+		const columns = {};
+		for (const uniId of referencedUniIdsOf(distilled)) {
+			const recipe = Column(uniId, opts);
+			if (recipe === void 0) return void 0;
+			columns[uniId] = recipe;
+		}
+		return new ColumnDiscoveredRecipe(distilled, columns);
+	}
+	/**
+	* Static counterpart to {@link fromKey}: returns the resolution status of
+	* a {@link ColumnDiscoveredKey} without constructing the recipe. Worst-wins
+	* across every referenced {@link ColumnUniversalId} (hit + path linkers),
+	* each resolved via the top-level {@link ColumnRecipe.getStatus} dispatcher.
+	*/
+	static getStatusByKey(key, opts = {}) {
+		const distilled = distillColumnDiscoveredKey(key);
+		let worst = "present";
+		for (const uniId of referencedUniIdsOf(distilled)) {
+			const s = ColumnRecipe.getStatus(uniId, opts);
+			if (s === "absent") return "absent";
+			if (s === "resolving") worst = "resolving";
+		}
+		return worst;
+	}
+	id;
+	specCache;
+	queryCache;
+	dataStatusCache;
+	constructor(key, columns) {
+		this.key = key;
+		this.columns = columns;
+		this.id = stringifyColumnDiscoveredId(this.key);
+	}
+	/**
+	* Universal id of the hit column (excluding path/qualifications on top).
+	* May itself be a wrapped id (Overridden / Filtered / nested Discovered) —
+	* preserves projections applied to the underlying column.
+	*/
+	getHitId() {
+		return this.key.column;
+	}
+	/**
+	* Axis qualifications attached to the hit column itself — applied to the
+	* outer-join entry that wraps this column at the consumer boundary.
+	*/
+	getColumnQualifications() {
+		return this.key.columnQualifications ?? [];
+	}
+	/**
+	* Per-primary-column qualifications applied to the primary anchors on
+	* this group's side. Keyed by the external primary column id.
+	*/
+	getQueriesQualifications() {
+		return this.key.queriesQualifications ?? {};
+	}
+	/**
+	* Leaf {@link PObjectId}s the recipe physically depends on: hit column +
+	* each linker in `path`, with any projection wrappers unwrapped down to
+	* their underlying storage column. Used to track real-data dependencies
+	* (e.g. {@link getDataStatus}), not projected identities.
+	*/
+	getReferencedIds() {
+		return [...new Set([...referencedUniIdsOf(this.key)].map((uniId) => extractPObjectId(uniId)))];
+	}
+	/**
+	* Final spec of a discovered hit is just the hit column's own spec: the
+	* linker chain only enables co-indexing, it does not remap the hit's
+	* `axesSpec`, and axis qualifications live on the outer join entry (see
+	* {@link buildSpecQuery}), not in the spec. So pass through to the hit
+	* recipe's `getSpec()` — no engine round-trip needed. This mirrors the
+	* Discovered branch of `reconstructSpecFromId` on the host side.
+	*/
+	getSpec() {
+		if (this.specCache === void 0) {
+			const hit = this.columns[this.key.column] ?? throwError(`ColumnDiscoveredRecipe.getSpec: missing column ${this.key.column}`);
+			this.specCache = { value: hit.getSpec() };
+		}
+		return this.specCache.value;
+	}
+	/** IR for building the final spec — see {@link buildSpecQuery}. */
+	getQuery() {
+		if (this.queryCache === void 0) this.queryCache = { value: this.buildSpecQuery() };
+		return this.queryCache.value;
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: Object.values(this.columns).reduce((worst, lazy) => {
+			const s = lazy.getDataStatus();
+			if (s === "absent" || worst === "absent") return "absent";
+			if (s === "resolving") return "resolving";
+			return worst;
+		}, "present") };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Discovered + overrides → Overridden<Discovered>. Delegates to the
+	* flat-merge factory of ColumnOverriddenRecipe; subsequent `withSpecs`
+	* calls merge at the Overridden level (one wrapper, no nesting).
+	*/
+	withSpecs(overrides) {
+		return ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+	/**
+	* Assembles the SpecQuery for this discovered hit by folding `key.path`
+	* around the hit column.
+	*
+	* The hit (innermost) is built by inlining `columns[key.column].getQuery()`
+	* — recursing into the hit's own recipe — so wrapping layers on the hit
+	* (Overridden / Filtered / nested Discovered) appear in the produced tree.
+	* The previous `pframeSpec.buildQuery` path was a flat
+	* {@link PObjectId}-only call and could not express that.
+	*
+	* Linkers stay as plain column references on the linker side of
+	* `linkerJoin` (the spec node has no slot for a query-side linker); the
+	* linker's recipe id is used directly. The frame registered in
+	* {@link getSpec} carries each recipe's final spec under that same id, so
+	* the engine resolves linker axes from the post-projection spec.
+	*
+	* Path ordering matches {@link ColumnDiscoveredKey.path}: `path[0]` is
+	* outermost, `path[N-1]` is closest to the hit. We fold from the inside
+	* out — innermost wrap first — so the result lines up with that convention.
+	*
+	* `columnQualifications` / `queriesQualifications` are not emitted here —
+	* qualifications live on a {@link SpecQueryJoinEntry} wrapper (lost on
+	* unwrapping to {@link SpecQuery}). External consumers apply them at the
+	* outer join via {@link getColumnQualifications} / {@link getQueriesQualifications}.
+	*/
+	buildSpecQuery() {
+		const hitRecipe = this.columns[this.key.column] ?? throwError(`ColumnDiscoveredRecipe.buildSpecQuery: missing column ${this.key.column}`);
+		let query = rebrandLeafId(hitRecipe.getQuery(), hitRecipe.id, this.id);
+		const path = this.key.path ?? [];
+		for (let i = path.length - 1; i >= 0; i--) query = {
+			type: "linkerJoin",
+			linker: (this.columns[path[i].column] ?? throwError(`ColumnDiscoveredRecipe.buildSpecQuery: missing linker column ${path[i].column}`)).getQuery(),
+			secondary: [{ entry: query }]
+		};
+		return query;
+	}
+};
+function referencedUniIdsOf(key) {
+	return /* @__PURE__ */ new Set([key.column, ...(key.path ?? []).map((item) => item.column)]);
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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,
+* axisFilters }`.
+*
+* Flat-merge invariant: `inner` is never another {@link ColumnFilteredRecipe}.
+* Repeated {@link wrap} concatenates `axisFilters` at the current level.
+*
+* Layering: `withSpecs` on a Filtered recipe yields
+* `Overridden<Filtered<inner>>` — Overridden is always the outermost layer.
+* The reverse layering (`Filtered<Overridden<...>>`) is not reachable via
+* the public interface.
+*/
+var ColumnFilteredRecipe = class ColumnFilteredRecipe {
+	inner;
+	axisFilters;
+	/**
+	* Wrap any recipe with axis filters. If `inner` is already a
+	* {@link ColumnFilteredRecipe}, concatenates `axisFilters` and returns a
+	* new Filtered sharing the original `inner`.
+	*
+	* Validates every axis index against `inner.getSpec().axesSpec` at
+	* construction — throws on an out-of-range index. After {@link wrap}, the
+	* recipe is guaranteed to be spec-complete.
+	*
+	* Order semantics: new filters are appended after existing ones, preserving
+	* their relative order. AND composition is otherwise commutative; order
+	* only affects canonicalize/equality.
+	*/
+	static wrap(col, axisFilters) {
+		const combined = col instanceof ColumnFilteredRecipe ? [...col.axisFilters, ...axisFilters] : axisFilters;
+		const base = col instanceof ColumnFilteredRecipe ? col.inner : col;
+		if (combined.length === 0) throw new Error("ColumnFilteredRecipe.wrap: at least one axis filter must be provided");
+		const innerSpec = base.getSpec();
+		const fixed = /* @__PURE__ */ new Set();
+		for (const [idx] of combined) {
+			if (innerSpec.axesSpec[idx] === void 0) throw new Error(`ColumnFilteredRecipe.wrap: axis index ${idx} out of range (inner has ${innerSpec.axesSpec.length} axes)`);
+			fixed.add(idx);
+		}
+		if (fixed.size >= innerSpec.axesSpec.length) throw new Error(`ColumnFilteredRecipe.wrap: filters fix all ${innerSpec.axesSpec.length} axes — at least one axis must remain`);
+		return new ColumnFilteredRecipe(base, combined);
+	}
+	/**
+	* Static counterpart to {@link wrap}: returns the resolution status of a
+	* {@link ColumnFilteredKey} without constructing the recipe. Axis filters
+	* do not add references — status collapses to the source's status.
+	*/
+	static getStatusByKey(key, opts = {}) {
+		if (typeof key.source !== "string") throw new Error("ColumnFilteredRecipe.getStatusByKey: filtered column with non-string source");
+		return ColumnRecipe.getStatus(key.source, opts);
+	}
+	id;
+	specCache;
+	queryCache;
+	dataStatusCache;
+	constructor(inner, axisFilters) {
+		this.inner = inner;
+		this.axisFilters = axisFilters;
+		this.id = stringifyColumnFilteredId({
+			source: inner.id,
+			axisFilters
+		});
+	}
+	/** Wrapped recipe — exposed so external walkers can descend. */
+	getInner() {
+		return this.inner;
+	}
+	/** Axis filters do not introduce references to other columns. */
+	getReferencedIds() {
+		return this.inner.getReferencedIds();
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: this.inner.getDataStatus() };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Final spec — the inner spec with fixed axes removed. Indices in
+	* `axisFilters` are positional against `inner.getSpec().axesSpec` and were
+	* validated at {@link wrap} time.
+	*/
+	getSpec() {
+		if (this.specCache === void 0) this.specCache = { value: applyAxisFilters(this.inner.getSpec(), this.axisFilters) };
+		return this.specCache.value;
+	}
+	/**
+	* Wraps the inner query in `SpecQuerySliceAxes`. Index→selector resolution
+	* goes through the inner spec — guaranteed available since {@link wrap}
+	* validated all indices at construction.
+	*/
+	getQuery() {
+		if (this.queryCache === void 0) {
+			const innerQuery = this.inner.getQuery();
+			if (this.axisFilters.length === 0) this.queryCache = { value: rebrandLeafId(innerQuery, this.inner.id, this.id) };
+			else {
+				const innerSpec = this.inner.getSpec();
+				this.queryCache = { value: {
+					type: "sliceAxes",
+					input: rebrandLeafId(innerQuery, this.inner.id, this.id),
+					axisFilters: this.axisFilters.map(([idx, value]) => ({
+						axisSelector: toAxisSelector(innerSpec.axesSpec[idx]),
+						constant: value
+					}))
+				} };
+			}
+		}
+		return this.queryCache.value;
+	}
+	/**
+	* Filtered + overrides → Overridden<Filtered>. Overridden is always the
+	* outermost layer.
+	*/
+	withSpecs(overrides) {
+		return ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+};
+function toAxisSelector(axis) {
+	const selector = {
+		name: axis.name,
+		type: axis.type
+	};
+	if (axis.domain !== void 0 && Object.keys(axis.domain).length > 0) selector.domain = axis.domain;
+	if (axis.contextDomain !== void 0 && Object.keys(axis.contextDomain).length > 0) selector.contextDomain = axis.contextDomain;
+	return selector;
+}
+//#endregion
+//#region ../node_modules/.pnpm/lru-cache@11.5.1/node_modules/lru-cache/dist/esm/browser/index.min.js
+var L = { hasSubscribers: !1 }, S = L, W = L;
+var M = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+var D = () => S.hasSubscribers || W.hasSubscribers, j = /* @__PURE__ */ new Set(), I = typeof process == "object" && process ? process : {}, P = (u, e, t, i) => {
+	typeof I.emitWarning == "function" ? I.emitWarning(u, e, t, i) : console.error(`[${t}] ${e}: ${u}`);
+}, k = (u) => !j.has(u);
+var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(u) ? u <= Math.pow(2, 8) ? Uint8Array : u <= Math.pow(2, 16) ? Uint16Array : u <= Math.pow(2, 32) ? Uint32Array : u <= Number.MAX_SAFE_INTEGER ? O : null : null, O = class extends Array {
+	constructor(e) {
+		super(e), this.fill(0);
+	}
+}, R = class u {
+	heap;
+	length;
+	static #o = !1;
+	static create(e) {
+		let t = G(e);
+		if (!t) return [];
+		u.#o = !0;
+		let i = new u(e, t);
+		return u.#o = !1, i;
+	}
+	constructor(e, t) {
+		if (!u.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+		this.heap = new t(e), this.length = 0;
+	}
+	push(e) {
+		this.heap[this.length++] = e;
+	}
+	pop() {
+		return this.heap[--this.length];
+	}
+}, U = class u {
+	#o;
+	#c;
+	#S;
+	#O;
+	#w;
+	#M;
+	#I;
+	#m;
+	get perf() {
+		return this.#m;
+	}
+	ttl;
+	ttlResolution;
+	ttlAutopurge;
+	updateAgeOnGet;
+	updateAgeOnHas;
+	allowStale;
+	noDisposeOnSet;
+	noUpdateTTL;
+	maxEntrySize;
+	sizeCalculation;
+	noDeleteOnFetchRejection;
+	noDeleteOnStaleGet;
+	allowStaleOnFetchAbort;
+	allowStaleOnFetchRejection;
+	ignoreFetchAbort;
+	backgroundFetchSize;
+	#n;
+	#b;
+	#s;
+	#i;
+	#t;
+	#l;
+	#u;
+	#a;
+	#h;
+	#y;
+	#r;
+	#_;
+	#F;
+	#d;
+	#g;
+	#T;
+	#U;
+	#f;
+	#x;
+	static unsafeExposeInternals(e) {
+		return {
+			starts: e.#F,
+			ttls: e.#d,
+			autopurgeTimers: e.#g,
+			sizes: e.#_,
+			keyMap: e.#s,
+			keyList: e.#i,
+			valList: e.#t,
+			next: e.#l,
+			prev: e.#u,
+			get head() {
+				return e.#a;
+			},
+			get tail() {
+				return e.#h;
+			},
+			free: e.#y,
+			isBackgroundFetch: (t) => e.#e(t),
+			backgroundFetch: (t, i, s, n) => e.#P(t, i, s, n),
+			moveToTail: (t) => e.#L(t),
+			indexes: (t) => e.#A(t),
+			rindexes: (t) => e.#z(t),
+			isStale: (t) => e.#p(t)
+		};
+	}
+	get max() {
+		return this.#o;
+	}
+	get maxSize() {
+		return this.#c;
+	}
+	get calculatedSize() {
+		return this.#b;
+	}
+	get size() {
+		return this.#n;
+	}
+	get fetchMethod() {
+		return this.#M;
+	}
+	get memoMethod() {
+		return this.#I;
+	}
+	get dispose() {
+		return this.#S;
+	}
+	get onInsert() {
+		return this.#O;
+	}
+	get disposeAfter() {
+		return this.#w;
+	}
+	constructor(e) {
+		let { max: t = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: r, updateAgeOnHas: h, allowStale: a, dispose: o, onInsert: d, disposeAfter: y, noDisposeOnSet: _, noUpdateTTL: c, maxSize: g = 0, maxEntrySize: f = 0, sizeCalculation: b, fetchMethod: l, memoMethod: w, noDeleteOnFetchRejection: F, noDeleteOnStaleGet: m, allowStaleOnFetchRejection: p, allowStaleOnFetchAbort: A, ignoreFetchAbort: z, backgroundFetchSize: C = 1, perf: E } = e;
+		if (this.backgroundFetchSize = C, E !== void 0 && typeof E?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+		if (this.#m = E ?? M, t !== 0 && !T(t)) throw new TypeError("max option must be a nonnegative integer");
+		let v = t ? G(t) : Array;
+		if (!v) throw new Error("invalid max value: " + t);
+		if (this.#o = t, this.#c = g, this.maxEntrySize = f || this.#c, this.sizeCalculation = b, this.sizeCalculation) {
+			if (!this.#c && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+			if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+		}
+		if (w !== void 0 && typeof w != "function") throw new TypeError("memoMethod must be a function if defined");
+		if (this.#I = w, l !== void 0 && typeof l != "function") throw new TypeError("fetchMethod must be a function if specified");
+		if (this.#M = l, this.#U = !!l, this.#s = /* @__PURE__ */ new Map(), this.#i = Array.from({ length: t }).fill(void 0), this.#t = Array.from({ length: t }).fill(void 0), this.#l = new v(t), this.#u = new v(t), this.#a = 0, this.#h = 0, this.#y = R.create(t), this.#n = 0, this.#b = 0, typeof o == "function" && (this.#S = o), typeof d == "function" && (this.#O = d), typeof y == "function" ? (this.#w = y, this.#r = []) : (this.#w = void 0, this.#r = void 0), this.#T = !!this.#S, this.#x = !!this.#O, this.#f = !!this.#w, this.noDisposeOnSet = !!_, this.noUpdateTTL = !!c, this.noDeleteOnFetchRejection = !!F, this.allowStaleOnFetchRejection = !!p, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z, this.maxEntrySize !== 0) {
+			if (this.#c !== 0 && !T(this.#c)) throw new TypeError("maxSize must be a positive integer if specified");
+			if (!T(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+			this.#X();
+		}
+		if (this.allowStale = !!a, this.noDeleteOnStaleGet = !!m, this.updateAgeOnGet = !!r, this.updateAgeOnHas = !!h, this.ttlResolution = T(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
+			if (!T(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+			this.#k();
+		}
+		if (this.#o === 0 && this.ttl === 0 && this.#c === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+		if (!this.ttlAutopurge && !this.#o && !this.#c) {
+			let x = "LRU_CACHE_UNBOUNDED";
+			k(x) && (j.add(x), P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", x, u));
+		}
+	}
+	getRemainingTTL(e) {
+		return this.#s.has(e) ? Infinity : 0;
+	}
+	#k() {
+		let e = new O(this.#o), t = new O(this.#o);
+		this.#d = e, this.#F = t;
+		let i = this.ttlAutopurge ? Array.from({ length: this.#o }) : void 0;
+		this.#g = i, this.#H = (h, a, o = this.#m.now()) => {
+			t[h] = a !== 0 ? o : 0, e[h] = a, s(h, a);
+		}, this.#D = (h) => {
+			t[h] = e[h] !== 0 ? this.#m.now() : 0, s(h, e[h]);
+		};
+		let s = this.ttlAutopurge ? (h, a) => {
+			if (i?.[h] && (clearTimeout(i[h]), i[h] = void 0), a && a !== 0 && i) {
+				let o = setTimeout(() => {
+					this.#p(h) && this.#E(this.#i[h], "expire");
+				}, a + 1);
+				o.unref && o.unref(), i[h] = o;
+			}
+		} : () => {};
+		this.#v = (h, a) => {
+			if (e[a]) {
+				let o = e[a], d = t[a];
+				if (!o || !d) return;
+				h.ttl = o, h.start = d, h.now = n || r();
+				h.remainingTTL = o - (h.now - d);
+			}
+		};
+		let n = 0, r = () => {
+			let h = this.#m.now();
+			if (this.ttlResolution > 0) {
+				n = h;
+				let a = setTimeout(() => n = 0, this.ttlResolution);
+				a.unref && a.unref();
+			}
+			return h;
+		};
+		this.getRemainingTTL = (h) => {
+			let a = this.#s.get(h);
+			if (a === void 0) return 0;
+			let o = e[a], d = t[a];
+			if (!o || !d) return Infinity;
+			return o - ((n || r()) - d);
+		}, this.#p = (h) => {
+			let a = t[h], o = e[h];
+			return !!o && !!a && (n || r()) - a > o;
+		};
+	}
+	#D = () => {};
+	#v = () => {};
+	#H = () => {};
+	#p = () => !1;
+	#X() {
+		let e = new O(this.#o);
+		this.#b = 0, this.#_ = e, this.#R = (t) => {
+			this.#b -= e[t], e[t] = 0;
+		}, this.#N = (t, i, s, n) => {
+			if (!T(s)) {
+				if (this.#e(i)) return this.backgroundFetchSize;
+				if (n) {
+					if (typeof n != "function") throw new TypeError("sizeCalculation must be a function");
+					if (s = n(i, t), !T(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+				} else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+			}
+			return s;
+		}, this.#j = (t, i, s) => {
+			if (e[t] = i, this.#c) {
+				let n = this.#c - e[t];
+				for (; this.#b > n;) this.#G(!0);
+			}
+			this.#b += e[t], s && (s.entrySize = i, s.totalCalculatedSize = this.#b);
+		};
+	}
+	#R = (e) => {};
+	#j = (e, t, i) => {};
+	#N = (e, t, i, s) => {
+		if (i || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+		return 0;
+	};
+	*#A({ allowStale: e = this.allowStale } = {}) {
+		if (this.#n) for (let t = this.#h; this.#V(t) && ((e || !this.#p(t)) && (yield t), t !== this.#a);) t = this.#u[t];
+	}
+	*#z({ allowStale: e = this.allowStale } = {}) {
+		if (this.#n) for (let t = this.#a; this.#V(t) && ((e || !this.#p(t)) && (yield t), t !== this.#h);) t = this.#l[t];
+	}
+	#V(e) {
+		return e !== void 0 && this.#s.get(this.#i[e]) === e;
+	}
+	*entries() {
+		for (let e of this.#A()) this.#t[e] !== void 0 && this.#i[e] !== void 0 && !this.#e(this.#t[e]) && (yield [this.#i[e], this.#t[e]]);
+	}
+	*rentries() {
+		for (let e of this.#z()) this.#t[e] !== void 0 && this.#i[e] !== void 0 && !this.#e(this.#t[e]) && (yield [this.#i[e], this.#t[e]]);
+	}
+	*keys() {
+		for (let e of this.#A()) {
+			let t = this.#i[e];
+			t !== void 0 && !this.#e(this.#t[e]) && (yield t);
+		}
+	}
+	*rkeys() {
+		for (let e of this.#z()) {
+			let t = this.#i[e];
+			t !== void 0 && !this.#e(this.#t[e]) && (yield t);
+		}
+	}
+	*values() {
+		for (let e of this.#A()) this.#t[e] !== void 0 && !this.#e(this.#t[e]) && (yield this.#t[e]);
+	}
+	*rvalues() {
+		for (let e of this.#z()) this.#t[e] !== void 0 && !this.#e(this.#t[e]) && (yield this.#t[e]);
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	[Symbol.toStringTag] = "LRUCache";
+	find(e, t = {}) {
+		for (let i of this.#A()) {
+			let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+			if (n !== void 0 && e(n, this.#i[i], this)) return this.#C(this.#i[i], t);
+		}
+	}
+	forEach(e, t = this) {
+		for (let i of this.#A()) {
+			let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+			n !== void 0 && e.call(t, n, this.#i[i], this);
+		}
+	}
+	rforEach(e, t = this) {
+		for (let i of this.#z()) {
+			let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+			n !== void 0 && e.call(t, n, this.#i[i], this);
+		}
+	}
+	purgeStale() {
+		let e = !1;
+		for (let t of this.#z({ allowStale: !0 })) this.#p(t) && (this.#E(this.#i[t], "expire"), e = !0);
+		return e;
+	}
+	info(e) {
+		let t = this.#s.get(e);
+		if (t === void 0) return;
+		let i = this.#t[t], s = this.#e(i) ? i.__staleWhileFetching : i;
+		if (s === void 0) return;
+		let n = { value: s };
+		if (this.#d && this.#F) {
+			let r = this.#d[t], h = this.#F[t];
+			if (r && h) n.ttl = r - (this.#m.now() - h), n.start = Date.now();
+		}
+		return this.#_ && (n.size = this.#_[t]), n;
+	}
+	dump() {
+		let e = [];
+		for (let t of this.#A({ allowStale: !0 })) {
+			let i = this.#i[t], s = this.#t[t], n = this.#e(s) ? s.__staleWhileFetching : s;
+			if (n === void 0 || i === void 0) continue;
+			let r = { value: n };
+			if (this.#d && this.#F) {
+				r.ttl = this.#d[t];
+				let h = this.#m.now() - this.#F[t];
+				r.start = Math.floor(Date.now() - h);
+			}
+			this.#_ && (r.size = this.#_[t]), e.unshift([i, r]);
+		}
+		return e;
+	}
+	load(e) {
+		this.clear();
+		for (let [t, i] of e) {
+			if (i.start) {
+				let s = Date.now() - i.start;
+				i.start = this.#m.now() - s;
+			}
+			this.#W(t, i.value, i);
+		}
+	}
+	set(e, t, i = {}) {
+		let { status: s = S.hasSubscribers ? {} : void 0 } = i;
+		i.status = s, s && (s.op = "set", s.key = e, t !== void 0 && (s.value = t), s.cache = this);
+		let n = this.#W(e, t, i);
+		return s && S.hasSubscribers && S.publish(s), n;
+	}
+	#W(e, t, i, s) {
+		let { ttl: n = this.ttl, start: r, noDisposeOnSet: h = this.noDisposeOnSet, sizeCalculation: a = this.sizeCalculation, status: o } = i, d = this.#e(t);
+		if (t === void 0) return o && (o.set = "deleted"), this.delete(e), this;
+		let { noUpdateTTL: y = this.noUpdateTTL } = i;
+		o && !d && (o.value = t);
+		let _ = this.#N(e, t, i.size || 0, a, o);
+		if (this.maxEntrySize && _ > this.maxEntrySize) return this.#E(e, "set"), o && (o.set = "miss", o.maxEntrySizeExceeded = !0), this;
+		let c = this.#n === 0 ? void 0 : this.#s.get(e);
+		if (c === void 0) c = this.#n === 0 ? this.#h : this.#y.length !== 0 ? this.#y.pop() : this.#n === this.#o ? this.#G(!1) : this.#n, this.#i[c] = e, this.#t[c] = t, this.#s.set(e, c), this.#l[this.#h] = c, this.#u[c] = this.#h, this.#h = c, this.#n++, this.#j(c, _, o), o && (o.set = "add"), y = !1, this.#x && !d && this.#O?.(t, e, "add");
+		else {
+			this.#L(c);
+			let g = this.#t[c];
+			if (t !== g) {
+				if (!h) if (this.#e(g)) {
+					g !== s && g.__abortController.abort(/* @__PURE__ */ new Error("replaced"));
+					let { __staleWhileFetching: f } = g;
+					f !== void 0 && f !== t && (this.#T && this.#S?.(f, e, "set"), this.#f && this.#r?.push([
+						f,
+						e,
+						"set"
+					]));
+				} else this.#T && this.#S?.(g, e, "set"), this.#f && this.#r?.push([
+					g,
+					e,
+					"set"
+				]);
+				if (this.#R(c), this.#j(c, _, o), this.#t[c] = t, !d) {
+					let f = g && this.#e(g) ? g.__staleWhileFetching : g, b = f === void 0 ? "add" : t !== f ? "replace" : "update";
+					o && (o.set = b, f !== void 0 && (o.oldValue = f)), this.#x && this.onInsert?.(t, e, b);
+				}
+			} else d || (o && (o.set = "update"), this.#x && this.onInsert?.(t, e, "update"));
+		}
+		if (n !== 0 && !this.#d && this.#k(), this.#d && (y || this.#H(c, n, r), o && this.#v(o, c)), !h && this.#f && this.#r) {
+			let g = this.#r, f;
+			for (; f = g?.shift();) this.#w?.(...f);
+		}
+		return this;
+	}
+	pop() {
+		try {
+			for (; this.#n;) {
+				let e = this.#t[this.#a];
+				if (this.#G(!0), this.#e(e)) {
+					if (e.__staleWhileFetching) return e.__staleWhileFetching;
+				} else if (e !== void 0) return e;
+			}
+		} finally {
+			if (this.#f && this.#r) {
+				let e = this.#r, t;
+				for (; t = e?.shift();) this.#w?.(...t);
+			}
+		}
+	}
+	#G(e) {
+		let t = this.#a, i = this.#i[t], s = this.#t[t], n = this.#e(s);
+		n && s.__abortController.abort(/* @__PURE__ */ new Error("evicted"));
+		let r = n ? s.__staleWhileFetching : s;
+		return (this.#T || this.#f) && r !== void 0 && (this.#T && this.#S?.(r, i, "evict"), this.#f && this.#r?.push([
+			r,
+			i,
+			"evict"
+		])), this.#R(t), this.#g?.[t] && (clearTimeout(this.#g[t]), this.#g[t] = void 0), e && (this.#i[t] = void 0, this.#t[t] = void 0, this.#y.push(t)), this.#n === 1 ? (this.#a = this.#h = 0, this.#y.length = 0) : this.#a = this.#l[t], this.#s.delete(i), this.#n--, t;
+	}
+	has(e, t = {}) {
+		let { status: i = S.hasSubscribers ? {} : void 0 } = t;
+		t.status = i, i && (i.op = "has", i.key = e, i.cache = this);
+		let s = this.#Y(e, t);
+		return S.hasSubscribers && S.publish(i), s;
+	}
+	#Y(e, t = {}) {
+		let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = t, n = this.#s.get(e);
+		if (n !== void 0) {
+			let r = this.#t[n];
+			if (this.#e(r) && r.__staleWhileFetching === void 0) return !1;
+			if (this.#p(n)) s && (s.has = "stale", this.#v(s, n));
+			else return i && this.#D(n), s && (s.has = "hit", this.#v(s, n)), !0;
+		} else s && (s.has = "miss");
+		return !1;
+	}
+	peek(e, t = {}) {
+		let { status: i = D() ? {} : void 0 } = t;
+		i && (i.op = "peek", i.key = e, i.cache = this), t.status = i;
+		let s = this.#J(e, t);
+		return S.hasSubscribers && S.publish(i), s;
+	}
+	#J(e, t) {
+		let { status: i, allowStale: s = this.allowStale } = t, n = this.#s.get(e);
+		if (n === void 0 || !s && this.#p(n)) {
+			i && (i.peek = n === void 0 ? "miss" : "stale");
+			return;
+		}
+		let r = this.#t[n], h = this.#e(r) ? r.__staleWhileFetching : r;
+		return i && (h !== void 0 ? (i.peek = "hit", i.value = h) : i.peek = "miss"), h;
+	}
+	#P(e, t, i, s) {
+		let n = t === void 0 ? void 0 : this.#t[t];
+		if (this.#e(n)) return n;
+		let r = new AbortController(), { signal: h } = i;
+		h?.addEventListener("abort", () => r.abort(h.reason), { signal: r.signal });
+		let a = {
+			signal: r.signal,
+			options: i,
+			context: s
+		}, o = (f, b = !1) => {
+			let { aborted: l } = r.signal, w = i.ignoreFetchAbort && f !== void 0, F = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && f !== void 0);
+			if (i.status && (l && !b ? (i.status.fetchAborted = !0, i.status.fetchError = r.signal.reason, w && (i.status.fetchAbortIgnored = !0)) : i.status.fetchResolved = !0), l && !w && !b) return y(r.signal.reason, F);
+			let m = c, p = this.#t[t];
+			return (p === c || p === void 0 && w && b) && (f === void 0 ? m.__staleWhileFetching !== void 0 ? this.#t[t] = m.__staleWhileFetching : this.#E(e, "fetch") : (i.status && (i.status.fetchUpdated = !0), this.#W(e, f, a.options, m))), f;
+		}, d = (f) => (i.status && (i.status.fetchRejected = !0, i.status.fetchError = f), y(f, !1)), y = (f, b) => {
+			let { aborted: l } = r.signal, w = l && i.allowStaleOnFetchAbort, F = w || i.allowStaleOnFetchRejection, m = F || i.noDeleteOnFetchRejection, p = c;
+			if (this.#t[t] === c && (!m || !b && p.__staleWhileFetching === void 0 ? this.#E(e, "fetch") : w || (this.#t[t] = p.__staleWhileFetching)), F) return i.status && p.__staleWhileFetching !== void 0 && (i.status.returnedStale = !0), p.__staleWhileFetching;
+			if (p.__returned === p) throw f;
+		}, _ = (f, b) => {
+			let l = this.#M?.(e, n, a);
+			r.signal.addEventListener("abort", () => {
+				(!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (f(void 0), i.allowStaleOnFetchAbort && (f = (w) => o(w, !0)));
+			}), l && l instanceof Promise ? l.then((w) => f(w === void 0 ? void 0 : w), b) : l !== void 0 && f(l);
+		};
+		i.status && (i.status.fetchDispatched = !0);
+		let c = new Promise(_).then(o, d), g = Object.assign(c, {
+			__abortController: r,
+			__staleWhileFetching: n,
+			__returned: void 0
+		});
+		return t === void 0 ? (this.#W(e, g, {
+			...a.options,
+			status: void 0
+		}), t = this.#s.get(e)) : this.#t[t] = g, g;
+	}
+	#e(e) {
+		if (!this.#U) return !1;
+		let t = e;
+		return !!t && t instanceof Promise && t.hasOwnProperty("__staleWhileFetching") && t.__abortController instanceof AbortController;
+	}
+	fetch(e, t = {}) {
+		let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t;
+		t.status = s, s && t.context && (s.context = t.context);
+		let n = this.#B(e, t);
+		return s && i && (s.trace = !0, W.tracePromise(() => n, s).catch(() => {})), n;
+	}
+	async #B(e, t = {}) {
+		let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: r = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: a = 0, sizeCalculation: o = this.sizeCalculation, noUpdateTTL: d = this.noUpdateTTL, noDeleteOnFetchRejection: y = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: _ = this.allowStaleOnFetchRejection, ignoreFetchAbort: c = this.ignoreFetchAbort, allowStaleOnFetchAbort: g = this.allowStaleOnFetchAbort, context: f, forceRefresh: b = !1, status: l, signal: w } = t;
+		if (l && (l.op = "fetch", l.key = e, b && (l.forceRefresh = !0), l.cache = this), !this.#U) return l && (l.fetch = "get"), this.#C(e, {
+			allowStale: i,
+			updateAgeOnGet: s,
+			noDeleteOnStaleGet: n,
+			status: l
+		});
+		let F = {
+			allowStale: i,
+			updateAgeOnGet: s,
+			noDeleteOnStaleGet: n,
+			ttl: r,
+			noDisposeOnSet: h,
+			size: a,
+			sizeCalculation: o,
+			noUpdateTTL: d,
+			noDeleteOnFetchRejection: y,
+			allowStaleOnFetchRejection: _,
+			allowStaleOnFetchAbort: g,
+			ignoreFetchAbort: c,
+			status: l,
+			signal: w
+		}, m = this.#s.get(e);
+		if (m === void 0) {
+			l && (l.fetch = "miss");
+			let p = this.#P(e, m, F, f);
+			return p.__returned = p;
+		} else {
+			let p = this.#t[m];
+			if (this.#e(p)) {
+				let v = i && p.__staleWhileFetching !== void 0;
+				return l && (l.fetch = "inflight", v && (l.returnedStale = !0)), v ? p.__staleWhileFetching : p.__returned = p;
+			}
+			let A = this.#p(m);
+			if (!b && !A) return l && (l.fetch = "hit"), this.#L(m), s && this.#D(m), l && this.#v(l, m), p;
+			let z = this.#P(e, m, F, f), E = z.__staleWhileFetching !== void 0 && i;
+			return l && (l.fetch = A ? "stale" : "refresh", E && A && (l.returnedStale = !0)), E ? z.__staleWhileFetching : z.__returned = z;
+		}
+	}
+	forceFetch(e, t = {}) {
+		let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t;
+		t.status = s, s && t.context && (s.context = t.context);
+		let n = this.#K(e, t);
+		return s && i && (s.trace = !0, W.tracePromise(() => n, s).catch(() => {})), n;
+	}
+	async #K(e, t = {}) {
+		let i = await this.#B(e, t);
+		if (i === void 0) throw new Error("fetch() returned undefined");
+		return i;
+	}
+	memo(e, t = {}) {
+		let { status: i = S.hasSubscribers ? {} : void 0 } = t;
+		t.status = i, i && (i.op = "memo", i.key = e, t.context && (i.context = t.context), i.cache = this);
+		let s = this.#Q(e, t);
+		return i && (i.value = s), S.hasSubscribers && S.publish(i), s;
+	}
+	#Q(e, t = {}) {
+		let i = this.#I;
+		if (!i) throw new Error("no memoMethod provided to constructor");
+		let { context: s, status: n, forceRefresh: r, ...h } = t;
+		n && r && (n.forceRefresh = !0);
+		let a = this.#C(e, h), o = r || a === void 0;
+		if (n && (n.memo = o ? "miss" : "hit", o || (n.value = a)), !o) return a;
+		let d = i(e, a, {
+			options: h,
+			context: s
+		});
+		return n && (n.value = d), this.#W(e, d, h), d;
+	}
+	get(e, t = {}) {
+		let { status: i = S.hasSubscribers ? {} : void 0 } = t;
+		t.status = i, i && (i.op = "get", i.key = e, i.cache = this);
+		let s = this.#C(e, t);
+		return i && (s !== void 0 && (i.value = s), S.hasSubscribers && S.publish(i)), s;
+	}
+	#C(e, t = {}) {
+		let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: r } = t, h = this.#s.get(e);
+		if (h === void 0) {
+			r && (r.get = "miss");
+			return;
+		}
+		let a = this.#t[h], o = this.#e(a);
+		return r && this.#v(r, h), this.#p(h) ? o ? (r && (r.get = "stale-fetching"), i && a.__staleWhileFetching !== void 0 ? (r && (r.returnedStale = !0), a.__staleWhileFetching) : void 0) : (n || this.#E(e, "expire"), r && (r.get = "stale"), i ? (r && (r.returnedStale = !0), a) : void 0) : (r && (r.get = o ? "fetching" : "hit"), this.#L(h), s && this.#D(h), o ? a.__staleWhileFetching : a);
+	}
+	#$(e, t) {
+		this.#u[t] = e, this.#l[e] = t;
+	}
+	#L(e) {
+		e !== this.#h && (e === this.#a ? this.#a = this.#l[e] : this.#$(this.#u[e], this.#l[e]), this.#$(this.#h, e), this.#h = e);
+	}
+	delete(e) {
+		return this.#E(e, "delete");
+	}
+	#E(e, t) {
+		S.hasSubscribers && S.publish({
+			op: "delete",
+			delete: t,
+			key: e,
+			cache: this
+		});
+		let i = !1;
+		if (this.#n !== 0) {
+			let s = this.#s.get(e);
+			if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i = !0, this.#n === 1) this.#q(t);
+			else {
+				this.#R(s);
+				let n = this.#t[s];
+				if (this.#e(n) ? n.__abortController.abort(/* @__PURE__ */ new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#S?.(n, e, t), this.#f && this.#r?.push([
+					n,
+					e,
+					t
+				])), this.#s.delete(e), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#u[s];
+				else if (s === this.#a) this.#a = this.#l[s];
+				else {
+					let r = this.#u[s];
+					this.#l[r] = this.#l[s];
+					let h = this.#l[s];
+					this.#u[h] = this.#u[s];
+				}
+				this.#n--, this.#y.push(s);
+			}
+		}
+		if (this.#f && this.#r?.length) {
+			let s = this.#r, n;
+			for (; n = s?.shift();) this.#w?.(...n);
+		}
+		return i;
+	}
+	clear() {
+		return this.#q("delete");
+	}
+	#q(e) {
+		for (let t of this.#z({ allowStale: !0 })) {
+			let i = this.#t[t];
+			if (this.#e(i)) i.__abortController.abort(/* @__PURE__ */ new Error("deleted"));
+			else {
+				let s = this.#i[t];
+				this.#T && this.#S?.(i, s, e), this.#f && this.#r?.push([
+					i,
+					s,
+					e
+				]);
+			}
+		}
+		if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#F) {
+			this.#d.fill(0), this.#F.fill(0);
+			for (let t of this.#g ?? []) t !== void 0 && clearTimeout(t);
+			this.#g?.fill(void 0);
+		}
+		if (this.#_ && this.#_.fill(0), this.#a = 0, this.#h = 0, this.#y.length = 0, this.#b = 0, this.#n = 0, this.#f && this.#r) {
+			let t = this.#r, i;
+			for (; i = t?.shift();) this.#w?.(...i);
+		}
+	}
+};
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/columns/column_providers/providers.js
+/**
+* Unified memoised factory dispatching to the right provider flavour by the
+* source shape:
+* - `TreeNodeAccessor` → {@link AccessorColumnsProvider}
+*   (indexed by `root.handle`, walks the accessor tree once per root).
+* - `UpstreamBlockCtx<AccessorHandle>[]` (or omitted — pulled from the
+*   ambient ctx) → {@link ResultPoolColumnsProvider}
+*   (indexed by a content-hash of the block list).
+*
+* Both branches return cached instances within their LRU window, so repeated
+* calls with the same source skip re-walking / re-hashing.
+*/
+function ColumnsProvider(source) {
+	if (isNil(source) || Array.isArray(source)) return ResultPoolColumnsProvider(source);
+	else if (source instanceof TreeNodeAccessor) return AccessorColumnsProvider(source);
+	else throw new Error("Unknown columns provider source");
+}
+/**
+* Memoised constructor — same `root.handle` returns the same
+* {@link AccessorColumnsProviderImpl}, so `indexAccessorRoot` runs once per
+* accessor root (within the LRU window).
+*/
+const _accessorProviderCache = new U({ max: 64 });
+function AccessorColumnsProvider(root) {
+	let provider = _accessorProviderCache.get(root.handle);
+	if (provider === void 0) {
+		provider = new AccessorColumnsProviderImpl(root);
+		_accessorProviderCache.set(root.handle, provider);
+	}
+	return provider;
+}
+/**
+* Memoised constructor — same `rawPool` content returns the same
+* {@link ResultPoolColumnsProviderImpl}, so `indexPoolBlock` runs once per
+* pool snapshot (within the LRU window).
+*/
+const _resultPoolProviderCache = new U({ max: 4 });
+function ResultPoolColumnsProvider(rawPool = getCfgRenderCtx().getUpstreamBlockCtx()) {
+	const key = hashRawPool(rawPool);
+	let provider = _resultPoolProviderCache.get(key);
+	if (provider === void 0) {
+		provider = new ResultPoolColumnsProviderImpl(rawPool);
+		_resultPoolProviderCache.set(key, provider);
+	}
+	return provider;
+}
+/**
+* Sandbox-specific provider over a {@link TreeNodeAccessor} root. Uses the
+* accessor's own `resolvePath` as the canonical root path for id construction,
+* and adds `getColumns()` returning {@link ColumnLazy}s on top of the generic
+* entries index.
+*/
+var AccessorColumnsProviderImpl = class extends AccessorEntriesProvider {
+	cachedColumns;
+	constructor(root) {
+		super(root, root.resolvePath);
+	}
+	getColumns() {
+		if (this.cachedColumns !== void 0) return this.cachedColumns;
+		return this.cachedColumns = Array.from(this.entries.values()).map((e) => ColumnLazyImpl.fromAccessor(e)).filter((v) => !isNil(v));
+	}
+};
+/**
+* Sandbox-specific result-pool provider. Accepts the raw handle-shaped blocks
+* returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx} and
+* wraps them into {@link TreeNodeAccessor}s, then adds `getColumns()`.
+*/
+var ResultPoolColumnsProviderImpl = class extends ResultPoolEntriesProvider {
+	cachedColumns;
+	constructor(rawPool = getCfgRenderCtx().getUpstreamBlockCtx()) {
+		const blocks = rawPool.map((b) => ({
+			blockId: b.blockId,
+			prodCtx: b.prodCtx !== void 0 ? new TreeNodeAccessor(b.prodCtx, [b.blockId, "prodCtx"]) : void 0,
+			stagingCtx: b.stagingCtx !== void 0 ? new TreeNodeAccessor(b.stagingCtx, [b.blockId, "stagingCtx"]) : void 0,
+			prodIncomplete: b.prodIncomplete,
+			stagingIncomplete: b.stagingIncomplete
+		}));
+		super(blocks);
+	}
+	getColumns() {
+		if (this.cachedColumns !== void 0) return this.cachedColumns;
+		return this.cachedColumns = Array.from(this.getPObjectEntries().values()).map((e) => ColumnLazyImpl.fromAccessor(e)).filter((v) => !isNil(v));
+	}
+};
+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.80.2/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)
+*  - `AccessorColumnsProvider` over `prerun`  (if present)
+*  - `ResultPoolColumnsProvider` over `rawResultPool`
+*
+* Pulls handles directly from the ambient `cfgRenderCtx`. Returns `[]` when
+* called outside a render context.
+*
+* Result is memoised per-ctx (WeakMap → array). Repeated calls within the
+* same render cycle return the same provider triplet — inner providers are
+* also LRU-memoised by their content keys, so even a cache miss here doesn't
+* re-walk the trees.
+*/
+const _ctxProvidersCache = /* @__PURE__ */ new WeakMap();
+function getCtxProviders(deps) {
+	const ctx = deps?.ctx ?? getCfgRenderCtx();
+	const cached = _ctxProvidersCache.get(ctx);
+	if (cached !== void 0) return cached;
+	const providers = [];
+	const outputs = ctx.getAccessorHandleByName(MainAccessorName);
+	if (outputs !== void 0) providers.push(ColumnsProvider(new TreeNodeAccessor(outputs, [MainAccessorName])));
+	const prerun = ctx.getAccessorHandleByName(StagingAccessorName);
+	if (prerun !== void 0) providers.push(ColumnsProvider(new TreeNodeAccessor(prerun, [StagingAccessorName])));
+	providers.push(ColumnsProvider(ctx.getUpstreamBlockCtx()));
+	_ctxProvidersCache.set(ctx, providers);
+	return providers;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/columns/column_lazy.js
+/**
+* Thrown by leaf-recipe factories when the requested column is provably
+* absent in the active render ctx — i.e. every relevant accessor reports
+* `inputsLocked` and the column did not appear. Distinct from the
+* `undefined` return that the factories still use for the "resolving" case
+* (the column may still appear later).
+*
+* Catch at the boundary (resolver / filter+sort wiring / data-table assembly)
+* when partial absence should be surfaced to the user rather than silently
+* producing an empty result.
+*/
+var ColumnAbsentError = class extends Error {
+	id;
+	constructor(id) {
+		super(`Column is absent in the active render ctx and will not appear: ${id}`);
+		this.id = id;
+		this.name = "ColumnAbsentError";
+	}
+};
+/**
+* ColumnLazy is the leaf-recipe building block: a {@link ColumnRecipe} whose
+* `id` is a bare {@link PObjectId} and whose readers are bound to a single
+* tree-accessor leaf. Layered encodings (Overridden / Discovered / Filtered)
+* are reified through their dedicated recipe classes and reference leaf
+* columns by id.
+*/
+var ColumnLazyImpl = class ColumnLazyImpl {
+	id;
+	options;
+	specCache;
+	dataCache;
+	dataStatusCache;
+	constructor(id, options) {
+		this.id = id;
+		this.options = options;
+	}
+	/** A leaf-recipe references exactly one column — its own id. */
+	getReferencedIds() {
+		return [this.id];
+	}
+	getSpec() {
+		if (this.specCache === void 0) this.specCache = { value: this.options.getSpec() };
+		return this.specCache.value;
+	}
+	/** Leaf-shaped — points straight at `this.id`. */
+	getQuery() {
+		return {
+			type: "column",
+			column: this.id
+		};
+	}
+	/** Leaf-only: not on the recipe interface — only the leaf can read data directly. */
+	getData() {
+		if (this.dataCache === void 0) this.dataCache = { value: this.options.getData() };
+		return this.dataCache.value;
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: this.options.getDataStatus() };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Overlay overrides → produces a {@link ColumnOverriddenRecipe} wrapping
+	* this leaf. ColumnLazy itself stays bare (id remains a plain PObjectId);
+	* layering lives entirely in the recipe wrappers.
+	*/
+	withSpecs(overrides) {
+		return ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+	/**
+	* Resolve via the ambient {@link ColumnRegistry}. Spec is resolved eagerly:
+	* returns `undefined` if the leaf isn't reachable yet (resolving). Throws
+	* {@link ColumnAbsentError} when every relevant accessor is `inputsLocked`
+	* and the column did not appear — the column will not exist in this ctx.
+	* Data and dataStatus stay lazy.
+	*/
+	static fromId(id, { ctx } = {}) {
+		const registry = new ColumnRegistry(getCtxProviders({ ctx }));
+		const leaf = registry.resolve(id);
+		if (isNil(leaf)) {
+			if (registry.isFinal()) throw new ColumnAbsentError(id);
+			return;
+		}
+		const spec = readSpecAccessor(leaf);
+		if (isNil(spec)) {
+			if (leaf.accessor.getInputsLocked()) throw new ColumnAbsentError(id);
+			return;
+		}
+		if (!spec.hasData()) return void 0;
+		return new ColumnLazyImpl(id, {
+			getSpec: () => spec.getDataAsJson(),
+			getData: () => readDataAccessor(leaf),
+			getDataStatus: () => readDataStatus(leaf)
+		});
+	}
+	/** {@link PlRef} wrapper over {@link fromId}. */
+	static fromPlRef(ref) {
+		return ColumnLazyImpl.fromId(createGlobalPObjectId(ref.blockId, ref.name));
+	}
+	/**
+	* Bind directly to an accessor-backed {@link LeafEntry} — no registry.
+	* Throws {@link ColumnAbsentError} if the leaf has no spec field and its
+	* accessor is `inputsLocked`. Returns `undefined` while still resolving.
+	*/
+	static fromAccessor(entry) {
+		const spec = readSpecAccessor(entry);
+		if (isNil(spec)) {
+			if (entry.accessor.getInputsLocked()) throw new ColumnAbsentError(entry.id);
+			return;
+		}
+		if (!spec.hasData()) return void 0;
+		return new ColumnLazyImpl(entry.id, {
+			getSpec: () => spec.getDataAsJson(),
+			getData: () => readDataAccessor(entry),
+			getDataStatus: () => readDataStatus(entry)
+		});
+	}
+	/**
+	* Wrap a materialised {@link PColumn}. If the input is already a
+	* {@link ColumnLazy} it is returned as-is.
+	*/
+	static fromColumn(column) {
+		if (column instanceof ColumnLazyImpl) return column;
+		return new ColumnLazyImpl(column.id, {
+			getSpec: () => column.spec,
+			getData: () => column.data,
+			getDataStatus: () => "present"
+		});
+	}
+	/**
+	* Distinguishes `present` / `resolving` / `absent` for a {@link PObjectId}
+	* in the active render ctx. Falls back to the registry's `isFinal()`
+	* when the id has no entry — only then we can say `absent` instead of
+	* `resolving`.
+	*/
+	static getStatusById(id, { ctx } = {}) {
+		const registry = new ColumnRegistry(getCtxProviders({ ctx }));
+		const leaf = registry.resolve(id);
+		if (isNil(leaf)) return registry.isFinal() ? "absent" : "resolving";
+		return getLeafEntryStatus(leaf);
+	}
+	/** {@link PlRef} wrapper over {@link getStatusById}. */
+	static getStatusByPlRef(ref, opts = {}) {
+		return ColumnLazyImpl.getStatusById(createGlobalPObjectId(ref.blockId, ref.name), opts);
+	}
+	/** No registry — reads straight off the entry's accessor. */
+	static getStatusByAccessor(entry) {
+		return getLeafEntryStatus(entry);
+	}
+};
+/**
+* Unified dispatcher — picks the right `ColumnLazyImpl.fromX` by source
+* shape. For ambiguous inputs callers can still use the explicit factories
+* (also attached as properties: `ColumnLazy.fromId`, `.fromPlRef`,
+* `.fromAccessor`, `.fromColumn`).
+*/
+function ColumnLazyDispatch(source, opts = {}) {
+	if (typeof source === "string") return ColumnLazyImpl.fromId(source, opts);
+	if (source instanceof ColumnLazyImpl) return source;
+	if ("accessor" in source) return ColumnLazyImpl.fromAccessor(source);
+	if (isPlRef(source)) return ColumnLazyImpl.fromPlRef(source);
+	if (isPColumn(source)) return ColumnLazyImpl.fromColumn(source);
+	throw new Error("ColumnLazy: unknown source shape");
+}
+/**
+* Polymorphic counterpart to {@link ColumnLazyDispatch}: returns the
+* {@link ColumnResolutionStatus} for any factory input without constructing
+* the recipe. For already-materialised sources ({@link PColumn} value,
+* existing {@link ColumnLazy}) status is `present` by construction.
+*/
+function ColumnLazyGetStatus(source, opts = {}) {
+	if (typeof source === "string") return ColumnLazyImpl.getStatusById(source, opts);
+	if (source instanceof ColumnLazyImpl) return "present";
+	if ("accessor" in source) return ColumnLazyImpl.getStatusByAccessor(source);
+	if (isPlRef(source)) return ColumnLazyImpl.getStatusByPlRef(source, opts);
+	if (isPColumn(source)) return "present";
+	throw new Error("ColumnLazy.getStatus: unknown source shape");
+}
+const ColumnLazy = Object.assign(ColumnLazyDispatch, {
+	fromId: ColumnLazyImpl.fromId,
+	fromPlRef: ColumnLazyImpl.fromPlRef,
+	fromAccessor: ColumnLazyImpl.fromAccessor,
+	fromColumn: ColumnLazyImpl.fromColumn,
+	getStatus: ColumnLazyGetStatus,
+	getStatusById: ColumnLazyImpl.getStatusById,
+	getStatusByPlRef: ColumnLazyImpl.getStatusByPlRef,
+	getStatusByAccessor: ColumnLazyImpl.getStatusByAccessor
+});
+const readSpecAccessor = memoizeByEntry(({ accessor, name }) => accessor.traverse({
+	field: `${name}.spec`,
+	assertFieldType: "Input",
+	ignoreError: true
+}));
+/**
+* Per-entry counterpart to {@link readDataStatus}: tells whether the leaf's
+* **spec** can be read in this ctx, and — for the negative cases —
+* distinguishes `resolving` from `absent` via `getInputsLocked()`.
+*
+*  - spec field not yet on the entry's accessor + inputs locked → `absent`
+*  - spec field not yet on the entry's accessor + still resolving → `resolving`
+*  - spec resource present but bytes not yet written → `resolving`
+*    (transient — the spec resource is connected, just unfilled)
+*  - spec resource present and `hasData()` → `present`
+*/
+function getLeafEntryStatus(entry) {
+	const spec = readSpecAccessor(entry);
+	if (isNil(spec)) return entry.accessor.getInputsLocked() ? "absent" : "resolving";
+	if (!spec.hasData()) return "resolving";
+	return "present";
+}
+const readDataAccessor = memoizeByEntry(({ accessor, name }) => accessor.traverse({
+	field: `${name}.data`,
+	assertFieldType: "Input",
+	ignoreError: true
+}));
+const readDataStatus = memoizeByEntry(({ accessor, name }) => {
+	if (accessor.listInputFields().includes(`${name}.data`)) return "present";
+	return accessor.getInputsLocked() ? "absent" : "resolving";
+});
+function memoizeByEntry(fn) {
+	const cache = new U({ max: 1e3 });
+	return (entry) => {
+		const key = `${entry.accessor.handle}:${entry.name}`;
+		let hit = cache.get(key);
+		if (!hit) cache.set(key, hit = { value: fn(entry) });
+		return hit.value;
+	};
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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
+* wrappers' inner `source`:
+*
+*   - bare {@link PObjectId} (non-JSON)               → `ColumnLazy.fromId`
+*   - `ColumnDiscoveredKey`                          → {@link ColumnDiscoveredRecipe}
+*   - `ColumnOverriddenKey { source, specOverrides }` → recurse on `source`,
+*                                                       then {@link ColumnOverriddenRecipe.wrap}
+*   - `ColumnFilteredKey { source, axisFilters }`     → recurse on `source`,
+*                                                       then {@link ColumnFilteredRecipe.wrap}
+*
+* Returns `undefined` for unsupported variants (e.g. AnchoredPColumnId,
+* which needs an anchor map to resolve) or when a nested source itself
+* cannot be built.
+*/
+function ColumnRecipeBuild(id, opts = {}) {
+	const parsed = parseColumnIdSafely(id);
+	if (isPObjectKey(parsed)) return ColumnLazyImpl.fromId(id, opts);
+	if (isColumnDiscoveredKey(parsed)) return ColumnDiscoveredRecipe.fromKey(parsed, opts);
+	if (isColumnOverriddenKey(parsed)) {
+		const inner = ColumnRecipe(parsed.source, opts);
+		if (inner === void 0) return void 0;
+		return ColumnOverriddenRecipe.wrap(inner, parsed.specOverrides);
+	}
+	if (isColumnFilteredKey(parsed)) {
+		if (typeof parsed.source !== "string") throw new Error(`Unsupported ColumnRecipe id variant: filtered column with non-string source (${JSON.stringify(parsed.source)})`);
+		const inner = ColumnRecipe(parsed.source, opts);
+		if (inner === void 0) return void 0;
+		return ColumnFilteredRecipe.wrap(inner, parsed.axisFilters);
+	}
+	throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);
+}
+/**
+* Resolution status counterpart to {@link ColumnRecipeBuild}. Dispatches on
+* the parsed id shape to the matching `getStatusBy*` static — never
+* constructs the recipe. Use this at boundaries (resolver, filter/sort
+* targets) to throw early on `absent` instead of silently producing an empty
+* recipe via {@link ColumnRecipeBuild}.
+*/
+function ColumnRecipeGetStatus(id, opts = {}) {
+	const parsed = parseColumnIdSafely(id);
+	if (isPObjectKey(parsed)) return ColumnLazyImpl.getStatusById(id, opts);
+	if (isColumnDiscoveredKey(parsed)) return ColumnDiscoveredRecipe.getStatusByKey(parsed, opts);
+	if (isColumnOverriddenKey(parsed)) return ColumnOverriddenRecipe.getStatusByKey(parsed, opts);
+	if (isColumnFilteredKey(parsed)) return ColumnFilteredRecipe.getStatusByKey(parsed, opts);
+	throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);
+}
+const ColumnRecipe = Object.assign(ColumnRecipeBuild, { getStatus: ColumnRecipeGetStatus });
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/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}
+*   - object source (`PlRef` / `LeafEntry` / `PColumn` / `ColumnLazy`) → {@link ColumnLazy}
+*
+* `ColumnLazy` is itself a `ColumnRecipe<PObjectId>`, so the return type is
+* the common `ColumnRecipe`.
+*/
+function Column(source, opts) {
+	if (typeof source === "string") return ColumnRecipe(source, opts);
+	return ColumnLazy(source, opts);
+}
 (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	exports = module.exports = stringify;
 	exports.getSerialize = serializer;
@@ -8319,8 +10277,7 @@ function migrateV1ToV2(v1) {
 				receptor: "IG"
 			},
 			model: "esm2",
-			fidelity: v1.fidelity,
-			isExpanded: false
+			fidelity: v1.fidelity
 		})),
 		embeddingsInitializedForAnchor: v1.scopesInitializedForAnchor,
 		mem: v1.mem,
@@ -8328,11 +10285,28 @@ function migrateV1ToV2(v1) {
 		defaultBlockLabel: v1.defaultBlockLabel
 	};
 }
-const blockDataModel = new DataModelBuilder().from("Ver_2026_05_29").migrate("Ver_2026_06_23_models", migrateV1ToV2).init(() => ({
-	embeddings: [],
-	mem: 32,
-	cpu: 16
-}));
+/**
+* V2 (per-card model list) → V3 (single selection). The card list collapses to one
+* selection: take the first card (existing projects seeded at least one), dropping
+* the now-unused `id`. Empty list → blank selection (`{}`), so the UI re-seeds a
+* default on the next input connection.
+*/
+function migrateV2ToV3(v2) {
+	const first = v2.embeddings[0];
+	return {
+		inputAnchor: v2.inputAnchor,
+		embedding: first ? {
+			scope: first.scope,
+			model: first.model,
+			fidelity: first.fidelity
+		} : {},
+		embeddingInitializedForAnchor: v2.embeddingsInitializedForAnchor,
+		mem: v2.mem,
+		cpu: v2.cpu,
+		defaultBlockLabel: v2.defaultBlockLabel
+	};
+}
+const blockDataModel = new DataModelBuilder().from("Ver_2026_05_29").migrate("Ver_2026_06_23_models", migrateV1ToV2).migrate("Ver_2026_07_03_single_selection", migrateV2ToV3).init(() => ({ embedding: {} }));
 //#endregion
 //#region ../model/dist/scopes.js
 /**
@@ -8565,31 +10539,22 @@ const inputAnchorSpecs = [
 ];
 const platforma$1 = BlockModelV3.create(blockDataModel).args((data) => {
 	if (data.inputAnchor === void 0) throw new Error("Select an input dataset");
-	if (data.embeddings.length === 0) throw new Error("Add at least one embedding");
-	const tasks = data.embeddings.map((card) => {
-		if (card.scope === void 0) throw new Error("Each embedding needs a sequence selected");
-		if (card.model === void 0) throw new Error("Each embedding needs a model selected");
-		if (!isCompatible(card.scope.feature, card.scope.isHeavy, card.scope.receptor, card.model)) throw new Error(`${card.model} cannot embed "${card.scope.label}"`);
-		return {
-			scope: card.scope,
-			model: card.model,
-			fidelity: card.model === "esm2" ? card.fidelity ?? "standard" : void 0
-		};
-	});
-	const seen = /* @__PURE__ */ new Set();
-	for (const t of tasks) {
-		const key = `${t.scope.id}|${t.model}|${t.fidelity ?? ""}`;
-		if (seen.has(key)) throw new Error(`"${t.scope.label}" is already being embedded with this model — remove the duplicate embedding.`);
-		seen.add(key);
-	}
-	tasks.sort((a, b) => a.scope.id.localeCompare(b.scope.id) || a.model.localeCompare(b.model) || (a.fidelity ?? "").localeCompare(b.fidelity ?? ""));
+	const sel = data.embedding;
+	if (sel.scope === void 0) throw new Error("Select a sequence to embed");
+	if (sel.model === void 0) throw new Error("Select a model");
+	if (!isCompatible(sel.scope.feature, sel.scope.isHeavy, sel.scope.receptor, sel.model)) throw new Error(`${sel.model} cannot embed "${sel.scope.label}"`);
+	const task = {
+		scope: sel.scope,
+		model: sel.model,
+		fidelity: sel.model === "esm2" ? sel.fidelity ?? "standard" : void 0
+	};
 	return {
 		inputAnchor: data.inputAnchor,
-		embeddings: tasks,
+		embeddings: [task],
 		mem: data.mem,
 		cpu: data.cpu
 	};
-}).prerunArgs(() => ({})).output("inputOptions", (ctx) => ctx.resultPool.getOptions(inputAnchorSpecs)).output("inputSpec", (ctx) => ctx.data.inputAnchor ? ctx.resultPool.getPColumnSpecByRef(ctx.data.inputAnchor) : void 0).output("availableScopes", (ctx) => {
+}).prerunArgs(() => ({})).output("inputOptions", (ctx) => ctx.resultPool.getOptions(inputAnchorSpecs)).output("availableScopes", (ctx) => {
 	const ref = ctx.data.inputAnchor;
 	if (ref === void 0) return void 0;
 	const spec = ctx.resultPool.getPColumnSpecByRef(ref);
@@ -8617,7 +10582,14 @@ const platforma$1 = BlockModelV3.create(blockDataModel).args((data) => {
 	field: "gpuAvailable",
 	assertFieldType: "Input",
 	allowPermanentAbsence: true
-})?.getDataAsJson()).title(() => "Sequence Embeddings").subtitle((ctx) => ctx.data.defaultBlockLabel ?? "").sections(() => [{
+})?.getDataAsJson()).title(() => "Sequence Embeddings").subtitle((ctx) => {
+	const parts = [];
+	if (ctx.data.defaultBlockLabel) parts.push(ctx.data.defaultBlockLabel);
+	const sel = ctx.data.embedding;
+	if (sel.scope?.label) parts.push(sel.scope.label);
+	if (sel.model) parts.push(EMBEDDING_MODELS[sel.model].label);
+	return parts.join(" · ");
+}).sections(() => [{
 	type: "link",
 	href: "/",
 	label: "Main"