@platforma-open/milaboratories.mixcr-clonotyping-2 2.21.0 → 2.21.2

package/dist/index.js

@@ -21,14 +21,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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.27/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.
@@ -270,7 +270,7 @@ function getPluginData(rawStorage, handle) {
 	return pluginEntry.__data;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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 {
@@ -765,7 +765,7 @@ var DataModel = class DataModel {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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";
@@ -835,7 +835,7 @@ function registerFutureAwait(handle, onResolve) {
 	futureResolves.get(handle).push(onResolve);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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.
@@ -870,7 +870,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.27/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;
@@ -4471,7 +4471,7 @@ objectType({
 	to: numberType().min(1)
 });
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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);
 }
@@ -4483,7 +4483,7 @@ function uniqueBy(array, makeId) {
 	return [...new Map(array.map((e) => [makeId(e), e])).values()];
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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.
 *
@@ -4674,7 +4674,7 @@ function entriesToDataInfo(dataInfoEntries) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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";
 };
@@ -4698,7 +4698,7 @@ function ensureError(value) {
 	return new Error(stringifyValue(value));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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");
@@ -4731,7 +4731,7 @@ function parseJsonSafely(value, fallback) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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];
 }
@@ -4982,9 +4982,6 @@ const PColumnName = {
 		Sequence: "pl7.app/vdj/sequence"
 	}
 };
-function isLabelColumn(column) {
-	return column.axesSpec.length === 1 && column.name === PColumnName.Label;
-}
 /** Get column id and spec from a column */
 function getColumnIdAndSpec(column) {
 	return {
@@ -5023,7 +5020,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.4/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
 const BOOLEAN_TYPES = /* @__PURE__ */ new Set([
 	"numericComparison",
 	"stringEquals",
@@ -5088,20 +5085,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)
@@ -5112,19 +5112,28 @@ 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);
+}
+/** Collects all column references from a SpecQuery tree. */
+function collectSpecQueryColumns(query) {
+	const result = [];
+	traverseQuerySpec(query, { column: (c) => {
+		result.push(c);
+		return c;
+	} });
+	return result;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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) {
@@ -5159,7 +5168,7 @@ function mapJoinEntry(entry, cb) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.js
 function getPTableColumnId(spec) {
 	switch (spec.type) {
 		case "axis": return {
@@ -5173,17 +5182,366 @@ function getPTableColumnId(spec) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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()];
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.4/node_modules/@milaboratories/helpers/dist/utils.js
+function isNil$1(v) {
+	return v === null || v === void 0;
+}
+Array.isArray;
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Checks if the given value is a plain object.
+*
+* A plain object is defined as an object created by the `{}` literal,
+* an object created with `Object.create(null)`, or an object with a
+* prototype that resolves to `Object.prototype`.
+*
+* @param value - The value to check.
+* @returns `true` if the value is a plain object, otherwise `false`.
+*
+* @example
+* ```typescript
+* isPlainObject({}); // true
+* isPlainObject(Object.create(null)); // true
+* isPlainObject(new Date()); // false
+* isPlainObject(null); // false
+* isPlainObject([]); // false
+* ```
+*/
+function isPlainObject(value) {
+	if (!isObject(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+//#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.42.0/node_modules/es-toolkit/dist/array/uniq.mjs
+function uniq(arr) {
+	return [...new Set(arr)];
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/array/uniqBy.mjs
+function uniqBy(arr, mapper) {
+	const map = /* @__PURE__ */ new Map();
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		const key = mapper(item);
+		if (!map.has(key)) map.set(key, item);
+	}
+	return Array.from(map.values());
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/predicate/isFunction.mjs
+function isFunction(value) {
+	return typeof value === "function";
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/predicate/isNil.mjs
+function isNil(x) {
+	return x == null;
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/predicate/isString.mjs
+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.4/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));
 }
@@ -5429,53 +5787,7 @@ function isAnchorAxisRef(value) {
 	return typeof value === "object" && "anchor" in value;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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.4/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.
 *
@@ -5556,7 +5868,7 @@ function legacyColumnSelectorsToPredicate(predicateOrSelectors) {
 	else return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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,
@@ -5568,19 +5880,7 @@ function deriveNativeId(spec) {
 	return (0, import_canonicalize.default)(result);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.3/node_modules/@milaboratories/helpers/dist/utils.js
-function isNil$1(v) {
-	return v === null || v === void 0;
-}
-Array.isArray;
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.3/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.4/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;
@@ -5758,7 +6058,7 @@ var LinkerMap = class LinkerMap {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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
@@ -5767,7 +6067,7 @@ var LinkerMap = class LinkerMap {
 const REQUIRES_PFRAMES_VERSION = 1001031;
 stringType().length(24).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/node_modules/@milaboratories/pl-model-common/dist/ref.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/ref.js
 const PlRef = objectType({
 	__isRef: literalType(true).describe("Crucial marker for the block dependency tree reconstruction"),
 	blockId: stringType().describe("Upstream block id"),
@@ -5803,7 +6103,7 @@ function withEnrichments(ref, requireEnrichments = true) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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,
@@ -5811,7 +6111,51 @@ function mapValueInVOE(voe, cb) {
 	} : voe;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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();
@@ -5850,7 +6194,7 @@ const { service, isNodeService, isWasmService, isMainService, getServiceKind, ge
 	};
 })();
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.4/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",
@@ -5908,6 +6252,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}`);
@@ -5922,7 +6288,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.4/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)];
@@ -5931,26 +6297,269 @@ function buildMethodMap(pick) {
 buildMethodMap(getServiceUiMethods);
 buildMethodMap(getServiceModelMethods);
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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];
+/**
+* Enumerate column names backing a PFrame accessor — derived from
+* `<name>.spec` field names, without resolving the spec resources.
+*/
+function listColumnNames(accessor, prefix = "") {
+	if (accessor.resourceType.name !== ResourceTypeName.PFrame) return [];
+	const out = [];
+	for (const field of accessor.listInputFields()) {
+		if (!field.endsWith(".spec")) continue;
+		const raw = field.slice(0, -5);
+		if (!raw.startsWith(prefix)) continue;
+		out.push(raw.slice(prefix.length));
+	}
+	return out;
 }
 /**
-* 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).
+* 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 decodeErrorMessage(raw) {
-	try {
-		const parsed = JSON.parse(raw);
-		if (typeof parsed?.message === "string") return parsed.message;
-	} catch {}
-	return raw;
+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;
 }
-/** Represent resource tree node accessor */
-var TreeNodeAccessor = class TreeNodeAccessor {
-	handle;
+/**
+* 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/dedup.js
+/**
+* Two-track dedup over an item stream keyed by `ColumnUniversalId`:
+*
+* - **Raw `PObjectId`s** are deduped by `deriveNativeId(spec)`. The same
+*   physical column reached via outputs vs. result_pool has different
+*   id shapes but identical nativeId — first occurrence wins so the
+*   provider order (outputs before pool) decides which id is canonical.
+* - **Non-`PObjectId` ids** (e.g. `SUniversalPColumnUniversalId`,
+*   `ColumnDiscoveredId`) keep raw-id dedup — they legitimately share
+*   nativeId with siblings.
+*
+* When `getSpec` returns `undefined` for a `PObjectId`, falls back to raw-id
+* dedup (so an unresolvable id still survives instead of dropping silently).
+*
+* Shared by sandbox-side `extractColumns` (column_providers) and host-side
+* `ColumnsCollectionDriverImpl.getColumns` — both layers need identical
+* dedup semantics, but operate on different concrete item types (ColumnLazy
+* vs. raw ColumnUniversalId).
+*/
+function dedupColumns(items, getId, getSpec) {
+	const seenNative = /* @__PURE__ */ new Set();
+	const seenId = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const item of items) {
+		const id = getId(item);
+		if (seenId.has(id)) continue;
+		if (isPObjectId(id)) {
+			const spec = getSpec(item);
+			if (spec !== void 0) {
+				const nativeId = deriveNativeId(spec);
+				if (seenNative.has(nativeId)) continue;
+				seenNative.add(nativeId);
+			}
+		}
+		seenId.add(id);
+		out.push(item);
+	}
+	return out;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.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;
 	constructor(handle, resolvePath) {
 		this.handle = handle;
@@ -5977,7 +6586,7 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 		}));
 		return this.resolveWithCommon({}, ...transformedSteps);
 	}
-	resolveAny(...steps) {
+	traverse(...steps) {
 		return this.resolveWithCommon({}, ...steps);
 	}
 	resolveWithCommon(commonOptions, ...steps) {
@@ -6023,6 +6632,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);
 	}
@@ -6059,9 +6671,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;
@@ -6070,9 +6689,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;
@@ -6083,15 +6700,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
 	*/
@@ -6182,11 +6790,11 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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.27/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;
@@ -6250,22 +6858,7 @@ function filterDataInfoEntries(dataInfoEntries, axisFilters) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/function/identity.mjs
-function identity(x) {
-	return x;
-}
-//#endregion
-//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/predicate/isFunction.mjs
-function isFunction(value) {
-	return typeof value === "function";
-}
-//#endregion
-//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/predicate/isNil.mjs
-function isNil(x) {
-	return x == null;
-}
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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";
@@ -6531,7 +7124,7 @@ function minimizeTypeSet(typeSet, records, stats, forceTraceElements, forcedSet,
 	return result;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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) => ({
@@ -6540,7 +7133,7 @@ function deriveLabels(values, getSpec, options = {}) {
 	}));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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";
@@ -6872,7 +7465,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());
@@ -6883,7 +7476,7 @@ function allPColumnsReady(columns) {
 	return columns.every(isPColumnReady);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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;
@@ -6893,7 +7486,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;
@@ -6945,7 +7538,7 @@ function getSplitAxisIndices(selector) {
 }
 var PColumnCollection = class {
 	defaultProviderStore = [];
-	providers = [new ArrayColumnProvider(this.defaultProviderStore)];
+	providers = [new ArrayColumnsProvider(this.defaultProviderStore)];
 	axisLabelProviders = [];
 	constructor() {}
 	addColumnProvider(provider) {
@@ -7108,7 +7701,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
 			});
 		}
@@ -7144,7 +7739,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;
@@ -7159,7 +7754,7 @@ var PColumnCollection = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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.
@@ -7170,11 +7765,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.27/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.
@@ -7183,10 +7779,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.27/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);
@@ -7197,7 +7793,7 @@ function getService(name) {
 	})();
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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;
@@ -7235,7 +7831,7 @@ function patchInSetFilters(filters) {
 	return filters.map((filter) => mapFilter(filter, inSetToOrEqual));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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
@@ -7250,24 +7846,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));
@@ -7411,7 +8018,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]));
@@ -7492,6 +8098,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);
@@ -7569,20 +8178,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,
@@ -7597,7 +8194,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;
@@ -7614,17 +8211,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();
@@ -7689,27 +8280,27 @@ var PluginRenderCtx = class extends RenderCtxBase {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/version.js
-const PlatformaSDKVersion = "1.79.27";
+//#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.27/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.27/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.27/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.27/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().
 *
@@ -7886,7 +8477,7 @@ function derivePrerunArgsFromStorage(storageJson, argsFunction, prerunArgsFuncti
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/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`
@@ -8143,62 +8734,2320 @@ var BlockModelV3 = class BlockModelV3 {
 			[BlockStorageFacadeCallbacks.ArgsDerive]: (storageJson) => deriveArgsFromStorage(storageJson, argsFunction),
 			[BlockStorageFacadeCallbacks.PrerunArgsDerive]: (storageJson) => derivePrerunArgsFromStorage(storageJson, argsFunction, prerunArgsFunction)
 		});
-		const pluginOutputs = {};
-		for (const handle of pluginHandles) {
-			const { model, inputs } = plugins[handle];
-			const wrappedInputs = {};
-			for (const [paramKey, paramFn] of Object.entries(inputs)) wrappedInputs[paramKey] = () => paramFn(new BlockRenderCtx());
-			const outputs = model.outputs;
-			for (const [outputKey, outputFn] of Object.entries(outputs)) {
-				const key = pluginOutputKey(handle, outputKey);
-				pluginOutputs[key] = createAndRegisterRenderLambda({
-					handle: key,
-					lambda: () => outputFn(new PluginRenderCtx(handle, wrappedInputs)),
-					withStatus: true
-				});
-			}
+		const pluginOutputs = {};
+		for (const handle of pluginHandles) {
+			const { model, inputs } = plugins[handle];
+			const wrappedInputs = {};
+			for (const [paramKey, paramFn] of Object.entries(inputs)) wrappedInputs[paramKey] = () => paramFn(new BlockRenderCtx());
+			const outputs = model.outputs;
+			for (const [outputKey, outputFn] of Object.entries(outputs)) {
+				const key = pluginOutputKey(handle, outputKey);
+				pluginOutputs[key] = createAndRegisterRenderLambda({
+					handle: key,
+					lambda: () => outputFn(new PluginRenderCtx(handle, wrappedInputs)),
+					withStatus: true
+				});
+			}
+		}
+		const allOutputs = {
+			...this.config.outputs,
+			...pluginOutputs
+		};
+		globalThis.platformaApiVersion = apiVersion;
+		if (!isInUI()) return { config: {
+			v4: {
+				configVersion: 4,
+				modelAPIVersion: 2,
+				sdkVersion: PlatformaSDKVersion,
+				renderingMode: this.config.renderingMode,
+				sections: this.config.sections,
+				title: this.config.title,
+				subtitle: this.config.subtitle,
+				tags: this.config.tags,
+				outputs: allOutputs,
+				enrichmentTargets: this.config.enrichmentTargets,
+				featureFlags: this.config.featureFlags,
+				blockLifecycleCallbacks: { ...BlockStorageFacadeHandles }
+			},
+			sdkVersion: PlatformaSDKVersion,
+			renderingMode: this.config.renderingMode,
+			sections: this.config.sections,
+			outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)]))
+		} };
+		else return {
+			...getPlatformaInstance({
+				sdkVersion: PlatformaSDKVersion,
+				apiVersion
+			}),
+			blockModelInfo: {
+				outputs: Object.fromEntries(Object.entries(allOutputs).map(([key, value]) => [key, { withStatus: Boolean(isConfigLambda(value) && value.withStatus) }])),
+				pluginIds: pluginHandles,
+				featureFlags: this.config.featureFlags,
+				pluginPublicOutputs: Object.fromEntries(pluginHandles.map((handle) => [handle, plugins[handle].model.publicOutputDef]))
+			}
+		};
+	}
+};
+//#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.2.4/node_modules/lru-cache/dist/esm/index.js
+/**
+* @module LRUCache
+*/
+const defaultPerf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+const warned = /* @__PURE__ */ new Set();
+/* c8 ignore start */
+const PROCESS = typeof process === "object" && !!process ? process : {};
+/* c8 ignore start */
+const emitWarning = (msg, type, code, fn) => {
+	typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+};
+let AC = globalThis.AbortController;
+let AS = globalThis.AbortSignal;
+/* c8 ignore start */
+if (typeof AC === "undefined") {
+	AS = class AbortSignal {
+		onabort;
+		_onabort = [];
+		reason;
+		aborted = false;
+		addEventListener(_, fn) {
+			this._onabort.push(fn);
+		}
+	};
+	AC = class AbortController {
+		constructor() {
+			warnACPolyfill();
+		}
+		signal = new AS();
+		abort(reason) {
+			if (this.signal.aborted) return;
+			this.signal.reason = reason;
+			this.signal.aborted = true;
+			for (const fn of this.signal._onabort) fn(reason);
+			this.signal.onabort?.(reason);
+		}
+	};
+	let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+	const warnACPolyfill = () => {
+		if (!printACPolyfillWarning) return;
+		printACPolyfillWarning = false;
+		emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
+	};
+}
+/* c8 ignore stop */
+const shouldWarn = (code) => !warned.has(code);
+const isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+/* c8 ignore start */
+const getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+/* c8 ignore stop */
+var ZeroArray = class extends Array {
+	constructor(size) {
+		super(size);
+		this.fill(0);
+	}
+};
+var Stack = class Stack {
+	heap;
+	length;
+	static #constructing = false;
+	static create(max) {
+		const HeapCls = getUintArray(max);
+		if (!HeapCls) return [];
+		Stack.#constructing = true;
+		const s = new Stack(max, HeapCls);
+		Stack.#constructing = false;
+		return s;
+	}
+	constructor(max, HeapCls) {
+		/* c8 ignore start */
+		if (!Stack.#constructing) throw new TypeError("instantiate Stack using Stack.create(n)");
+		/* c8 ignore stop */
+		this.heap = new HeapCls(max);
+		this.length = 0;
+	}
+	push(n) {
+		this.heap[this.length++] = n;
+	}
+	pop() {
+		return this.heap[--this.length];
+	}
+};
+/**
+* Default export, the thing you're using this module to get.
+*
+* The `K` and `V` types define the key and value types, respectively. The
+* optional `FC` type defines the type of the `context` object passed to
+* `cache.fetch()` and `cache.memo()`.
+*
+* Keys and values **must not** be `null` or `undefined`.
+*
+* All properties from the options object (with the exception of `max`,
+* `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
+* added as normal public members. (The listed options are read-only getters.)
+*
+* Changing any of these will alter the defaults for subsequent method calls.
+*/
+var LRUCache = class LRUCache {
+	#max;
+	#maxSize;
+	#dispose;
+	#onInsert;
+	#disposeAfter;
+	#fetchMethod;
+	#memoMethod;
+	#perf;
+	/**
+	* {@link LRUCache.OptionsBase.perf}
+	*/
+	get perf() {
+		return this.#perf;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.ttl}
+	*/
+	ttl;
+	/**
+	* {@link LRUCache.OptionsBase.ttlResolution}
+	*/
+	ttlResolution;
+	/**
+	* {@link LRUCache.OptionsBase.ttlAutopurge}
+	*/
+	ttlAutopurge;
+	/**
+	* {@link LRUCache.OptionsBase.updateAgeOnGet}
+	*/
+	updateAgeOnGet;
+	/**
+	* {@link LRUCache.OptionsBase.updateAgeOnHas}
+	*/
+	updateAgeOnHas;
+	/**
+	* {@link LRUCache.OptionsBase.allowStale}
+	*/
+	allowStale;
+	/**
+	* {@link LRUCache.OptionsBase.noDisposeOnSet}
+	*/
+	noDisposeOnSet;
+	/**
+	* {@link LRUCache.OptionsBase.noUpdateTTL}
+	*/
+	noUpdateTTL;
+	/**
+	* {@link LRUCache.OptionsBase.maxEntrySize}
+	*/
+	maxEntrySize;
+	/**
+	* {@link LRUCache.OptionsBase.sizeCalculation}
+	*/
+	sizeCalculation;
+	/**
+	* {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+	*/
+	noDeleteOnFetchRejection;
+	/**
+	* {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+	*/
+	noDeleteOnStaleGet;
+	/**
+	* {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+	*/
+	allowStaleOnFetchAbort;
+	/**
+	* {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+	*/
+	allowStaleOnFetchRejection;
+	/**
+	* {@link LRUCache.OptionsBase.ignoreFetchAbort}
+	*/
+	ignoreFetchAbort;
+	#size;
+	#calculatedSize;
+	#keyMap;
+	#keyList;
+	#valList;
+	#next;
+	#prev;
+	#head;
+	#tail;
+	#free;
+	#disposed;
+	#sizes;
+	#starts;
+	#ttls;
+	#autopurgeTimers;
+	#hasDispose;
+	#hasFetchMethod;
+	#hasDisposeAfter;
+	#hasOnInsert;
+	/**
+	* Do not call this method unless you need to inspect the
+	* inner workings of the cache.  If anything returned by this
+	* object is modified in any way, strange breakage may occur.
+	*
+	* These fields are private for a reason!
+	*
+	* @internal
+	*/
+	static unsafeExposeInternals(c) {
+		return {
+			starts: c.#starts,
+			ttls: c.#ttls,
+			autopurgeTimers: c.#autopurgeTimers,
+			sizes: c.#sizes,
+			keyMap: c.#keyMap,
+			keyList: c.#keyList,
+			valList: c.#valList,
+			next: c.#next,
+			prev: c.#prev,
+			get head() {
+				return c.#head;
+			},
+			get tail() {
+				return c.#tail;
+			},
+			free: c.#free,
+			isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
+			backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
+			moveToTail: (index) => c.#moveToTail(index),
+			indexes: (options) => c.#indexes(options),
+			rindexes: (options) => c.#rindexes(options),
+			isStale: (index) => c.#isStale(index)
+		};
+	}
+	/**
+	* {@link LRUCache.OptionsBase.max} (read-only)
+	*/
+	get max() {
+		return this.#max;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.maxSize} (read-only)
+	*/
+	get maxSize() {
+		return this.#maxSize;
+	}
+	/**
+	* The total computed size of items in the cache (read-only)
+	*/
+	get calculatedSize() {
+		return this.#calculatedSize;
+	}
+	/**
+	* The number of items stored in the cache (read-only)
+	*/
+	get size() {
+		return this.#size;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+	*/
+	get fetchMethod() {
+		return this.#fetchMethod;
+	}
+	get memoMethod() {
+		return this.#memoMethod;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.dispose} (read-only)
+	*/
+	get dispose() {
+		return this.#dispose;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.onInsert} (read-only)
+	*/
+	get onInsert() {
+		return this.#onInsert;
+	}
+	/**
+	* {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+	*/
+	get disposeAfter() {
+		return this.#disposeAfter;
+	}
+	constructor(options) {
+		const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, perf } = options;
+		if (perf !== void 0) {
+			if (typeof perf?.now !== "function") throw new TypeError("perf option must have a now() method if specified");
+		}
+		this.#perf = perf ?? defaultPerf;
+		if (max !== 0 && !isPosInt(max)) throw new TypeError("max option must be a nonnegative integer");
+		const UintArray = max ? getUintArray(max) : Array;
+		if (!UintArray) throw new Error("invalid max value: " + max);
+		this.#max = max;
+		this.#maxSize = maxSize;
+		this.maxEntrySize = maxEntrySize || this.#maxSize;
+		this.sizeCalculation = sizeCalculation;
+		if (this.sizeCalculation) {
+			if (!this.#maxSize && !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 (memoMethod !== void 0 && typeof memoMethod !== "function") throw new TypeError("memoMethod must be a function if defined");
+		this.#memoMethod = memoMethod;
+		if (fetchMethod !== void 0 && typeof fetchMethod !== "function") throw new TypeError("fetchMethod must be a function if specified");
+		this.#fetchMethod = fetchMethod;
+		this.#hasFetchMethod = !!fetchMethod;
+		this.#keyMap = /* @__PURE__ */ new Map();
+		this.#keyList = new Array(max).fill(void 0);
+		this.#valList = new Array(max).fill(void 0);
+		this.#next = new UintArray(max);
+		this.#prev = new UintArray(max);
+		this.#head = 0;
+		this.#tail = 0;
+		this.#free = Stack.create(max);
+		this.#size = 0;
+		this.#calculatedSize = 0;
+		if (typeof dispose === "function") this.#dispose = dispose;
+		if (typeof onInsert === "function") this.#onInsert = onInsert;
+		if (typeof disposeAfter === "function") {
+			this.#disposeAfter = disposeAfter;
+			this.#disposed = [];
+		} else {
+			this.#disposeAfter = void 0;
+			this.#disposed = void 0;
+		}
+		this.#hasDispose = !!this.#dispose;
+		this.#hasOnInsert = !!this.#onInsert;
+		this.#hasDisposeAfter = !!this.#disposeAfter;
+		this.noDisposeOnSet = !!noDisposeOnSet;
+		this.noUpdateTTL = !!noUpdateTTL;
+		this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+		this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+		this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+		this.ignoreFetchAbort = !!ignoreFetchAbort;
+		if (this.maxEntrySize !== 0) {
+			if (this.#maxSize !== 0) {
+				if (!isPosInt(this.#maxSize)) throw new TypeError("maxSize must be a positive integer if specified");
+			}
+			if (!isPosInt(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+			this.#initializeSizeTracking();
+		}
+		this.allowStale = !!allowStale;
+		this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+		this.updateAgeOnGet = !!updateAgeOnGet;
+		this.updateAgeOnHas = !!updateAgeOnHas;
+		this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+		this.ttlAutopurge = !!ttlAutopurge;
+		this.ttl = ttl || 0;
+		if (this.ttl) {
+			if (!isPosInt(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+			this.#initializeTTLTracking();
+		}
+		if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+		if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
+			const code = "LRU_CACHE_UNBOUNDED";
+			if (shouldWarn(code)) {
+				warned.add(code);
+				emitWarning("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", code, LRUCache);
+			}
+		}
+	}
+	/**
+	* Return the number of ms left in the item's TTL. If item is not in cache,
+	* returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
+	*/
+	getRemainingTTL(key) {
+		return this.#keyMap.has(key) ? Infinity : 0;
+	}
+	#initializeTTLTracking() {
+		const ttls = new ZeroArray(this.#max);
+		const starts = new ZeroArray(this.#max);
+		this.#ttls = ttls;
+		this.#starts = starts;
+		const purgeTimers = this.ttlAutopurge ? new Array(this.#max) : void 0;
+		this.#autopurgeTimers = purgeTimers;
+		this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
+			starts[index] = ttl !== 0 ? start : 0;
+			ttls[index] = ttl;
+			if (purgeTimers?.[index]) {
+				clearTimeout(purgeTimers[index]);
+				purgeTimers[index] = void 0;
+			}
+			if (ttl !== 0 && purgeTimers) {
+				const t = setTimeout(() => {
+					if (this.#isStale(index)) this.#delete(this.#keyList[index], "expire");
+				}, ttl + 1);
+				/* c8 ignore start */
+				if (t.unref) t.unref();
+				/* c8 ignore stop */
+				purgeTimers[index] = t;
+			}
+		};
+		this.#updateItemAge = (index) => {
+			starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0;
+		};
+		this.#statusTTL = (status, index) => {
+			if (ttls[index]) {
+				const ttl = ttls[index];
+				const start = starts[index];
+				/* c8 ignore next */
+				if (!ttl || !start) return;
+				status.ttl = ttl;
+				status.start = start;
+				status.now = cachedNow || getNow();
+				status.remainingTTL = ttl - (status.now - start);
+			}
+		};
+		let cachedNow = 0;
+		const getNow = () => {
+			const n = this.#perf.now();
+			if (this.ttlResolution > 0) {
+				cachedNow = n;
+				const t = setTimeout(() => cachedNow = 0, this.ttlResolution);
+				/* c8 ignore start */
+				if (t.unref) t.unref();
+			}
+			return n;
+		};
+		this.getRemainingTTL = (key) => {
+			const index = this.#keyMap.get(key);
+			if (index === void 0) return 0;
+			const ttl = ttls[index];
+			const start = starts[index];
+			if (!ttl || !start) return Infinity;
+			return ttl - ((cachedNow || getNow()) - start);
+		};
+		this.#isStale = (index) => {
+			const s = starts[index];
+			const t = ttls[index];
+			return !!t && !!s && (cachedNow || getNow()) - s > t;
+		};
+	}
+	#updateItemAge = () => {};
+	#statusTTL = () => {};
+	#setItemTTL = () => {};
+	/* c8 ignore stop */
+	#isStale = () => false;
+	#initializeSizeTracking() {
+		const sizes = new ZeroArray(this.#max);
+		this.#calculatedSize = 0;
+		this.#sizes = sizes;
+		this.#removeItemSize = (index) => {
+			this.#calculatedSize -= sizes[index];
+			sizes[index] = 0;
+		};
+		this.#requireSize = (k, v, size, sizeCalculation) => {
+			if (this.#isBackgroundFetch(v)) return 0;
+			if (!isPosInt(size)) if (sizeCalculation) {
+				if (typeof sizeCalculation !== "function") throw new TypeError("sizeCalculation must be a function");
+				size = sizeCalculation(v, k);
+				if (!isPosInt(size)) 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 size;
+		};
+		this.#addItemSize = (index, size, status) => {
+			sizes[index] = size;
+			if (this.#maxSize) {
+				const maxSize = this.#maxSize - sizes[index];
+				while (this.#calculatedSize > maxSize) this.#evict(true);
+			}
+			this.#calculatedSize += sizes[index];
+			if (status) {
+				status.entrySize = size;
+				status.totalCalculatedSize = this.#calculatedSize;
+			}
+		};
+	}
+	#removeItemSize = (_i) => {};
+	#addItemSize = (_i, _s, _st) => {};
+	#requireSize = (_k, _v, size, sizeCalculation) => {
+		if (size || sizeCalculation) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+		return 0;
+	};
+	*#indexes({ allowStale = this.allowStale } = {}) {
+		if (this.#size) for (let i = this.#tail;;) {
+			if (!this.#isValidIndex(i)) break;
+			if (allowStale || !this.#isStale(i)) yield i;
+			if (i === this.#head) break;
+			else i = this.#prev[i];
+		}
+	}
+	*#rindexes({ allowStale = this.allowStale } = {}) {
+		if (this.#size) for (let i = this.#head;;) {
+			if (!this.#isValidIndex(i)) break;
+			if (allowStale || !this.#isStale(i)) yield i;
+			if (i === this.#tail) break;
+			else i = this.#next[i];
+		}
+	}
+	#isValidIndex(index) {
+		return index !== void 0 && this.#keyMap.get(this.#keyList[index]) === index;
+	}
+	/**
+	* Return a generator yielding `[key, value]` pairs,
+	* in order from most recently used to least recently used.
+	*/
+	*entries() {
+		for (const i of this.#indexes()) if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield [this.#keyList[i], this.#valList[i]];
+	}
+	/**
+	* Inverse order version of {@link LRUCache.entries}
+	*
+	* Return a generator yielding `[key, value]` pairs,
+	* in order from least recently used to most recently used.
+	*/
+	*rentries() {
+		for (const i of this.#rindexes()) if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield [this.#keyList[i], this.#valList[i]];
+	}
+	/**
+	* Return a generator yielding the keys in the cache,
+	* in order from most recently used to least recently used.
+	*/
+	*keys() {
+		for (const i of this.#indexes()) {
+			const k = this.#keyList[i];
+			if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+		}
+	}
+	/**
+	* Inverse order version of {@link LRUCache.keys}
+	*
+	* Return a generator yielding the keys in the cache,
+	* in order from least recently used to most recently used.
+	*/
+	*rkeys() {
+		for (const i of this.#rindexes()) {
+			const k = this.#keyList[i];
+			if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+		}
+	}
+	/**
+	* Return a generator yielding the values in the cache,
+	* in order from most recently used to least recently used.
+	*/
+	*values() {
+		for (const i of this.#indexes()) if (this.#valList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
+	}
+	/**
+	* Inverse order version of {@link LRUCache.values}
+	*
+	* Return a generator yielding the values in the cache,
+	* in order from least recently used to most recently used.
+	*/
+	*rvalues() {
+		for (const i of this.#rindexes()) if (this.#valList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
+	}
+	/**
+	* Iterating over the cache itself yields the same results as
+	* {@link LRUCache.entries}
+	*/
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	/**
+	* A String value that is used in the creation of the default string
+	* description of an object. Called by the built-in method
+	* `Object.prototype.toString`.
+	*/
+	[Symbol.toStringTag] = "LRUCache";
+	/**
+	* Find a value for which the supplied fn method returns a truthy value,
+	* similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
+	*/
+	find(fn, getOptions = {}) {
+		for (const i of this.#indexes()) {
+			const v = this.#valList[i];
+			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+			if (value === void 0) continue;
+			if (fn(value, this.#keyList[i], this)) return this.get(this.#keyList[i], getOptions);
+		}
+	}
+	/**
+	* Call the supplied function on each item in the cache, in order from most
+	* recently used to least recently used.
+	*
+	* `fn` is called as `fn(value, key, cache)`.
+	*
+	* If `thisp` is provided, function will be called in the `this`-context of
+	* the provided object, or the cache if no `thisp` object is provided.
+	*
+	* Does not update age or recenty of use, or iterate over stale values.
+	*/
+	forEach(fn, thisp = this) {
+		for (const i of this.#indexes()) {
+			const v = this.#valList[i];
+			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+			if (value === void 0) continue;
+			fn.call(thisp, value, this.#keyList[i], this);
+		}
+	}
+	/**
+	* The same as {@link LRUCache.forEach} but items are iterated over in
+	* reverse order.  (ie, less recently used items are iterated over first.)
+	*/
+	rforEach(fn, thisp = this) {
+		for (const i of this.#rindexes()) {
+			const v = this.#valList[i];
+			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+			if (value === void 0) continue;
+			fn.call(thisp, value, this.#keyList[i], this);
+		}
+	}
+	/**
+	* Delete any stale entries. Returns true if anything was removed,
+	* false otherwise.
+	*/
+	purgeStale() {
+		let deleted = false;
+		for (const i of this.#rindexes({ allowStale: true })) if (this.#isStale(i)) {
+			this.#delete(this.#keyList[i], "expire");
+			deleted = true;
+		}
+		return deleted;
+	}
+	/**
+	* Get the extended info about a given entry, to get its value, size, and
+	* TTL info simultaneously. Returns `undefined` if the key is not present.
+	*
+	* Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+	* serialization, the `start` value is always the current timestamp, and the
+	* `ttl` is a calculated remaining time to live (negative if expired).
+	*
+	* Always returns stale values, if their info is found in the cache, so be
+	* sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+	* if relevant.
+	*/
+	info(key) {
+		const i = this.#keyMap.get(key);
+		if (i === void 0) return void 0;
+		const v = this.#valList[i];
+		/* c8 ignore start - this isn't tested for the info function,
+		* but it's the same logic as found in other places. */
+		const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+		if (value === void 0) return void 0;
+		/* c8 ignore end */
+		const entry = { value };
+		if (this.#ttls && this.#starts) {
+			const ttl = this.#ttls[i];
+			const start = this.#starts[i];
+			if (ttl && start) {
+				entry.ttl = ttl - (this.#perf.now() - start);
+				entry.start = Date.now();
+			}
+		}
+		if (this.#sizes) entry.size = this.#sizes[i];
+		return entry;
+	}
+	/**
+	* Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+	* passed to {@link LRUCache#load}.
+	*
+	* The `start` fields are calculated relative to a portable `Date.now()`
+	* timestamp, even if `performance.now()` is available.
+	*
+	* Stale entries are always included in the `dump`, even if
+	* {@link LRUCache.OptionsBase.allowStale} is false.
+	*
+	* Note: this returns an actual array, not a generator, so it can be more
+	* easily passed around.
+	*/
+	dump() {
+		const arr = [];
+		for (const i of this.#indexes({ allowStale: true })) {
+			const key = this.#keyList[i];
+			const v = this.#valList[i];
+			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+			if (value === void 0 || key === void 0) continue;
+			const entry = { value };
+			if (this.#ttls && this.#starts) {
+				entry.ttl = this.#ttls[i];
+				const age = this.#perf.now() - this.#starts[i];
+				entry.start = Math.floor(Date.now() - age);
+			}
+			if (this.#sizes) entry.size = this.#sizes[i];
+			arr.unshift([key, entry]);
+		}
+		return arr;
+	}
+	/**
+	* Reset the cache and load in the items in entries in the order listed.
+	*
+	* The shape of the resulting cache may be different if the same options are
+	* not used in both caches.
+	*
+	* The `start` fields are assumed to be calculated relative to a portable
+	* `Date.now()` timestamp, even if `performance.now()` is available.
+	*/
+	load(arr) {
+		this.clear();
+		for (const [key, entry] of arr) {
+			if (entry.start) {
+				const age = Date.now() - entry.start;
+				entry.start = this.#perf.now() - age;
+			}
+			this.set(key, entry.value, entry);
+		}
+	}
+	/**
+	* Add a value to the cache.
+	*
+	* Note: if `undefined` is specified as a value, this is an alias for
+	* {@link LRUCache#delete}
+	*
+	* Fields on the {@link LRUCache.SetOptions} options param will override
+	* their corresponding values in the constructor options for the scope
+	* of this single `set()` operation.
+	*
+	* If `start` is provided, then that will set the effective start
+	* time for the TTL calculation. Note that this must be a previous
+	* value of `performance.now()` if supported, or a previous value of
+	* `Date.now()` if not.
+	*
+	* Options object may also include `size`, which will prevent
+	* calling the `sizeCalculation` function and just use the specified
+	* number if it is a positive integer, and `noDisposeOnSet` which
+	* will prevent calling a `dispose` function in the case of
+	* overwrites.
+	*
+	* If the `size` (or return value of `sizeCalculation`) for a given
+	* entry is greater than `maxEntrySize`, then the item will not be
+	* added to the cache.
+	*
+	* Will update the recency of the entry.
+	*
+	* If the value is `undefined`, then this is an alias for
+	* `cache.delete(key)`. `undefined` is never stored in the cache.
+	*/
+	set(k, v, setOptions = {}) {
+		if (v === void 0) {
+			this.delete(k);
+			return this;
+		}
+		const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
+		let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+		const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
+		if (this.maxEntrySize && size > this.maxEntrySize) {
+			if (status) {
+				status.set = "miss";
+				status.maxEntrySizeExceeded = true;
+			}
+			this.#delete(k, "set");
+			return this;
+		}
+		let index = this.#size === 0 ? void 0 : this.#keyMap.get(k);
+		if (index === void 0) {
+			index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
+			this.#keyList[index] = k;
+			this.#valList[index] = v;
+			this.#keyMap.set(k, index);
+			this.#next[this.#tail] = index;
+			this.#prev[index] = this.#tail;
+			this.#tail = index;
+			this.#size++;
+			this.#addItemSize(index, size, status);
+			if (status) status.set = "add";
+			noUpdateTTL = false;
+			if (this.#hasOnInsert) this.#onInsert?.(v, k, "add");
+		} else {
+			this.#moveToTail(index);
+			const oldVal = this.#valList[index];
+			if (v !== oldVal) {
+				if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
+					oldVal.__abortController.abort(/* @__PURE__ */ new Error("replaced"));
+					const { __staleWhileFetching: s } = oldVal;
+					if (s !== void 0 && !noDisposeOnSet) {
+						if (this.#hasDispose) this.#dispose?.(s, k, "set");
+						if (this.#hasDisposeAfter) this.#disposed?.push([
+							s,
+							k,
+							"set"
+						]);
+					}
+				} else if (!noDisposeOnSet) {
+					if (this.#hasDispose) this.#dispose?.(oldVal, k, "set");
+					if (this.#hasDisposeAfter) this.#disposed?.push([
+						oldVal,
+						k,
+						"set"
+					]);
+				}
+				this.#removeItemSize(index);
+				this.#addItemSize(index, size, status);
+				this.#valList[index] = v;
+				if (status) {
+					status.set = "replace";
+					const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
+					if (oldValue !== void 0) status.oldValue = oldValue;
+				}
+			} else if (status) status.set = "update";
+			if (this.#hasOnInsert) this.onInsert?.(v, k, v === oldVal ? "update" : "replace");
+		}
+		if (ttl !== 0 && !this.#ttls) this.#initializeTTLTracking();
+		if (this.#ttls) {
+			if (!noUpdateTTL) this.#setItemTTL(index, ttl, start);
+			if (status) this.#statusTTL(status, index);
+		}
+		if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+			const dt = this.#disposed;
+			let task;
+			while (task = dt?.shift()) this.#disposeAfter?.(...task);
+		}
+		return this;
+	}
+	/**
+	* Evict the least recently used item, returning its value or
+	* `undefined` if cache is empty.
+	*/
+	pop() {
+		try {
+			while (this.#size) {
+				const val = this.#valList[this.#head];
+				this.#evict(true);
+				if (this.#isBackgroundFetch(val)) {
+					if (val.__staleWhileFetching) return val.__staleWhileFetching;
+				} else if (val !== void 0) return val;
+			}
+		} finally {
+			if (this.#hasDisposeAfter && this.#disposed) {
+				const dt = this.#disposed;
+				let task;
+				while (task = dt?.shift()) this.#disposeAfter?.(...task);
+			}
+		}
+	}
+	#evict(free) {
+		const head = this.#head;
+		const k = this.#keyList[head];
+		const v = this.#valList[head];
+		if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) v.__abortController.abort(/* @__PURE__ */ new Error("evicted"));
+		else if (this.#hasDispose || this.#hasDisposeAfter) {
+			if (this.#hasDispose) this.#dispose?.(v, k, "evict");
+			if (this.#hasDisposeAfter) this.#disposed?.push([
+				v,
+				k,
+				"evict"
+			]);
+		}
+		this.#removeItemSize(head);
+		if (this.#autopurgeTimers?.[head]) {
+			clearTimeout(this.#autopurgeTimers[head]);
+			this.#autopurgeTimers[head] = void 0;
+		}
+		if (free) {
+			this.#keyList[head] = void 0;
+			this.#valList[head] = void 0;
+			this.#free.push(head);
+		}
+		if (this.#size === 1) {
+			this.#head = this.#tail = 0;
+			this.#free.length = 0;
+		} else this.#head = this.#next[head];
+		this.#keyMap.delete(k);
+		this.#size--;
+		return head;
+	}
+	/**
+	* Check if a key is in the cache, without updating the recency of use.
+	* Will return false if the item is stale, even though it is technically
+	* in the cache.
+	*
+	* Check if a key is in the cache, without updating the recency of
+	* use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+	* to `true` in either the options or the constructor.
+	*
+	* Will return `false` if the item is stale, even though it is technically in
+	* the cache. The difference can be determined (if it matters) by using a
+	* `status` argument, and inspecting the `has` field.
+	*
+	* Will not update item age unless
+	* {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+	*/
+	has(k, hasOptions = {}) {
+		const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+		const index = this.#keyMap.get(k);
+		if (index !== void 0) {
+			const v = this.#valList[index];
+			if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === void 0) return false;
+			if (!this.#isStale(index)) {
+				if (updateAgeOnHas) this.#updateItemAge(index);
+				if (status) {
+					status.has = "hit";
+					this.#statusTTL(status, index);
+				}
+				return true;
+			} else if (status) {
+				status.has = "stale";
+				this.#statusTTL(status, index);
+			}
+		} else if (status) status.has = "miss";
+		return false;
+	}
+	/**
+	* Like {@link LRUCache#get} but doesn't update recency or delete stale
+	* items.
+	*
+	* Returns `undefined` if the item is stale, unless
+	* {@link LRUCache.OptionsBase.allowStale} is set.
+	*/
+	peek(k, peekOptions = {}) {
+		const { allowStale = this.allowStale } = peekOptions;
+		const index = this.#keyMap.get(k);
+		if (index === void 0 || !allowStale && this.#isStale(index)) return;
+		const v = this.#valList[index];
+		return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+	}
+	#backgroundFetch(k, index, options, context) {
+		const v = index === void 0 ? void 0 : this.#valList[index];
+		if (this.#isBackgroundFetch(v)) return v;
+		const ac = new AC();
+		const { signal } = options;
+		signal?.addEventListener("abort", () => ac.abort(signal.reason), { signal: ac.signal });
+		const fetchOpts = {
+			signal: ac.signal,
+			options,
+			context
+		};
+		const cb = (v, updateCache = false) => {
+			const { aborted } = ac.signal;
+			const ignoreAbort = options.ignoreFetchAbort && v !== void 0;
+			if (options.status) if (aborted && !updateCache) {
+				options.status.fetchAborted = true;
+				options.status.fetchError = ac.signal.reason;
+				if (ignoreAbort) options.status.fetchAbortIgnored = true;
+			} else options.status.fetchResolved = true;
+			if (aborted && !ignoreAbort && !updateCache) return fetchFail(ac.signal.reason);
+			const bf = p;
+			const vl = this.#valList[index];
+			if (vl === p || ignoreAbort && updateCache && vl === void 0) if (v === void 0) if (bf.__staleWhileFetching !== void 0) this.#valList[index] = bf.__staleWhileFetching;
+			else this.#delete(k, "fetch");
+			else {
+				if (options.status) options.status.fetchUpdated = true;
+				this.set(k, v, fetchOpts.options);
+			}
+			return v;
+		};
+		const eb = (er) => {
+			if (options.status) {
+				options.status.fetchRejected = true;
+				options.status.fetchError = er;
+			}
+			return fetchFail(er);
+		};
+		const fetchFail = (er) => {
+			const { aborted } = ac.signal;
+			const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+			const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+			const noDelete = allowStale || options.noDeleteOnFetchRejection;
+			const bf = p;
+			if (this.#valList[index] === p) {
+				if (!noDelete || bf.__staleWhileFetching === void 0) this.#delete(k, "fetch");
+				else if (!allowStaleAborted) this.#valList[index] = bf.__staleWhileFetching;
+			}
+			if (allowStale) {
+				if (options.status && bf.__staleWhileFetching !== void 0) options.status.returnedStale = true;
+				return bf.__staleWhileFetching;
+			} else if (bf.__returned === bf) throw er;
+		};
+		const pcall = (res, rej) => {
+			const fmp = this.#fetchMethod?.(k, v, fetchOpts);
+			if (fmp && fmp instanceof Promise) fmp.then((v) => res(v === void 0 ? void 0 : v), rej);
+			ac.signal.addEventListener("abort", () => {
+				if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+					res(void 0);
+					if (options.allowStaleOnFetchAbort) res = (v) => cb(v, true);
+				}
+			});
+		};
+		if (options.status) options.status.fetchDispatched = true;
+		const p = new Promise(pcall).then(cb, eb);
+		const bf = Object.assign(p, {
+			__abortController: ac,
+			__staleWhileFetching: v,
+			__returned: void 0
+		});
+		if (index === void 0) {
+			this.set(k, bf, {
+				...fetchOpts.options,
+				status: void 0
+			});
+			index = this.#keyMap.get(k);
+		} else this.#valList[index] = bf;
+		return bf;
+	}
+	#isBackgroundFetch(p) {
+		if (!this.#hasFetchMethod) return false;
+		const b = p;
+		return !!b && b instanceof Promise && b.hasOwnProperty("__staleWhileFetching") && b.__abortController instanceof AC;
+	}
+	async fetch(k, fetchOptions = {}) {
+		const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal } = fetchOptions;
+		if (!this.#hasFetchMethod) {
+			if (status) status.fetch = "get";
+			return this.get(k, {
+				allowStale,
+				updateAgeOnGet,
+				noDeleteOnStaleGet,
+				status
+			});
+		}
+		const options = {
+			allowStale,
+			updateAgeOnGet,
+			noDeleteOnStaleGet,
+			ttl,
+			noDisposeOnSet,
+			size,
+			sizeCalculation,
+			noUpdateTTL,
+			noDeleteOnFetchRejection,
+			allowStaleOnFetchRejection,
+			allowStaleOnFetchAbort,
+			ignoreFetchAbort,
+			status,
+			signal
+		};
+		let index = this.#keyMap.get(k);
+		if (index === void 0) {
+			if (status) status.fetch = "miss";
+			const p = this.#backgroundFetch(k, index, options, context);
+			return p.__returned = p;
+		} else {
+			const v = this.#valList[index];
+			if (this.#isBackgroundFetch(v)) {
+				const stale = allowStale && v.__staleWhileFetching !== void 0;
+				if (status) {
+					status.fetch = "inflight";
+					if (stale) status.returnedStale = true;
+				}
+				return stale ? v.__staleWhileFetching : v.__returned = v;
+			}
+			const isStale = this.#isStale(index);
+			if (!forceRefresh && !isStale) {
+				if (status) status.fetch = "hit";
+				this.#moveToTail(index);
+				if (updateAgeOnGet) this.#updateItemAge(index);
+				if (status) this.#statusTTL(status, index);
+				return v;
+			}
+			const p = this.#backgroundFetch(k, index, options, context);
+			const staleVal = p.__staleWhileFetching !== void 0 && allowStale;
+			if (status) {
+				status.fetch = isStale ? "stale" : "refresh";
+				if (staleVal && isStale) status.returnedStale = true;
+			}
+			return staleVal ? p.__staleWhileFetching : p.__returned = p;
+		}
+	}
+	async forceFetch(k, fetchOptions = {}) {
+		const v = await this.fetch(k, fetchOptions);
+		if (v === void 0) throw new Error("fetch() returned undefined");
+		return v;
+	}
+	memo(k, memoOptions = {}) {
+		const memoMethod = this.#memoMethod;
+		if (!memoMethod) throw new Error("no memoMethod provided to constructor");
+		const { context, forceRefresh, ...options } = memoOptions;
+		const v = this.get(k, options);
+		if (!forceRefresh && v !== void 0) return v;
+		const vv = memoMethod(k, v, {
+			options,
+			context
+		});
+		this.set(k, vv, options);
+		return vv;
+	}
+	/**
+	* Return a value from the cache. Will update the recency of the cache
+	* entry found.
+	*
+	* If the key is not found, get() will return `undefined`.
+	*/
+	get(k, getOptions = {}) {
+		const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
+		const index = this.#keyMap.get(k);
+		if (index !== void 0) {
+			const value = this.#valList[index];
+			const fetching = this.#isBackgroundFetch(value);
+			if (status) this.#statusTTL(status, index);
+			if (this.#isStale(index)) {
+				if (status) status.get = "stale";
+				if (!fetching) {
+					if (!noDeleteOnStaleGet) this.#delete(k, "expire");
+					if (status && allowStale) status.returnedStale = true;
+					return allowStale ? value : void 0;
+				} else {
+					if (status && allowStale && value.__staleWhileFetching !== void 0) status.returnedStale = true;
+					return allowStale ? value.__staleWhileFetching : void 0;
+				}
+			} else {
+				if (status) status.get = "hit";
+				if (fetching) return value.__staleWhileFetching;
+				this.#moveToTail(index);
+				if (updateAgeOnGet) this.#updateItemAge(index);
+				return value;
+			}
+		} else if (status) status.get = "miss";
+	}
+	#connect(p, n) {
+		this.#prev[n] = p;
+		this.#next[p] = n;
+	}
+	#moveToTail(index) {
+		if (index !== this.#tail) {
+			if (index === this.#head) this.#head = this.#next[index];
+			else this.#connect(this.#prev[index], this.#next[index]);
+			this.#connect(this.#tail, index);
+			this.#tail = index;
+		}
+	}
+	/**
+	* Deletes a key out of the cache.
+	*
+	* Returns true if the key was deleted, false otherwise.
+	*/
+	delete(k) {
+		return this.#delete(k, "delete");
+	}
+	#delete(k, reason) {
+		let deleted = false;
+		if (this.#size !== 0) {
+			const index = this.#keyMap.get(k);
+			if (index !== void 0) {
+				if (this.#autopurgeTimers?.[index]) {
+					clearTimeout(this.#autopurgeTimers?.[index]);
+					this.#autopurgeTimers[index] = void 0;
+				}
+				deleted = true;
+				if (this.#size === 1) this.#clear(reason);
+				else {
+					this.#removeItemSize(index);
+					const v = this.#valList[index];
+					if (this.#isBackgroundFetch(v)) v.__abortController.abort(/* @__PURE__ */ new Error("deleted"));
+					else if (this.#hasDispose || this.#hasDisposeAfter) {
+						if (this.#hasDispose) this.#dispose?.(v, k, reason);
+						if (this.#hasDisposeAfter) this.#disposed?.push([
+							v,
+							k,
+							reason
+						]);
+					}
+					this.#keyMap.delete(k);
+					this.#keyList[index] = void 0;
+					this.#valList[index] = void 0;
+					if (index === this.#tail) this.#tail = this.#prev[index];
+					else if (index === this.#head) this.#head = this.#next[index];
+					else {
+						const pi = this.#prev[index];
+						this.#next[pi] = this.#next[index];
+						const ni = this.#next[index];
+						this.#prev[ni] = this.#prev[index];
+					}
+					this.#size--;
+					this.#free.push(index);
+				}
+			}
+		}
+		if (this.#hasDisposeAfter && this.#disposed?.length) {
+			const dt = this.#disposed;
+			let task;
+			while (task = dt?.shift()) this.#disposeAfter?.(...task);
+		}
+		return deleted;
+	}
+	/**
+	* Clear the cache entirely, throwing away all values.
+	*/
+	clear() {
+		return this.#clear("delete");
+	}
+	#clear(reason) {
+		for (const index of this.#rindexes({ allowStale: true })) {
+			const v = this.#valList[index];
+			if (this.#isBackgroundFetch(v)) v.__abortController.abort(/* @__PURE__ */ new Error("deleted"));
+			else {
+				const k = this.#keyList[index];
+				if (this.#hasDispose) this.#dispose?.(v, k, reason);
+				if (this.#hasDisposeAfter) this.#disposed?.push([
+					v,
+					k,
+					reason
+				]);
+			}
+		}
+		this.#keyMap.clear();
+		this.#valList.fill(void 0);
+		this.#keyList.fill(void 0);
+		if (this.#ttls && this.#starts) {
+			this.#ttls.fill(0);
+			this.#starts.fill(0);
+			for (const t of this.#autopurgeTimers ?? []) if (t !== void 0) clearTimeout(t);
+			this.#autopurgeTimers?.fill(void 0);
+		}
+		if (this.#sizes) this.#sizes.fill(0);
+		this.#head = 0;
+		this.#tail = 0;
+		this.#free.length = 0;
+		this.#calculatedSize = 0;
+		this.#size = 0;
+		if (this.#hasDisposeAfter && this.#disposed) {
+			const dt = this.#disposed;
+			let task;
+			while (task = dt?.shift()) this.#disposeAfter?.(...task);
+		}
+	}
+};
+//#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 LRUCache({ 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 LRUCache({ 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;
+}
+function isColumnProvider(source) {
+	if (typeof source !== "object" || source === null) return false;
+	const p = source;
+	return typeof p.getColumns === "function" && typeof p.isFinal === "function";
+}
+//#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 LRUCache({ 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);
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/columns/columns_collection.js
+/**
+* Build a {@link ColumnsCollection} from sandbox-side source descriptors.
+* Resolves the `columnsCollection` driver (either from `deps.driver` or via
+* `getService("columnsCollection")`) and asks the host to mint a fresh
+* handle covering the supplied sources. Pass `sources === undefined` to
+* fall back to the active render ctx (main outputs + prerun + result pool).
+*
+* `sources` accepts {@link ColumnsSourceShorthand} string literals
+* (`"result_pool"`, `"current_block"`) for the common ctx-derived sources.
+*/
+function ColumnsCollection(sources, deps) {
+	const driver = deps?.driver ?? getService("columnsCollection", { ctx: deps?.ctx });
+	const serialized = sources ? sources.flatMap((s) => toSerializedSources(s, deps?.ctx)) : defaultCtxSources(deps?.ctx);
+	return new ColumnsCollectionImpl(driver.create(serialized), driver);
+}
+/**
+* Sandbox proxy over the host-side `ColumnsCollection` driver. The driver
+* owns all column-set state; this object only carries an opaque
+* {@link CollectionHandle} plus a reference to the driver service.
+*
+* Construct via {@link ColumnsCollection} — the bare constructor is a
+* trivial `(handle, driver)` pair so that `addSource` / `discover` / `filter`
+* can rebind a freshly-minted handle without going through source
+* serialisation again.
+*
+* Every method returning a `ColumnsCollection` mints a fresh handle on the
+* host — the host VM bridge pins it to the active render ctx, so the sandbox
+* never has to manage refcounts.
+*/
+var ColumnsCollectionImpl = class ColumnsCollectionImpl {
+	handle;
+	driver;
+	constructor(handle, driver) {
+		this.handle = handle;
+		this.driver = driver;
+	}
+	isEmpty() {
+		return this.driver.isEmpty(this.handle);
+	}
+	isFinal() {
+		return this.driver.isFinal(this.handle);
+	}
+	getColumnIds() {
+		return this.driver.getColumns(this.handle);
+	}
+	getColumns() {
+		return this.getColumnIds().map((id) => ColumnRecipe(id)).filter((c) => !isNil(c));
+	}
+	addSource(source) {
+		return new ColumnsCollectionImpl(this.driver.addSource(this.handle, toSerializedSources(source)), this.driver);
+	}
+	discover(options) {
+		return new ColumnsCollectionImpl(this.driver.discover(this.handle, options), this.driver);
+	}
+	filter(options) {
+		return new ColumnsCollectionImpl(this.driver.filter(this.handle, options), this.driver);
+	}
+};
+function toSerializedSources(source, ctx) {
+	if (source === "result_pool") return [{ kind: "result_pool" }];
+	if (source === "current_block") return currentBlockSources(ctx);
+	if (source instanceof ColumnsCollectionImpl) return [{
+		kind: "collection",
+		handle: source.handle
+	}];
+	if (source instanceof TreeNodeAccessor) return [{
+		kind: "accessor",
+		accessor: source.handle,
+		path: source.resolvePath
+	}];
+	if (isColumnArray(source)) return [{
+		kind: "ids",
+		ids: source.columns.map((c) => c.id),
+		isFinal: source.isFinal
+	}];
+	if (isColumnProvider(source)) return [{
+		kind: "ids",
+		ids: source.getColumns().map((c) => c.id),
+		isFinal: source.isFinal()
+	}];
+	throw new Error("ColumnsCollection: unrecognised ColumnsSource shape");
+}
+function isColumnArray(source) {
+	if (typeof source !== "object" || source === null) return false;
+	const s = source;
+	return Array.isArray(s.columns) && typeof s.isFinal === "boolean";
+}
+function currentBlockSources(ctx) {
+	const renderCtx = ctx ?? getCfgRenderCtx();
+	const sources = [];
+	const outputs = renderCtx.getAccessorHandleByName(MainAccessorName);
+	if (outputs !== void 0) sources.push({
+		kind: "accessor",
+		accessor: outputs,
+		path: [MainAccessorName]
+	});
+	const prerun = renderCtx.getAccessorHandleByName(StagingAccessorName);
+	if (prerun !== void 0) sources.push({
+		kind: "accessor",
+		accessor: prerun,
+		path: [StagingAccessorName]
+	});
+	return sources;
+}
+function defaultCtxSources(ctx) {
+	return [...currentBlockSources(ctx), { kind: "result_pool" }];
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/columns/utils.js
+/**
+* PObjectIds of every non-hit column referenced by `recipe.getQuery()`,
+* deduped in traversal order. The hit column is
+* `extractPObjectId(recipe.id)`; anything else in the query is a linker or
+* other engine-consumed column.
+*
+* Pure query walk — no registry access. Use {@link collectLinkerColumns} for
+* the resolved {@link ColumnLazy} variant.
+*/
+function collectLinkerIds(recipe) {
+	const hit = extractPObjectId(recipe.id);
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const id of collectSpecQueryColumns(recipe.getQuery())) {
+		const bare = extractPObjectId(id);
+		if (bare === hit) continue;
+		if (seen.has(bare)) continue;
+		seen.add(bare);
+		out.push(bare);
+	}
+	return out;
+}
+/**
+* {@link collectLinkerIds} resolved against the ambient context as
+* {@link ColumnLazy} instances. Throws if any id fails to resolve —
+* matches the contract of the legacy `resolveLinkers` it replaces.
+*/
+function collectLinkerColumns(recipe, opts = {}) {
+	return collectLinkerIds(recipe).map((id) => ColumnLazyImpl.fromId(id, opts) ?? throwError(`materializeLinkers: linker ${id} not resolvable`));
+}
+/**
+* Hit-side axis qualifications for the recipe — the ones that should land on
+* the outer-join entry wrapping this column at the consumer boundary.
+*
+* Descends {@link ColumnOverriddenRecipe} / {@link ColumnFilteredRecipe} via
+* `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise
+* returns `[]`. Pure recipe walk — no query-tree introspection.
+*/
+function hitQualifications(recipe) {
+	return findDiscovered(recipe)?.getColumnQualifications() ?? [];
+}
+/**
+* Per-primary-column axis qualifications for the recipe — applied to the
+* outer primary anchors on this recipe's group side. Keyed by the external
+* primary column id (NOT by columns inside this recipe's own query).
+*
+* Same walk strategy as {@link hitQualifications}.
+*/
+function queriesQualifications(recipe) {
+	return findDiscovered(recipe)?.getQueriesQualifications() ?? {};
+}
+/**
+* Whether the recipe's underlying data resources actually carry bytes —
+* strictly stronger than `getDataStatus() === "present"`, which only tells
+* that the `.data` field is wired onto the accessor.
+*
+* Walks every physical leaf the recipe depends on via
+* {@link ColumnRecipe.getReferencedIds} (resolves each id back to a
+* {@link ColumnLazy} through the ambient ctx) and ANDs `hasData()` across
+* all of them. Inline {@link PColumnValues} payloads count as present.
+*
+* Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as
+* "not yet ready") rather than throwing — this is a UI-facing predicate, not
+* a contract assertion.
+*/
+function hasColumnData(recipe, opts = {}) {
+	for (const id of recipe.getReferencedIds()) {
+		const lazy = ColumnLazyImpl.fromId(id, opts);
+		if (lazy === void 0) return false;
+		if (lazy.getDataStatus() !== "present") return false;
+		if (!isLazyDataPresent(lazy.getData())) return false;
+	}
+	return true;
+}
+function isLazyDataPresent(data) {
+	if (data === void 0) return false;
+	if (Array.isArray(data)) return true;
+	if (data instanceof TreeNodeAccessor) return data.hasData();
+	if (isDataInfo(data)) {
+		let ok = true;
+		visitDataInfo(data, (blob) => {
+			ok &&= blob.hasData();
+		});
+		return ok;
+	}
+	return false;
+}
+/**
+* Walk wrapper layers (Overridden, Filtered) until a {@link
+* ColumnDiscoveredRecipe} is found. Returns `undefined` if the recipe chain
+* has no Discovered layer (bare leaves and Overridden-over-leaf cases).
+*
+* Invariant from the wrapper classes themselves: there is at most one
+* Discovered layer in any recipe chain — Discovered is constructed only via
+* its own factory and is never re-wrapped by Discovered.
+*/
+function findDiscovered(recipe) {
+	let current = recipe;
+	while (true) {
+		if (current instanceof ColumnDiscoveredRecipe) return current;
+		if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {
+			current = current.getInner();
+			continue;
 		}
-		const allOutputs = {
-			...this.config.outputs,
-			...pluginOutputs
-		};
-		globalThis.platformaApiVersion = apiVersion;
-		if (!isInUI()) return { config: {
-			v4: {
-				configVersion: 4,
-				modelAPIVersion: 2,
-				sdkVersion: PlatformaSDKVersion,
-				renderingMode: this.config.renderingMode,
-				sections: this.config.sections,
-				title: this.config.title,
-				subtitle: this.config.subtitle,
-				tags: this.config.tags,
-				outputs: allOutputs,
-				enrichmentTargets: this.config.enrichmentTargets,
-				featureFlags: this.config.featureFlags,
-				blockLifecycleCallbacks: { ...BlockStorageFacadeHandles }
-			},
-			sdkVersion: PlatformaSDKVersion,
-			renderingMode: this.config.renderingMode,
-			sections: this.config.sections,
-			outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)]))
-		} };
-		else return {
-			...getPlatformaInstance({
-				sdkVersion: PlatformaSDKVersion,
-				apiVersion
-			}),
-			blockModelInfo: {
-				outputs: Object.fromEntries(Object.entries(allOutputs).map(([key, value]) => [key, { withStatus: Boolean(isConfigLambda(value) && value.withStatus) }])),
-				pluginIds: pluginHandles,
-				featureFlags: this.config.featureFlags,
-				pluginPublicOutputs: Object.fromEntries(pluginHandles.map((handle) => [handle, plugins[handle].model.publicOutputDef]))
-			}
-		};
+		return;
 	}
-};
+}
+/**
+* A recipe is a "leaf" (directly co-indexed on the anchor, reached without a
+* linker chain) iff its wrapper chain contains no {@link ColumnDiscoveredRecipe}.
+*
+* `Filtered` / `Overridden` over a bare leaf stay leaves; anything wrapping a
+* `Discovered` (e.g. `Overridden(Discovered(...))`) is linked. Use this — not an
+* `instanceof ColumnLazyImpl` check — to split direct vs. linker-joined columns,
+* since projections over a plain leaf are still direct.
+*/
+function isLeafColumn(recipe) {
+	return findDiscovered(recipe) === void 0;
+}
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/filters/traverse.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/filters/traverse.js
 /**
 * Recursively traverses a FilterSpec tree bottom-up, applying visitor callbacks.
 *
@@ -8237,16 +11086,15 @@ function collectFilterSpecColumns(filter) {
 	});
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/filters/converters/filterToQuery.js
-/** Parses a CanonicalizedJson<PTableColumnId> string into a SpecQueryExpression reference. */
-function resolveColumnRef(columnStr) {
-	const parsed = JSON.parse(columnStr);
-	return parsed.type === "axis" ? {
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/filters/converters/filterToQuery.js
+/** Converts a QueryColumnId object into a SpecQueryExpression reference. */
+function resolveColumnRef(col) {
+	return col.type === "axis" ? {
 		type: "axisRef",
-		value: parsed.id
+		value: col.id
 	} : {
 		type: "columnRef",
-		value: parsed.id
+		value: col.id
 	};
 }
 /** Converts a FilterSpec tree into a SpecQueryExpression. */
@@ -8566,7 +11414,7 @@ function isEmpty(value) {
 	return true;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/filters/distill.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/filters/distill.js
 /**
 * Strips non-FilterSpec metadata (whitelist approach) and removes
 * unfilled leaves (type is undefined or any required field is undefined).
@@ -8671,7 +11519,7 @@ const REQUIRED_KEYS_BY_TYPE = {
 	greaterThanColumnOrEqual: ["column", "rhs"]
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/components/PlDataTable/state-migration.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/components/PlDataTable/state-migration.js
 /** Upgrade PlDataTableStateV2 to the latest version */
 function upgradePlDataTableStateV2(state) {
 	if (!state) return createPlDataTableStateV2();
@@ -8682,12 +11530,13 @@ function upgradePlDataTableStateV2(state) {
 			...entry,
 			filtersState: []
 		})),
-		pTableParams: createDefaultPTableParams()
+		pTableParams: createDefaultPTableParamsV7()
 	};
 	if (state.version === 3) state = createPlDataTableStateV2();
 	if (state.version === 4) state = migrateV4toV6(state);
 	if (state.version === 5) state = migrateV5toV6(state);
 	if (state.version === 6) state = migrateV6toV7(state);
+	if (state.version === 7) state = migrateV7toV8(state);
 	return state;
 }
 /** Migrate v5 to v6: unwrap `{source, labeled}` colIds in gridState. */
@@ -8698,7 +11547,7 @@ function migrateV5toV6(state) {
 			...entry,
 			gridState: unwrapV5GridState(entry.gridState)
 		})),
-		pTableParams: createDefaultPTableParams()
+		pTableParams: createDefaultPTableParamsV7()
 	};
 }
 /** Convert v5 wrapped colId JSON to bare PTableColumnSpec JSON, taking `.source`.
@@ -8755,10 +11604,7 @@ function migrateV4toV6(state) {
 	const nextId = () => ++idCounter;
 	const migratedCache = state.stateCache.map((entry) => {
 		const leaves = [];
-		for (const f of entry.filtersState) if (f.filter !== null && !f.filter.disabled) {
-			const column = canonicalizeJson(f.id);
-			leaves.push(migrateTableFilter(column, f.filter.value, nextId));
-		}
+		for (const f of entry.filtersState) if (f.filter !== null && !f.filter.disabled) leaves.push(migrateTableFilter(canonicalizeJson(f.id), f.filter.value, nextId));
 		const filtersState = leaves.length > 0 ? {
 			id: nextId(),
 			type: "and",
@@ -8786,10 +11632,11 @@ function migrateV4toV6(state) {
 			filters: distillFilterSpec(currentCache.filtersState),
 			defaultFilters: null,
 			sorting: state.pTableParams.sorting
-		} : createDefaultPTableParams()
+		} : createDefaultPTableParamsV7()
 	};
 }
-/** Migrate a single per-column PlTableFilter to a tree-based FilterSpec node */
+/** Migrate a single per-column PlTableFilter to a v7-form tree node (legacy
+*  string column ids). v7 → v8 later converts these to object form. */
 function migrateTableFilter(column, filter, nextId) {
 	const id = nextId();
 	switch (filter.type) {
@@ -8915,7 +11762,9 @@ function migrateTableFilter(column, filter, nextId) {
 		};
 	}
 }
-function createDefaultPTableParams() {
+/** Default pTableParams in the v7 shape (sorting: []). Used by intermediate
+*  migration steps that produce v6/v7 state before the v7 → v8 conversion. */
+function createDefaultPTableParamsV7() {
 	return {
 		sourceId: null,
 		hiddenColIds: null,
@@ -8924,87 +11773,232 @@ function createDefaultPTableParams() {
 		sorting: []
 	};
 }
+function createDefaultPTableParams() {
+	return {
+		sourceId: null,
+		hiddenColIds: null,
+		filters: null,
+		defaultFilters: null,
+		sorting: null
+	};
+}
 function createPlDataTableStateV2() {
 	return {
-		version: 7,
+		version: 8,
 		stateCache: [],
 		pTableParams: createDefaultPTableParams()
 	};
 }
+function migrateV7toV8(state) {
+	const newCache = state.stateCache.map((entry) => ({
+		sourceId: entry.sourceId,
+		gridState: entry.gridState,
+		sheetsState: entry.sheetsState,
+		filtersState: convertFiltersWithMeta(entry.filtersState),
+		defaultFiltersState: convertFiltersWithMeta(entry.defaultFiltersState),
+		searchString: entry.searchString
+	}));
+	const params = state.pTableParams;
+	let pTableParams;
+	if (params.sourceId === null) pTableParams = createDefaultPTableParams();
+	else pTableParams = {
+		sourceId: params.sourceId,
+		hiddenColIds: params.hiddenColIds,
+		sorting: params.sorting.length === 0 ? null : params.sorting,
+		filters: convertFiltersPlain(params.filters),
+		defaultFilters: convertFiltersPlain(params.defaultFilters)
+	};
+	return {
+		version: 8,
+		stateCache: newCache,
+		pTableParams
+	};
+}
+function convertFiltersWithMeta(node) {
+	if (node === null) return null;
+	const result = pruneFilterNode(node);
+	if (result === void 0) return null;
+	return result;
+}
+function convertFiltersPlain(node) {
+	if (node === null) return null;
+	const result = pruneFilterNode(node);
+	if (result === void 0) return null;
+	return result;
+}
+/** Recursively converts and prunes a legacy v7 filter tree. Preserves meta
+*  fields (id/isExpanded/source/isSuppressed) on non-leaf nodes. Returns
+*  `undefined` when the subtree is empty after pruning. */
+function pruneFilterNode(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const n = node;
+	if (n.type === "and" || n.type === "or") {
+		const kept = (n.filters ?? []).map((f) => pruneFilterNode(f)).filter((f) => f !== void 0);
+		if (kept.length === 0) return void 0;
+		return {
+			...n,
+			type: n.type,
+			filters: kept
+		};
+	}
+	if (n.type === "not") {
+		const inner = pruneFilterNode(n.filter);
+		if (inner === void 0) return void 0;
+		return {
+			...n,
+			type: "not",
+			filter: inner
+		};
+	}
+	return convertLegacyLeaf(n);
+}
+function convertLegacyLeaf(leaf) {
+	if (leaf.type === void 0) return leaf;
+	const result = { ...leaf };
+	if ("column" in result) {
+		const c = parseLegacyLeafColumn(result.column);
+		if (c === void 0) return void 0;
+		result.column = c;
+	}
+	if ("rhs" in result) {
+		const c = parseLegacyLeafColumn(result.rhs);
+		if (c === void 0) return void 0;
+		result.rhs = c;
+	}
+	return result;
+}
+function parseLegacyLeafColumn(s) {
+	if (typeof s !== "string") return void 0;
+	const parsed = parseJsonSafely(s);
+	if (!parsed || typeof parsed !== "object") return void 0;
+	if (!("type" in parsed) || !("id" in parsed)) return void 0;
+	const t = parsed.type;
+	if (t !== "axis" && t !== "column") return void 0;
+	return parsed;
+}
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/utils.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/utils.js
+/** Adapt a {@link ColumnRecipe} to the plain {@link RuleColumn} shape. */
+function toRuleColumn(col) {
+	return {
+		id: extractPObjectId(col.id),
+		spec: col.getSpec()
+	};
+}
+/** Check if column should be omitted from the table */
+function isColumnHidden(spec) {
+	return readAnnotation(spec, Annotation.Table.Visibility) === "hidden";
+}
 /** Check if column is hidden by default */
 function isColumnOptional(spec) {
 	return readAnnotation(spec, Annotation.Table.Visibility) === "optional";
 }
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/components/PlDataTable/labels.js
-/** Get label columns matching the provided columns from the result pool */
-function getMatchingLabelColumns(columns, allLabelColumns) {
-	const inputLabelColumns = [];
-	const inputValueColumns = [];
-	for (const column of columns) if (isLabelColumn(column.spec)) inputLabelColumns.push(column);
-	else inputValueColumns.push(column);
-	const unlabeledAxes = [];
-	for (const column of inputValueColumns) for (const axis of column.spec.axesSpec) {
-		const axisId = getAxisId(axis);
-		if (!unlabeledAxes.some((id) => matchAxisId(id, axisId))) unlabeledAxes.push(axisId);
-	}
-	for (const labelColumn of inputLabelColumns) {
-		const labelAxisId = getAxisId(labelColumn.spec.axesSpec[0]);
-		const labelMatch = unlabeledAxes.findIndex((axisId) => matchAxisId(axisId, labelAxisId));
-		if (labelMatch !== -1) unlabeledAxes.splice(labelMatch, 1);
-	}
-	const colId = (id, domain, contextDomain) => {
-		let wid = id.toString();
-		if (domain) for (const k in domain) {
-			wid += k;
-			wid += domain[k];
-		}
-		if (contextDomain) for (const k in contextDomain) {
-			wid += k;
-			wid += contextDomain[k];
-		}
-		return wid;
-	};
-	const labelColumns = [];
-	for (const labelColumn of allLabelColumns) {
-		const labelAxis = labelColumn.spec.axesSpec[0];
-		const labelAxisId = getAxisId(labelAxis);
-		const labelMatch = unlabeledAxes.findIndex((axisId) => matchAxisId(axisId, labelAxisId));
-		if (labelMatch !== -1) {
-			const axisId = unlabeledAxes[labelMatch];
-			if (Object.keys(axisId.domain ?? {}).length + Object.keys(axisId.contextDomain ?? {}).length > Object.keys(labelAxis.domain ?? {}).length + Object.keys(labelAxis.contextDomain ?? {}).length) labelColumns.push({
-				id: colId(labelColumn.id, axisId.domain, axisId.contextDomain),
-				spec: {
-					...labelColumn.spec,
-					axesSpec: [{
-						...axisId,
-						annotations: labelAxis.annotations
-					}]
-				},
-				data: labelColumn.data
-			});
-			else labelColumns.push(labelColumn);
-			unlabeledAxes.splice(labelMatch, 1);
+/** Get effective visibility for a column. Rule map lookup first, then annotation fallback. */
+function getEffectiveVisibility(col, visibilityByColId) {
+	const rule = visibilityByColId?.get(col.id);
+	if (rule !== void 0) return rule.visibility;
+	if (isColumnHidden(col.spec)) return "hidden";
+	if (isColumnOptional(col.spec)) return "optional";
+}
+/** Get ordering priority for a column. Rule map lookup first, then annotation fallback. */
+function getOrderPriority(col, orderByColId) {
+	const rule = orderByColId?.get(col.id);
+	if (rule !== void 0) return rule.priority;
+	const annotation = Number(readAnnotation(col.spec, Annotation.Table.OrderPriority));
+	return isNaN(annotation) ? void 0 : annotation;
+}
+/**
+* Evaluate display rules against a set of columns and return a map of `colId → winning rule`
+* (first-match-wins, preserving original rule order).
+*
+* Predicate-based rules (`ColumnMatcher`) are evaluated directly on the spec.
+* Selector-based rules (`ColumnSelector`) are matched via the
+* `columnsCollection` service — the inline column ids must be resolvable in
+* the active render ctx for the host to read their specs.
+*/
+function evaluateRules(rules, columns) {
+	const result = /* @__PURE__ */ new Map();
+	if (rules.length === 0 || columns.length === 0) return result;
+	const selectorRules = rules.filter((rule) => typeof rule.match !== "function");
+	const selectorHitsByRule = /* @__PURE__ */ new Map();
+	if (selectorRules.length > 0) {
+		const baseCollection = ColumnsCollection([{
+			columns: uniqBy(columns, (col) => col.id),
+			isFinal: true
+		}]);
+		for (const rule of selectorRules) {
+			const hitIds = baseCollection.filter({ include: rule.match }).getColumnIds();
+			if (hitIds.length === 0) return result;
+			selectorHitsByRule.set(rule, new Set(hitIds.map((id) => extractPObjectId(id))));
+		}
+	}
+	for (const col of columns) {
+		const colKey = extractPObjectId(col.id);
+		for (const rule of rules) if (selectorHitsByRule.get(rule)?.has(colKey) ?? false) {
+			result.set(colKey, rule);
+			break;
 		}
 	}
-	return labelColumns;
+	return result;
+}
+/**
+* Build a sidecar map `columnId → AnnotationDataStatus` derived from each
+* recipe's own status. This is *rendering* metadata — kept out of the spec
+* so it cannot perturb column identity (id-bearing spec overrides would
+* diverge the visible PTable's column ids from the full table / pframe).
+*
+* Mapping `ColumnFieldStatus` × actual byte-presence → `AnnotationDataStatus`:
+*   - `absent`                       → `"absent"`
+*   - `resolving`                    → `"computing"`
+*   - `present` + `hasColumnData()`  → `"ready"`
+*   - `present` + no bytes yet       → `"computing"`
+*
+* Intentionally scoped to visible columns — the probe is meaningful only for
+* what the user will actually see.
+*/
+function buildDataStatusMap(columns, opts = {}) {
+	return columns.reduce((acc, c) => (acc[c.id] = deriveDataStatus(c, opts), acc), {});
+}
+function deriveDataStatus(column, opts) {
+	const field = column.getDataStatus();
+	if (field === "absent") return "absent";
+	if (field === "resolving") return "computing";
+	return hasColumnData(column, opts) ? "ready" : "computing";
+}
+/** Derive labels for all table elements: columns via deriveDistinctLabels, axes from label columns. */
+function deriveAllLabels(options) {
+	const { columns, deriveLabelsOptions } = options;
+	return deriveDistinctLabels(columns.map((c) => ({
+		spec: c.spec,
+		linkerPath: c.linkerPath?.map((step) => ({ spec: step.linker.spec })),
+		qualifications: c.qualifications
+	})), deriveLabelsOptions).reduce((acc, label, index) => (acc[columns[index].id] = label, acc), {});
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPTableDefV3.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPTableDefV3.js
+/**
+* Assemble a ptable def directly from recipes. Each secondary recipe is its own
+* outer-joined subtree: `getQuery()` encodes its linker chain, and its
+* hit-/queries-qualifications are derived on the spot via {@link hitQualifications}
+* / {@link queriesQualifications} — no pre-extracted DTO. Bare leaves yield empty
+* qualifications, so plain {@link ColumnRecipe} arrays (e.g. label columns) work
+* unchanged.
+*/
 function createPTableDefV3(params) {
 	let query = {
 		type: params.primaryJoinType === "inner" ? "innerJoin" : "fullJoin",
-		entries: params.primary.map((a) => toLeaf(a.column, []))
+		entries: params.primary.map((c) => columnToJoinEntry(c, []))
 	};
 	if (params.secondary.length > 0) query = {
 		type: "outerJoin",
 		primary: {
 			entry: query,
-			qualifications: params.secondary.flatMap((g) => params.primary.flatMap((p) => g.primaryQualifications?.[p.column.id] ?? []))
+			qualifications: params.secondary.flatMap((s) => {
+				const quals = queriesQualifications(s);
+				return params.primary.flatMap((p) => quals[p.id] ?? []);
+			})
 		},
-		secondary: params.secondary.flatMap((g) => g.entries.map((e) => toJoinEntry(e)))
+		secondary: params.secondary.map((c) => columnToJoinEntry(c, hitQualifications(c)))
 	};
 	if (!isNil(params.filters)) {
 		const nonEmpty = distillFilterSpec(params.filters);
@@ -9024,7 +12018,7 @@ function createPTableDefV3(params) {
 		sortBy: params.sorting.map((s) => ({
 			expression: columnIdToExpr(s.column),
 			ascending: s.ascending,
-			nullsFirst: !s.naAndAbsentAreLeastValues
+			nullsFirst: s.naAndAbsentAreLeastValues
 		}))
 	};
 	return { query };
@@ -9038,153 +12032,392 @@ function columnIdToExpr(col) {
 		value: col.id
 	};
 }
-function toLeaf(col, qs) {
+function columnToJoinEntry(col, qualifications) {
 	return {
-		entry: {
-			type: "column",
-			column: col
-		},
-		qualifications: qs
+		entry: col.getQuery(),
+		qualifications
 	};
 }
-function toJoinEntry(e) {
-	const qs = e.qualifications ?? [];
-	if (isNil(e.linkers) || e.linkers.length === 0) return toLeaf(e.column, qs);
-	return {
-		...e.linkers.reduceRight((inner, linker) => ({
-			entry: {
-				type: "linkerJoin",
-				linker: { column: linker },
-				secondary: [inner]
-			},
-			qualifications: []
-		}), toLeaf(e.column, [])),
-		qualifications: qs
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/components/PlDataTable/columnResolver.js
+function createColumnResolver(columns, deps) {
+	const axisIds = [];
+	for (const c of columns) for (const ax of c.getSpec().axesSpec) axisIds.push(getAxisId(ax));
+	const byFullId = /* @__PURE__ */ new Map();
+	const byPObjectId = /* @__PURE__ */ new Map();
+	for (const c of columns) {
+		byFullId.set(c.id, c);
+		const pid = extractPObjectId(c.id);
+		const existing = byPObjectId.get(pid);
+		if (existing === void 0) byPObjectId.set(pid, c);
+		else if (existing.id !== c.id) deps?.warn?.(`Ambiguous PObjectId ${pid}: recipe ids ${existing.id} and ${c.id} both match — keeping first.`);
+	}
+	return (ref) => {
+		if (ref.type === "axis") return axisIds.some((a) => matchAxisId(ref.id, a)) ? ref : void 0;
+		const hit = byFullId.get(ref.id) ?? byPObjectId.get(extractPObjectId(ref.id));
+		if (hit === void 0) return void 0;
+		return {
+			type: "column",
+			id: hit.id
+		};
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPTableDefV2.js
-function createPTableDefV2(params) {
-	let coreColumns = params.columns;
-	const secondaryColumns = [];
-	if (isFunction(params.coreColumnPredicate)) {
-		coreColumns = [];
-		for (const c of params.columns) if (params.coreColumnPredicate(getColumnIdAndSpec(c))) coreColumns.push(c);
-		else secondaryColumns.push(c);
-	}
-	secondaryColumns.push(...params.labelColumns);
-	return createPTableDefV3({
-		primary: coreColumns.map((column) => ({ column })),
-		secondary: secondaryColumns.map((column) => ({ entries: [{ column }] })),
-		primaryJoinType: params.coreJoinType,
-		filters: params.filters,
-		sorting: params.sorting
-	});
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/discoverColumns.js
+/**
+* Discover columns from sources/anchors and split them into primary
+* (direct anchor hits — zero-hop, query is a bare column) and secondary
+* (reached via a linker chain, query carries a join).
+*/
+function discoverTableColumns(ctx, options) {
+	const discoveredColumns = ColumnsCollection(options.sources, { ctx: ctx.ctx }).discover({
+		...options.selector,
+		anchors: options.anchors
+	}).getColumns();
+	const primary = [];
+	const secondary = [];
+	for (const col of discoveredColumns) if (isLeafColumn(col)) primary.push(col);
+	else secondary.push(col);
+	return {
+		primary,
+		secondary
+	};
 }
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.27/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPlDataTableV2.js
 /**
-* Create p-table spec and handle given ui table state
+* Discover label columns matching the axes of the given value columns from
+* ctx providers. Returns a list of label {@link ColumnRecipe}s.
 *
-* @deprecated This version of createPlDataTable is deprecated and will be removed in future. Please migrate to v3 by switching to the new options format and providing necessary information for column discovery and display configuration. See createPlDataTableOptionsV3 for details.
-* @param ctx context
-* @param columns column list
-* @param tableState table ui state
-* @returns PlAgDataTableV2 table source
+* Primary columns are used as anchors for axis-aware label discovery.
+* `maxHops` is taken from the longest linker chain present in `columns`.
 */
-function createPlDataTableV2(ctx, columns, tableState, options) {
-	if (columns.length === 0) return void 0;
-	const tableStateNormalized = upgradePlDataTableStateV2(tableState);
-	const allLabelColumns = getAllLabelColumns(ctx.resultPool) ?? [];
-	let fullLabelColumns = getMatchingLabelColumns(columns, allLabelColumns);
-	fullLabelColumns = deriveLabels(fullLabelColumns, identity, { includeNativeLabel: true }).map((v) => {
-		return {
-			...v.value,
-			spec: {
-				...v.value.spec,
-				annotations: {
-					...v.value.spec.annotations,
-					[Annotation.Label]: v.label
-				}
-			}
-		};
+function discoverLabelColumns(ctx, primary, columns) {
+	if (columns.length === 0) return [];
+	const axes = columns.flatMap((col) => col.getSpec().axesSpec);
+	return ColumnsCollection(void 0, { ctx: ctx.ctx }).discover({
+		include: axes.map((a) => ({
+			name: {
+				type: "exact",
+				value: PColumnName.Label
+			},
+			axes: [{ name: {
+				type: "exact",
+				value: a.name
+			} }]
+		})),
+		anchors: Object.fromEntries(primary.map((col, i) => [`anchor_${i}`, col.getSpec()])),
+		maxHops: columns.reduce((acc, c) => Math.max(acc, collectLinkerIds(c).length), 0)
+	}).getColumns();
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPlDataTableV3.js
+function createPlDataTableV3(ctx, options) {
+	const state = upgradePlDataTableStateV2(options.tableState);
+	const primaryJoinType = options.primaryJoinType ?? "full";
+	const resolved = resolveInputColumns(ctx, options);
+	if (resolved === void 0) return void 0;
+	const { primary, secondary } = resolved;
+	if (primary.length === 0) return void 0;
+	const { direct, linked } = splitByTopology(secondary);
+	const derivedLabels = deriveAllLabels({
+		columns: [...primary, ...secondary].filter((c) => !isColumnHidden(c.getSpec())).map(toLabelableColumn),
+		deriveLabelsOptions: {
+			includeNativeLabel: true,
+			...options.labelsOptions
+		}
 	});
-	const fullColumns = [...columns, ...fullLabelColumns];
-	const fullColumnsIds = [...uniqueBy(fullColumns.flatMap((c) => c.spec.axesSpec.map((a) => getAxisId(a))), (a) => canonicalizeJson(a)).map((a) => ({
-		type: "axis",
-		id: a
-	})), ...fullColumns.map((c) => ({
-		type: "column",
-		id: c.id
-	}))];
-	const fullColumnsIdsSet = new Set(fullColumnsIds.map((c) => canonicalizeJson(c)));
-	const isValidColumnId = (id) => fullColumnsIdsSet.has(id);
-	const filters = tableStateNormalized.pTableParams.filters;
-	const defaultFilters = options?.filters ?? void 0;
-	const firstInvalidFilterColumn = (filters !== null ? collectFilterSpecColumns(filters) : []).find((col) => !isValidColumnId(col));
-	if (firstInvalidFilterColumn) throw new Error(`Invalid filter column ${firstInvalidFilterColumn}: column reference does not match the table columns`);
-	const firstInvalidDefaultFilterColumn = (defaultFilters !== void 0 ? collectFilterSpecColumns(defaultFilters) : []).find((col) => !isValidColumnId(col));
-	if (firstInvalidDefaultFilterColumn) throw new Error(`Invalid default filter column ${firstInvalidDefaultFilterColumn}: column reference does not match the table columns`);
-	const userSorting = tableStateNormalized.pTableParams.sorting;
-	const sorting = (isEmpty(userSorting) ? options?.sorting : userSorting) ?? [];
-	const firstInvalidSortingColumn = sorting.find((s) => !isValidColumnId(canonicalizeJson(s.column)));
-	if (firstInvalidSortingColumn) throw new Error(`Invalid sorting column ${JSON.stringify(firstInvalidSortingColumn.column)}: column reference does not match the table columns`);
-	const coreJoinType = options?.coreJoinType ?? "full";
-	const fullDef = createPTableDefV2({
-		columns,
-		labelColumns: fullLabelColumns,
-		coreJoinType,
+	const allColumnsForRules = [
+		...primary,
+		...direct,
+		...linked,
+		...collectLinkerSnapshots(linked)
+	];
+	const visibilityByColId = evaluateRules(options.displayOptions?.visibility ?? [], allColumnsForRules);
+	const orderByColId = evaluateRules(options.displayOptions?.ordering ?? [], allColumnsForRules);
+	const resolver = createColumnResolver([
+		...primary,
+		...direct,
+		...linked.flatMap((lc) => [...collectLinkerColumns(lc), lc])
+	], { warn: ctx.logWarn.bind(ctx) });
+	const remapedDefaultFilters = remapFilterColumnIds(options.filters, resolver);
+	const filters = filterFilters(concatFilters(state.pTableParams.filters, state.pTableParams.defaultFilters ?? remapedDefaultFilters), resolver);
+	const sorting = filterSorting(resolveSorting(state.pTableParams.sorting, remapSortingColumnIds(options.sorting, resolver)), resolver);
+	const fullDef = createPTableDefV3({
+		primaryJoinType,
+		primary,
+		secondary: [...direct, ...linked],
 		filters,
-		sorting,
-		coreColumnPredicate: options?.coreColumnPredicate
+		sorting
 	});
 	const fullHandle = ctx.createPTableV2(fullDef);
-	const pframeHandle = ctx.createPFrame(fullColumns);
-	if (!fullHandle || !pframeHandle) return void 0;
-	const hiddenColumns = new Set((() => {
-		if (coreJoinType === "inner") return [];
-		const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;
-		if (hiddenColIds !== null) return hiddenColIds.filter((s) => s.type === "column").map((s) => s.id);
-		return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);
-	})());
-	columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));
-	const coreColumnPredicate = options?.coreColumnPredicate;
-	if (coreColumnPredicate) columns.flatMap((c) => coreColumnPredicate(getColumnIdAndSpec(c)) ? [c.id] : []).forEach((c) => hiddenColumns.delete(c));
-	sorting.map((s) => s.column).filter((c) => c.type === "column").forEach((c) => hiddenColumns.delete(c.id));
-	if (filters) collectFilterSpecColumns(filters).flatMap((c) => {
-		const obj = parseJson(c);
-		return obj.type === "column" ? [obj.id] : [];
-	}).forEach((c) => hiddenColumns.delete(c));
-	const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
-	const visibleLabelColumns = getMatchingLabelColumns(visibleColumns.map(getColumnIdAndSpec), allLabelColumns);
-	if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns])) return void 0;
-	const visibleDef = createPTableDefV2({
-		columns: visibleColumns,
-		labelColumns: visibleLabelColumns,
-		coreJoinType,
-		filters,
+	const pframeHandle = ctx.createPFrame(uniq([
+		...primary.map((v) => extractPObjectId(v.id)),
+		...direct.map((v) => extractPObjectId(v.id)),
+		...linked.map((v) => extractPObjectId(v.id))
+	]));
+	const hiddenSpecs = state.pTableParams.hiddenColIds;
+	const hiddenColumnIds = computeHiddenColumns({
+		columns: [
+			...primary,
+			...direct,
+			...linked
+		],
+		visibilityByColId,
 		sorting,
-		coreColumnPredicate
+		filters,
+		hiddenSpecs
+	});
+	const visible = {
+		primary,
+		direct: direct.filter((c) => !hiddenColumnIds.has(c.id)),
+		linked: linked.filter((c) => !hiddenColumnIds.has(c.id))
+	};
+	const visibleDef = createPTableDefV3({
+		primaryJoinType,
+		primary,
+		secondary: [...visible.direct, ...visible.linked],
+		filters,
+		sorting
 	});
 	const visibleHandle = ctx.createPTableV2(visibleDef);
-	if (!visibleHandle) return void 0;
+	const columnsMeta = buildColumnsMeta({
+		fullColumns: [
+			...primary,
+			...direct,
+			...linked
+		],
+		visibleColumns: [
+			...visible.primary,
+			...visible.direct,
+			...visible.linked
+		],
+		primaryColumns: primary,
+		derivedLabels,
+		visibilityByColId,
+		orderByColId
+	});
 	return {
-		sourceId: tableStateNormalized.pTableParams.sourceId,
+		sourceId: state.pTableParams.sourceId,
 		fullTableHandle: fullHandle,
 		fullPframeHandle: pframeHandle,
 		visibleTableHandle: visibleHandle,
-		defaultFilters
+		defaultFilters: remapedDefaultFilters,
+		columnsMeta
 	};
 }
-function getAllLabelColumns(resultPool) {
-	return new PColumnCollection().addAxisLabelProvider(resultPool).addColumnProvider(resultPool).getColumns({
-		name: PColumnName.Label,
-		axes: [{}]
-	}, {
-		dontWaitAllData: true,
-		overrideLabelAnnotation: false
+/** Normalize either option branch into a {primary, secondary} pair of recipes. */
+function resolveInputColumns(ctx, options) {
+	if ("primaryColumns" in options) {
+		const primary = options.primaryColumns;
+		const secondary = options.columns ?? [];
+		const labels = discoverLabelColumns(ctx, primary, [...primary, ...secondary]);
+		const primaryIds = new Set(primary.map((c) => c.id));
+		return {
+			primary,
+			secondary: dedupColumns([...secondary, ...labels].filter((c) => !primaryIds.has(c.id)), (c) => c.id, (c) => c.getSpec())
+		};
+	}
+	if (isPlainObject(options.columns)) return discoverTableColumns(ctx, options.columns);
+}
+/** Split secondary recipes by query topology: leaves (no linker chain) vs joined. */
+function splitByTopology(columns) {
+	const direct = [];
+	const linked = [];
+	for (const c of columns) if (isLeafColumn(c)) direct.push(c);
+	else linked.push(c);
+	return {
+		direct,
+		linked
+	};
+}
+/** All linker recipes across the given linked columns, deduped by id. */
+function collectLinkerSnapshots(linked) {
+	return uniqueBy(linked.flatMap((c) => collectLinkerColumns(c)), (c) => c.id);
+}
+function toLabelableColumn(col) {
+	return {
+		id: col.id,
+		spec: col.getSpec(),
+		linkerPath: collectLinkerColumns(col).map((linker) => ({ linker: { spec: linker.getSpec() } })),
+		qualifications: {
+			forHit: [...hitQualifications(col)],
+			forQueries: queriesQualifications(col)
+		}
+	};
+}
+/**
+* Compute display metadata as a sidecar keyed by each emitted column's
+* `ColumnUniversalId` (and axis `AxisId`), instead of baking it into the specs
+* via `withSpecs`. Spec overrides change a recipe's id, so the same physical
+* column reached two ways would diverge into two ids and render twice; keeping
+* meta out of the spec preserves identity and lets dedup collapse such cases.
+* The UI overlays this onto the engine-emitted specs at render time.
+*/
+function buildColumnsMeta(params) {
+	const { fullColumns, visibleColumns, primaryColumns, derivedLabels } = params;
+	const { visibilityByColId, orderByColId } = params;
+	const visibleStatus = buildDataStatusMap(visibleColumns);
+	const columns = fullColumns.reduce((acc, c) => {
+		const rc = toRuleColumn(c);
+		acc[c.id] = {
+			label: derivedLabels[c.id],
+			visibility: getEffectiveVisibility(rc, visibilityByColId),
+			order: getOrderPriority(rc, orderByColId),
+			status: visibleStatus[c.id]
+		};
+		return acc;
+	}, {});
+	const primaryAxisKeys = new Set(primaryColumns.flatMap((c) => c.getSpec().axesSpec.map((a) => canonicalizeAxisId(a))));
+	return {
+		columns,
+		axes: fullColumns.reduce((acc, c) => c.getSpec().axesSpec.reduce((inner, ax) => {
+			const key = canonicalizeAxisId(ax);
+			if (inner[key] === void 0) inner[key] = { hidden: !primaryAxisKeys.has(key) };
+			return inner;
+		}, acc), {})
+	};
+}
+/** Drop filter leaves whose column references cannot be resolved; rewrite the
+*  resolvable ones through the resolver. Prune empty and/or/not groups. */
+function filterFilters(filters, resolver) {
+	if (isNil$1(filters)) return filters;
+	const rewriteLeaf = (leaf) => {
+		if (leaf.type === void 0) return leaf;
+		const result = { ...leaf };
+		if ("column" in result) {
+			const c = resolver(result.column);
+			if (isNil$1(c)) return void 0;
+			result.column = c;
+		}
+		if ("rhs" in result) {
+			const c = resolver(result.rhs);
+			if (isNil$1(c)) return void 0;
+			result.rhs = c;
+		}
+		return result;
+	};
+	const prune = (node) => {
+		if (node.type === "and" || node.type === "or") {
+			const kept = node.filters.map((f) => prune(f)).filter((f) => !isNil$1(f));
+			if (kept.length === 0) return void 0;
+			return {
+				type: node.type,
+				filters: kept
+			};
+		}
+		if (node.type === "not") {
+			const inner = prune(node.filter);
+			return isNil$1(inner) ? void 0 : {
+				type: "not",
+				filter: inner
+			};
+		}
+		return rewriteLeaf(node);
+	};
+	return prune(filters);
+}
+/** Merge two filter trees into one AND-combined tree. Returns the non-nil one if the other is nil. */
+function concatFilters(a, b) {
+	if (isNil$1(a)) return b;
+	if (isNil$1(b)) return a;
+	return {
+		...a,
+		filters: [...a.filters, ...b.filters]
+	};
+}
+/** Pick user sorting from state if set, otherwise fall back to options default.
+*  null = user has not touched sorting → use default;
+*  [] = user has explicitly cleared sorting → no sorting (default ignored). */
+function resolveSorting(userSorting, defaultSorting) {
+	return (isNil$1(userSorting) ? defaultSorting : userSorting) ?? [];
+}
+/** Rewrite sorting entries through the resolver; drop those that fail to resolve. */
+function filterSorting(sorting, resolver) {
+	return sorting.flatMap((s) => {
+		const col = resolver(s.column);
+		return isNil$1(col) ? [] : [{
+			...s,
+			column: col
+		}];
 	});
 }
+/** Determine which columns should be hidden based on state or optional-column defaults.
+*  Keyed by the recipe's logical {@link ColumnUniversalId} (rich) — variants of
+*  the same physical column are independently visible/hidden. */
+function computeHiddenColumns(params) {
+	const { columns, visibilityByColId, sorting, filters, hiddenSpecs } = params;
+	const visibilityOf = (c) => getEffectiveVisibility(toRuleColumn(c), visibilityByColId);
+	const alwaysHidden = columns.filter((c) => visibilityOf(c) === "hidden").map((c) => c.id);
+	const optionalHidden = !isNil$1(hiddenSpecs) ? hiddenSpecs.filter((s) => s.type === "column").map((s) => s.id) : columns.filter((c) => visibilityOf(c) === "optional").map((c) => c.id);
+	const initial = [...alwaysHidden, ...optionalHidden];
+	const preserved = collectPreservedColumnIds(sorting, filters);
+	return new Set(initial.filter((id) => !preserved.has(id)));
+}
+/** Collect IDs of columns that must remain visible (sorted, filtered). */
+function collectPreservedColumnIds(sorting, filters) {
+	const sortedIds = (sorting ?? []).map((s) => s.column).filter((c) => c.type === "column").map((c) => c.id);
+	const filterIds = !isNil$1(filters) ? collectFilterSpecColumns(filters).flatMap((c) => c.type === "column" ? [c.id] : []) : [];
+	return /* @__PURE__ */ new Set([...sortedIds, ...filterIds]);
+}
+/** Remap column references in sorting entries through the resolver.
+*  Unresolved entries are dropped with a warning (best-effort contract). */
+function remapSortingColumnIds(sorting, resolver) {
+	return sorting?.flatMap((s) => {
+		const col = resolver(s.column);
+		if (isNil$1(col)) {
+			console.warn(`Sorting column ${JSON.stringify(s.column)} does not match any discovered column — dropped.`);
+			return [];
+		}
+		return [{
+			...s,
+			column: col
+		}];
+	});
+}
+/** Remap column references in a filter tree through the resolver.
+*  Unresolved leaves are dropped with a warning; empty groups are pruned. */
+function remapFilterColumnIds(filters, resolver) {
+	if (isNil$1(filters)) return filters;
+	const mapLeaf = (leaf) => {
+		if (leaf.type === void 0) return leaf;
+		const result = { ...leaf };
+		if ("column" in result) {
+			const c = resolver(result.column);
+			if (isNil$1(c)) {
+				console.warn(`Filter column ${JSON.stringify(result.column)} does not match any discovered column — dropped.`);
+				return;
+			}
+			result.column = c;
+		}
+		if ("rhs" in result) {
+			const c = resolver(result.rhs);
+			if (isNil$1(c)) {
+				console.warn(`Filter rhs ${JSON.stringify(result.rhs)} does not match any discovered column — dropped.`);
+				return;
+			}
+			result.rhs = c;
+		}
+		return result;
+	};
+	const prune = (node) => {
+		if (node.type === "and" || node.type === "or") {
+			const kept = node.filters.map((f) => prune(f)).filter((f) => !isNil$1(f));
+			if (kept.length === 0) return void 0;
+			return {
+				type: node.type,
+				filters: kept
+			};
+		}
+		if (node.type === "not") {
+			const inner = prune(node.filter);
+			return isNil$1(inner) ? void 0 : {
+				type: "not",
+				filter: inner
+			};
+		}
+		return mapLeaf(node);
+	};
+	return prune(filters);
+}
 (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	exports = module.exports = stringify;
 	exports.getSerialize = serializer;
@@ -9254,8 +12487,8 @@ const StopCodonReplacements = objectType({
 	opal: stringType().optional()
 }).optional();
 const BlockArgsValidBase = objectType({
-	defaultBlockLabel: stringType(),
-	customBlockLabel: stringType(),
+	defaultBlockLabel: stringType().optional(),
+	customBlockLabel: stringType().optional(),
 	input: PlRef,
 	inputLibrary: PlRef.optional(),
 	libraryFile: stringType().transform((v) => v).optional(),
@@ -9544,9 +12777,8 @@ const platforma$1 = BlockModelV3.create(dataModel).prerunArgs((data) => ({
 }).output("started", (ctx) => ctx.outputs !== void 0).output("done", (ctx) => {
 	return ctx.outputs !== void 0 ? parseResourceMap(ctx.outputs?.resolve("clns"), (_acc) => true, false).data.map((e) => e.key[0]) : void 0;
 }).outputWithStatus("clones", (ctx) => {
-	const collection = ctx.outputs?.resolve("clonotypes")?.parsePObjectCollection();
-	if (collection === void 0) return void 0;
-	const pColumns = Object.values(collection).filter(isPColumn);
+	const pColumns = ctx.outputs?.resolve("clonotypes")?.getPColumns();
+	if (pColumns === void 0) return void 0;
 	return ctx.createPFrame(pColumns);
 }).retentiveOutput("inputOptions", (ctx) => {
 	return ctx.resultPool.getOptions((v) => {
@@ -9585,8 +12817,12 @@ const platforma$1 = BlockModelV3.create(dataModel).prerunArgs((data) => ({
 		assertFieldType: "Input",
 		allowPermanentAbsence: true
 	})?.getPColumns();
-	if (pCols === void 0) return;
-	return createPlDataTableV2(ctx, pCols, ctx.data.tableState);
+	if (pCols === void 0 || pCols.length === 0) return;
+	return createPlDataTableV3(ctx, {
+		primaryColumns: [ColumnLazy.fromColumn(pCols[0])],
+		columns: pCols.slice(1).map((c) => ColumnLazy.fromColumn(c)),
+		tableState: ctx.data.tableState
+	});
 }).output("rawTsvs", (ctx) => {
 	if (ctx.outputs === void 0) return void 0;
 	const pCols = ctx.outputs?.resolve("clonotypeTables")?.getPColumns();