@milaboratories/milaboratories.ui-examples 1.4.0 → 1.4.1

package/dist/index.js

@@ -4453,13 +4453,6 @@ objectType({
 function assertNever(x) {
 	throw new Error("Unexpected object: " + x);
 }
-/**
-* Return unique entries of the array by the provided id
-* For each id, the last entry is kept
-*/
-function uniqueBy(array, makeId) {
-	return [...new Map(array.map((e) => [makeId(e), e])).values()];
-}
 //#endregion
 //#region ../../../../lib/model/common/dist/drivers/pframe/data_info.js
 /**
@@ -4934,7 +4927,7 @@ function hasCycleOfParents(axisSpec) {
 }
 /** Create list of normalized axisSpec (parents are in array of specs, not indexes) */
 function getNormalizedAxesList(axes) {
-	if (!axes.length) return [];
+	if (axes.length === 0) return [];
 	const modifiedAxes = axes.map((axis) => {
 		const { parentAxes: _, ...copiedRest } = axis;
 		return {
@@ -5074,20 +5067,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)
@@ -5098,8 +5094,8 @@ function traverseQuerySpec(query, visitor) {
 	return visitor.node ? visitor.node(result) : result;
 }
 /** Recursively maps all column references in a SpecQuery tree. */
-function mapSpecQueryColumns(query, cb) {
-	return traverseQuerySpec(query, { column: cb });
+function mapSpecQueryColumns(query, visitor) {
+	return traverseQuerySpec(query, visitor);
 }
 //#endregion
 //#region ../../../../lib/model/common/dist/drivers/pframe/table_calculate.js
@@ -5109,8 +5105,8 @@ function mapPTableDef(def, cb) {
 		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,14 +5155,325 @@ function getPTableColumnId(spec) {
 	}
 }
 //#endregion
+//#region ../../../../lib/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 ../../../../lib/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 ../../../../lib/util/helpers/dist/utils.js
+function isNil$1(v) {
+	return v === null || v === void 0;
+}
+Array.isArray;
+//#endregion
+//#region ../../../../lib/util/helpers/dist/error.js
+function throwError(v) {
+	if (typeof v === "string") throw new Error(v);
+	else throw v;
+}
+//#endregion
+//#region ../../../../lib/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.39.10/node_modules/es-toolkit/dist/function/identity.mjs
+function identity(x) {
+	return x;
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/es-toolkit@1.39.10/node_modules/es-toolkit/dist/predicate/isFunction.mjs
+function isFunction(value) {
+	return typeof value === "function";
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/es-toolkit@1.39.10/node_modules/es-toolkit/dist/predicate/isNil.mjs
+function isNil(x) {
+	return x == null;
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/es-toolkit@1.39.10/node_modules/es-toolkit/dist/predicate/isString.mjs
+function isString(value) {
+	return typeof value === "string";
+}
+//#endregion
 //#region ../../../../lib/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 ../../../../lib/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 ../../../../lib/model/common/dist/drivers/pframe/spec/anchored.js
@@ -5415,52 +5722,6 @@ function isAnchorAxisRef(value) {
 	return typeof value === "object" && "anchor" in value;
 }
 //#endregion
-//#region ../../../../lib/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 ../../../../lib/model/common/dist/drivers/pframe/spec/selectors.js
 /**
 * Determines if an axis ID matches an axis selector.
@@ -5554,18 +5815,6 @@ function deriveNativeId(spec) {
 	return (0, import_canonicalize.default)(result);
 }
 //#endregion
-//#region ../../../../lib/util/helpers/dist/utils.js
-function isNil$1(v) {
-	return v === null || v === void 0;
-}
-Array.isArray;
-//#endregion
-//#region ../../../../lib/util/helpers/dist/error.js
-function throwError(v) {
-	if (typeof v === "string") throw new Error(v);
-	else throw v;
-}
-//#endregion
 //#region ../../../../lib/model/common/dist/drivers/pframe/linker_columns.js
 var LinkerMap = class LinkerMap {
 	/** Graph of linkers connected by axes (single or grouped by parents) */
@@ -5795,6 +6044,50 @@ function mapValueInVOE(voe, cb) {
 	} : voe;
 }
 //#endregion
+//#region ../../../../lib/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 ../../../../lib/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 } = (() => {
@@ -5892,6 +6185,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}`);
@@ -5915,26 +6230,228 @@ function buildMethodMap(pick) {
 buildMethodMap(getServiceUiMethods);
 buildMethodMap(getServiceModelMethods);
 //#endregion
-//#region ../../../../sdk/model/dist/render/accessor.js
-function ifDef(value, cb) {
-	return value === void 0 ? void 0 : cb(value);
+//#region ../../../../lib/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 ../../../../lib/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 ../../../../lib/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 ../../../../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;
@@ -5961,7 +6478,7 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 		}));
 		return this.resolveWithCommon({}, ...transformedSteps);
 	}
-	resolveAny(...steps) {
+	traverse(...steps) {
 		return this.resolveWithCommon({}, ...steps);
 	}
 	resolveWithCommon(commonOptions, ...steps) {
@@ -6007,6 +6524,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);
 	}
@@ -6043,9 +6563,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;
@@ -6054,9 +6581,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;
@@ -6067,15 +6592,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
 	*/
@@ -6167,8 +6683,8 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 };
 //#endregion
 //#region ../../../../sdk/model/dist/render/internal.js
-const StagingAccessorName = "staging";
 const MainAccessorName = "main";
+const StagingAccessorName = "staging";
 //#endregion
 //#region ../../../../sdk/model/dist/render/util/axis_filtering.js
 function filterDataInfoEntries(dataInfoEntries, axisFilters) {
@@ -6234,46 +6750,229 @@ function filterDataInfoEntries(dataInfoEntries, axisFilters) {
 	}
 }
 //#endregion
-//#region ../../../../node_modules/.pnpm/es-toolkit@1.39.10/node_modules/es-toolkit/dist/function/identity.mjs
-function identity(x) {
-	return x;
+//#region ../../../../sdk/model/dist/labels/linked_column_postfix.js
+/**
+* Structural postfix derivation for linked columns (phase 2 of `deriveDistinctLabels`).
+*
+* A linked column is
+* reached by a CHAIN of linkers, and we distinguish two such columns by the same ideology the main
+* algorithm uses — "find the minimal difference, escalate until unique" — over two dimensions:
+*
+*   - root:    the single source axis of the chain, derived from `linkers[0]` (one of its axesSpec).
+*              This is "the source" — it's what we prefer to show ("difference of sources").
+*   - linkers: the linker chain itself (by `LinkLabel`), a per-step fallback used only where roots
+*              coincide.
+*
+* Nothing is stored redundantly: the caller passes the linker path (`linkers`) and the hit spec;
+* root and every token are computed on the fly. The caller also supplies the `stem` (label+trace+
+* quals from the existing single-entity machinery); this module only adds the path postfix, and
+* only where stems collide.
+*/
+function defaultLinkerFormatter(parts) {
+	const chain = parts.linkers.map((l) => l.text).join(" > ");
+	const pieces = [parts.root?.text, chain || void 0].filter((p) => !isNil(p));
+	return pieces.length === 0 ? "" : `via ${pieces.join(" ")}`;
 }
-//#endregion
-//#region ../../../../node_modules/.pnpm/es-toolkit@1.39.10/node_modules/es-toolkit/dist/predicate/isFunction.mjs
-function isFunction(value) {
-	return typeof value === "function";
+function extractAxisIdentity(axis) {
+	const id = getAxisId(axis);
+	return {
+		label: readAnnotation(axis, Annotation.Label)?.trim() || void 0,
+		name: id.name,
+		domain: id.domain,
+		contextDomain: id.contextDomain
+	};
 }
-//#endregion
-//#region ../../../../node_modules/.pnpm/es-toolkit@1.39.10/node_modules/es-toolkit/dist/predicate/isNil.mjs
-function isNil(x) {
-	return x == null;
+/**
+* A linker is named ONLY by its human label (`LinkLabel`/`Label`) — never by its technical column
+* name. Returns `undefined` for an unlabeled linker, which callers treat as "not renderable": such a
+* step is skipped, and disambiguation falls to another step or the root.
+*/
+function extractLinkerIdentity(linker) {
+	const label = (readAnnotation(linker, Annotation.LinkLabel) ?? readAnnotation(linker, Annotation.Label))?.trim();
+	return label ? {
+		label,
+		name: label
+	} : void 0;
+}
+/** Domain keys where `mine` differs from at least one competitor. */
+function differingKeys(mine, others) {
+	const my = mine ?? {};
+	const diffKeys = /* @__PURE__ */ new Set();
+	for (const o of others) {
+		const od = o ?? {};
+		for (const k of Object.keys(my)) if (my[k] !== od[k]) diffKeys.add(k);
+		for (const k of Object.keys(od)) if (my[k] !== od[k]) diffKeys.add(k);
+	}
+	return [...diffKeys];
+}
+function renderWithDomain(base, keys, domain) {
+	if (keys.length === 0) return base;
+	const d = domain ?? {};
+	return `${base}[${keys.map((k) => `${k}=${d[k] ?? "∅"}`).join(", ")}]`;
+}
+/**
+* Minimal token distinguishing `mine` from `others`: label → name → only the differing domain keys.
+* Falls back to the bare label/name when indistinguishable at this dimension (another one covers it).
+*/
+function deriveToken(mine, others) {
+	const base = mine.label ?? mine.name;
+	if (mine.label !== void 0 && others.every((o) => o.label !== mine.label)) return mine.label;
+	if (others.every((o) => o.name !== mine.name)) return base;
+	const dk = differingKeys(mine.domain, others.map((o) => o.domain));
+	if (dk.length > 0) return renderWithDomain(base, dk, mine.domain);
+	const ck = differingKeys(mine.contextDomain, others.map((o) => o.contextDomain));
+	if (ck.length > 0) return renderWithDomain(base, ck, mine.contextDomain);
+	return base;
+}
+/**
+* The chain's single root: the source-side axis of `linkers[0]`. A linker bridges two axis groups;
+* the side facing the next hop (`linkers[1]`, or the hit for a single-linker chain) is the target,
+* the other side is the source → its axis is the root. `undefined` if `linkers[0]` is not a
+* well-formed two-group linker.
+*/
+function extractRoot(hit, linkers) {
+	const first = linkers[0];
+	if (first === void 0) return void 0;
+	const axes = first.axesSpec;
+	if (axes.length !== 2) return void 0;
+	const second = linkers[1] ?? hit;
+	return axes.find((a) => !second.axesSpec.some((b) => b.name === a.name));
+}
+const ABSENT = "__ABSENT__";
+function deriveSlotKey(group, slot, row) {
+	if (slot.kind === "root") {
+		const r = group.roots[row];
+		return r === void 0 ? ABSENT : canonicalizeJson(getAxisId(r));
+	} else {
+		const l = group.entries[row].linkers?.[slot.i];
+		const id = l && extractLinkerIdentity(l);
+		return isNil(id) ? ABSENT : canonicalizeJson(id);
+	}
+}
+function deriveSlotToken(group, slot, row) {
+	if (slot.kind === "root") {
+		const r = group.roots[row];
+		if (r === void 0) return void 0;
+		const comp = group.roots.filter((o, j) => j !== row && !isNil(o)).map((o) => extractAxisIdentity(o));
+		return deriveToken(extractAxisIdentity(r), comp);
+	}
+	const l = group.entries[row].linkers?.[slot.i];
+	const id = l && extractLinkerIdentity(l);
+	if (isNil(id)) return void 0;
+	return deriveToken(id, group.entries.filter((_, j) => j !== row).map((e) => e.linkers?.[slot.i]).map((x) => x ? extractLinkerIdentity(x) : void 0).filter((x) => !isNil(x)));
+}
+function getDiscriminates(group, slot) {
+	return new Set(group.entries.map((_, r) => deriveSlotKey(group, slot, r))).size > 1;
+}
+/** Render one row against a chosen slot set: the distinguishing root + linker pieces, formatted. */
+function renderRow(group, slots, row) {
+	const rootSpec = group.roots[row];
+	const rootText = slots.some((s) => s.kind === "root") ? deriveSlotToken(group, { kind: "root" }, row) : void 0;
+	const root = rootSpec !== void 0 && rootText !== void 0 ? {
+		spec: rootSpec,
+		text: rootText
+	} : void 0;
+	const linkers = slots.filter((s) => s.kind === "linker").sort((a, b) => a.i - b.i).map((s) => {
+		const spec = group.entries[row].linkers?.[s.i];
+		const text = deriveSlotToken(group, s, row);
+		return spec !== void 0 && text !== void 0 ? {
+			spec,
+			text
+		} : void 0;
+	}).filter((l) => !isNil(l));
+	if (root === void 0 && linkers.length === 0) return "";
+	return group.format({
+		root,
+		linkers
+	}, group.entries[row].hit, group.indices[row]) || "";
+}
+function renderAll(group, slots) {
+	return group.entries.map((_, r) => renderRow(group, slots, r));
+}
+function allUnique(rendered) {
+	return new Set(rendered).size === rendered.length;
+}
+/**
+* Minimal slot set that makes the group unique. Escalate by priority (root, then linkers by step),
+* then drop any redundant slot; render every row symmetrically against the result.
+*
+* KNOWN LIMITATION (review point): symmetric render can over-decorate a row in a mixed group (e.g.
+* `via Sample MapperA` where `via Sample` alone is already unique for that row). Per-row trimming is
+* a generalized `dropRedundantLinkerSuffix`; naive greedy trimming is unstable, so it's deferred.
+*/
+function resolveGroup(entries, indices, format) {
+	const group = {
+		entries,
+		roots: entries.map((e) => e.hit && e.linkers?.length ? extractRoot(e.hit, e.linkers) : void 0),
+		indices,
+		format
+	};
+	const maxLen = Math.max(0, ...entries.map((e) => e.linkers?.length ?? 0));
+	const escalated = [{ kind: "root" }, ...Array.from({ length: maxLen }, (_, i) => ({
+		kind: "linker",
+		i
+	}))].reduce((acc, slot) => allUnique(renderAll(group, acc)) || !getDiscriminates(group, slot) ? acc : (acc.push(slot), acc), []);
+	return renderAll(group, escalated.reduce((acc, slot) => {
+		const trial = acc.filter((s) => s !== slot);
+		return allUnique(renderAll(group, trial)) ? trial : acc;
+	}, escalated));
+}
+/**
+* Full label per entry: `stem` plus, where stems collide, a minimal postfix distinguishing the
+* linked columns by the difference between their sources.
+*/
+function derivePostfixes(entries, format = defaultLinkerFormatter) {
+	const postfix = [...entries.reduce((acc, e, idx) => acc.set(e.stem, [...acc.get(e.stem) ?? [], idx]), /* @__PURE__ */ new Map()).values()].reduce((acc, idxs) => {
+		if (idxs.length < 2) return acc;
+		const resolved = resolveGroup(idxs.map((i) => entries[i]), idxs, format);
+		return idxs.reduce((m, i, k) => m.set(i, resolved[k]), acc);
+	}, /* @__PURE__ */ new Map());
+	return entries.map((e, i) => {
+		const p = postfix.get(i);
+		return p ? `${e.stem} ${p}` : e.stem;
+	});
 }
 //#endregion
 //#region ../../../../sdk/model/dist/labels/derive_distinct_labels.js
 const DISTANCE_PENALTY = .001;
 const LABEL_TYPE = "__LABEL__";
 const LABEL_TYPE_FULL = "__LABEL__@1";
-const LINKER_TYPE = "__LINKER__";
-const LINKER_TYPE_FULL = "__LINKER__@1";
 const HIT_QUAL_TYPE = "__HIT_QUAL__";
 const ANCHOR_QUAL_TYPE_PREFIX = "__ANCHOR_QUAL__:";
 function isAnchorQualType(t) {
 	return t.startsWith(ANCHOR_QUAL_TYPE_PREFIX);
 }
 function isSyntheticType(t) {
-	return t === LINKER_TYPE || t === HIT_QUAL_TYPE || isAnchorQualType(t);
+	return t === HIT_QUAL_TYPE || isAnchorQualType(t);
 }
+/**
+* Distinct labels for a set of columns. Two phases:
+*  1. {@link deriveStems} — treats each column as a single entity (native label + trace + hit/anchor
+*     qualifications) and produces the minimal distinguishing "stem".
+*  2. {@link derivePostfixes} — for columns still colliding on their stem, appends a "via …" postfix
+*     describing the difference between their linker sources (root axis, then linker chain).
+*/
 function deriveDistinctLabels(values, options = {}) {
+	const stems = deriveStems(values, options);
+	return derivePostfixes(values.map((v, i) => {
+		const { spec, linkerPath } = extractEntryParts(v);
+		return {
+			stem: stems[i],
+			hit: spec,
+			linkers: (linkerPath ?? []).map((s) => s.spec)
+		};
+	}), options.formatters?.linker);
+}
+/** Phase 1: minimal per-column stem — native label + trace + hit/anchor qualifications, no linkers. */
+function deriveStems(values, options) {
 	const forceTraceElements = options.forceTraceElements !== void 0 && options.forceTraceElements.length > 0 ? new Set(options.forceTraceElements) : void 0;
 	const separator = options.separator ?? " / ";
 	const records = values.map((v, i) => enrichRecord(v, i, options));
 	const stats = collectTypeStats(records);
 	const hasAnySynthetic = records.some((r) => r.fullTrace.some((ft) => isSyntheticType(ft.type)));
 	const labelForced = (options.includeNativeLabel === true || hasAnySynthetic) && stats.countByType.has(LABEL_TYPE_FULL);
-	const linkerForced = stats.countByType.get(LINKER_TYPE_FULL) === values.length;
 	const forcedSet = /* @__PURE__ */ new Set();
 	if (labelForced) forcedSet.add(LABEL_TYPE_FULL);
-	if (linkerForced) forcedSet.add(LINKER_TYPE_FULL);
 	const { mainTypes, secondaryTypes } = classifyTypes(stats, values.length);
 	const build = (typeSet, force) => buildLabels(records, typeSet, forceTraceElements, separator, force);
 	if (mainTypes.length === 0) {
@@ -6289,7 +6988,7 @@ function deriveDistinctLabels(values, options = {}) {
 		const candidateResult = build(currentSet, false);
 		if (candidateResult !== void 0 && countUniqueLabels(candidateResult) === values.length) {
 			const minimized = minimizeTypeSet(currentSet, records, stats, forceTraceElements, forcedSet, separator);
-			return dropRedundantLinkerSuffix(records, minimized, forceTraceElements, forcedSet, separator, build(minimized, false) ?? throwError("Failed to derive unique labels"));
+			return repairBareByPresence(build(minimized, false) ?? throwError("Failed to derive unique labels"), minimized, records, stats, forcedSet, forceTraceElements, separator);
 		}
 		additionalType++;
 		if (additionalType >= mainTypes.length) {
@@ -6302,7 +7001,7 @@ function deriveDistinctLabels(values, options = {}) {
 		...mainTypes,
 		...secondaryTypes
 	]), records, stats, forceTraceElements, forcedSet, separator);
-	return dropRedundantLinkerSuffix(records, minimized, forceTraceElements, forcedSet, separator, build(minimized, true) ?? throwError("Failed to derive unique labels"));
+	return repairBareByPresence(build(minimized, true) ?? throwError("Failed to derive unique labels"), minimized, records, stats, forcedSet, forceTraceElements, separator);
 }
 function extractEntryParts(entry) {
 	if (!("spec" in entry && typeof entry.spec === "object")) return {
@@ -6328,13 +7027,6 @@ function formatQualification(q) {
 function formatQualifications(qs) {
 	return qs.map(formatQualification).join("; ");
 }
-function computeStepLabel(step, stepIndex, formatters) {
-	const base = (readAnnotation(step.spec, Annotation.LinkLabel) ?? readAnnotation(step.spec, Annotation.Label))?.trim();
-	if (isNil(base) || base.length === 0) return void 0;
-	if (step.qualifications === void 0 || step.qualifications.length === 0) return base;
-	const qualText = isFunction(formatters?.linkerStepQualification) ? formatters.linkerStepQualification(step.qualifications, stepIndex, step.spec) : `[${formatQualifications(step.qualifications)}]`;
-	return isNil(qualText) ? base : `${base} ${qualText}`;
-}
 function buildFullTrace(trace) {
 	const result = [];
 	const occurrences = /* @__PURE__ */ new Map();
@@ -6352,7 +7044,7 @@ function buildFullTrace(trace) {
 	return result;
 }
 function enrichRecord(value, index, options) {
-	const { spec, extraTrace, linkerPath, qualifications } = extractEntryParts(value);
+	const { spec, extraTrace, qualifications } = extractEntryParts(value);
 	const formatters = options.formatters;
 	const rawLabel = readAnnotation(spec, Annotation.Label);
 	const traceStr = readAnnotation(spec, Annotation.Trace);
@@ -6376,17 +7068,6 @@ function enrichRecord(value, index, options) {
 			else trace.splice(0, 0, labelEntry);
 		}
 	}
-	if (linkerPath !== void 0 && linkerPath.length > 0) {
-		const stepLabels = linkerPath.map((step, i) => computeStepLabel(step, i, formatters)).filter((s) => !isNil(s));
-		if (stepLabels.length > 0) {
-			const linkerText = isFunction(formatters?.linker) ? formatters.linker(stepLabels, spec, index) : `via ${stepLabels.join(" > ")}`;
-			if (!isNil(linkerText)) trace.push({
-				type: LINKER_TYPE,
-				label: linkerText,
-				importance: -10
-			});
-		}
-	}
 	if (qualifications !== void 0 && qualifications.forQueries !== void 0) {
 		for (const [anchorId, qs] of Object.entries(qualifications.forQueries)) {
 			if (qs.length === 0) continue;
@@ -6438,21 +7119,18 @@ function classifyTypes(stats, totalRecords) {
 function renderRecordLabel(record, includedTypes, forceTraceElements, separator) {
 	const traceParts = [];
 	const anchorParts = [];
-	let linkerLabel;
 	let hitLabel;
 	for (const ft of record.fullTrace) {
 		if (!(includedTypes.has(ft.fullType) || forceTraceElements?.has(ft.type))) continue;
-		if (ft.type === LINKER_TYPE) linkerLabel = ft.label;
-		else if (ft.type === HIT_QUAL_TYPE) hitLabel = ft.label;
+		if (ft.type === HIT_QUAL_TYPE) hitLabel = ft.label;
 		else if (isAnchorQualType(ft.type)) anchorParts.push(ft.label);
 		else traceParts.push(ft.label);
 	}
-	if (traceParts.length === 0 && anchorParts.length === 0 && linkerLabel === void 0 && hitLabel === void 0) return void 0;
+	if (traceParts.length === 0 && anchorParts.length === 0 && hitLabel === void 0) return void 0;
 	let label = traceParts.join(separator);
 	const append = (part) => {
 		label = label.length === 0 ? part : `${label} ${part}`;
 	};
-	if (linkerLabel !== void 0) append(linkerLabel);
 	for (const a of anchorParts) append(a);
 	if (hitLabel !== void 0) append(hitLabel);
 	return label;
@@ -6470,32 +7148,6 @@ function buildLabels(records, includedTypes, forceTraceElements, separator, forc
 	}
 	return result;
 }
-/**
-* Drop the "via …" linker suffix from records whose label is already unique without it.
-*
-* Global minimization may include `LINKER_TYPE_FULL` solely to resolve a collision between a
-* subset of records — but `buildLabels` then renders the suffix on every record that carries a
-* linker trace entry, including ones whose stem is already unique. We strip the suffix where it
-* isn't load-bearing while keeping the symmetric rendering required by `linkerForced` /
-* `forceTraceElements`.
-*
-* Rule: a record's linker suffix is redundant iff its stem (label rendered without LINKER) does
-* not appear anywhere else in the set.
-*/
-function dropRedundantLinkerSuffix(records, globalTypeSet, forceTraceElements, forcedSet, separator, labels) {
-	if (!globalTypeSet.has(LINKER_TYPE_FULL)) return labels;
-	if (forcedSet.has(LINKER_TYPE_FULL) || forceTraceElements?.has(LINKER_TYPE)) return labels;
-	const setWithoutLinker = new Set(globalTypeSet);
-	setWithoutLinker.delete(LINKER_TYPE_FULL);
-	const stems = records.map((r) => renderRecordLabel(r, setWithoutLinker, forceTraceElements, separator));
-	const stemOccurrences = /* @__PURE__ */ new Map();
-	for (const s of stems) if (s !== void 0) stemOccurrences.set(s, (stemOccurrences.get(s) ?? 0) + 1);
-	return labels.map((label, i) => {
-		const stem = stems[i];
-		if (stem === void 0) return label;
-		return stemOccurrences.get(stem) === 1 ? stem : label;
-	});
-}
 function countUniqueLabels(result) {
 	if (result === void 0) return 0;
 	return new Set(result).size;
@@ -6514,6 +7166,60 @@ function minimizeTypeSet(typeSet, records, stats, forceTraceElements, forcedSet,
 	}
 	return result;
 }
+const ABSENT_VALUE = "\0absent";
+/** Whether `fullType`'s rendered value differs across the group (absence counts as a value). */
+function typeDistinguishes(records, group, fullType) {
+	const values = /* @__PURE__ */ new Set();
+	for (const i of group) {
+		const ft = records[i].fullTrace.find((e) => e.fullType === fullType);
+		values.add(ft?.label ?? ABSENT_VALUE);
+		if (values.size > 1) return true;
+	}
+	return false;
+}
+/** The highest-importance trace type this row HAS (outside `typeSet`) that sets it apart from its
+*  group peers. `undefined` when the row carries nothing distinguishing of its own. */
+function bestDistinguishingType(records, group, row, typeSet, forcedSet, forceTraceElements, stats) {
+	return records[row].fullTrace.reduce((best, ft) => {
+		if (typeSet.has(ft.fullType) || forcedSet.has(ft.fullType) || forceTraceElements?.has(ft.type)) return best;
+		if (!typeDistinguishes(records, group, ft.fullType)) return best;
+		const imp = stats.importances.get(ft.fullType) ?? 0;
+		return best === void 0 || imp > best.imp ? {
+			type: ft.fullType,
+			imp
+		} : best;
+	}, void 0)?.type;
+}
+/**
+* Un-bare columns distinguished only "by absence". After minimization a column can end up with a
+* bare trace zone (only the forced native label) while a peer sharing that same base renders extra
+* tokens — the column reads as unique purely because it LACKS what the peer has. For each such bare
+* column this re-renders JUST that column's label with the highest-importance trace type it actually
+* carries that tells it apart from its peers, so every colliding column is distinguished by a token
+* it HAS rather than by omission.
+*
+* Patches individual labels rather than the shared type set on purpose: the set is global, so adding
+* a type there would also decorate unrelated columns in other groups that happen to carry it. Only
+* bare columns' labels grow (a superset of their previous value), so uniqueness is preserved. Groups
+* are keyed by the base = the label rendered from the forced types alone.
+*/
+function repairBareByPresence(labels, minimized, records, stats, forcedSet, forceTraceElements, separator) {
+	const base = records.map((r) => renderRecordLabel(r, forcedSet, forceTraceElements, separator));
+	const isBare = records.map((r, i) => renderRecordLabel(r, minimized, forceTraceElements, separator) === base[i]);
+	const groups = records.reduce((acc, _, i) => acc.set(base[i] ?? "", [...acc.get(base[i] ?? "") ?? [], i]), /* @__PURE__ */ new Map());
+	const patched = [...labels];
+	for (const group of groups.values()) {
+		if (!group.some((i) => !isBare[i])) continue;
+		for (const i of group) {
+			if (!isBare[i]) continue;
+			const chosen = bestDistinguishingType(records, group, i, minimized, forcedSet, forceTraceElements, stats);
+			if (chosen === void 0) continue;
+			const withToken = /* @__PURE__ */ new Set([...minimized, chosen]);
+			patched[i] = renderRecordLabel(records[i], withToken, forceTraceElements, separator) ?? patched[i];
+		}
+	}
+	return patched;
+}
 //#endregion
 //#region ../../../../sdk/model/dist/render/util/label.js
 /** @deprecated Use deriveDistinctLabels */
@@ -6811,7 +7517,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());
@@ -6832,7 +7538,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;
@@ -6884,7 +7590,7 @@ function getSplitAxisIndices(selector) {
 }
 var PColumnCollection = class {
 	defaultProviderStore = [];
-	providers = [new ArrayColumnProvider(this.defaultProviderStore)];
+	providers = [new ArrayColumnsProvider(this.defaultProviderStore)];
 	axisLabelProviders = [];
 	constructor() {}
 	addColumnProvider(provider) {
@@ -7047,7 +7753,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
 			});
 		}
@@ -7083,7 +7791,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;
@@ -7109,7 +7817,8 @@ var PColumnCollection = class {
 const BLOCK_SERVICE_FLAGS = {
 	requiresPFrameSpec: true,
 	requiresPFrame: true,
-	requiresDialog: true
+	requiresDialog: true,
+	requiresColumnsCollection: true
 };
 resolveRequiredServices(BLOCK_SERVICE_FLAGS);
 //#endregion
@@ -7124,8 +7833,8 @@ function createServiceProxy(dispatch) {
 //#endregion
 //#region ../../../../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);
@@ -7189,24 +7898,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));
@@ -7350,7 +8070,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]));
@@ -7431,6 +8150,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);
@@ -7508,20 +8230,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,
@@ -7536,7 +8246,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;
@@ -7553,17 +8263,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();
@@ -7629,7 +8333,7 @@ var PluginRenderCtx = class extends RenderCtxBase {
 };
 //#endregion
 //#region ../../../../sdk/model/dist/version.js
-const PlatformaSDKVersion = "1.79.20";
+const PlatformaSDKVersion = "1.80.8";
 //#endregion
 //#region ../../../../sdk/model/dist/bconfig/types.js
 function isConfigLambda(cfgOrFh) {
@@ -8137,79 +8841,2124 @@ var BlockModelV3 = class BlockModelV3 {
 	}
 };
 //#endregion
-//#region ../../../../sdk/model/dist/filters/traverse.js
+//#region ../../../../sdk/model/dist/columns/column_recipes/leaf_rebrand.js
 /**
-* Recursively traverses a FilterSpec tree bottom-up, applying visitor callbacks.
-*
-* Entries with `{ type: undefined }` inside `and`/`or` arrays are skipped
-* (these represent unfilled filter slots in the UI).
+* 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.
 *
-* Traversal order:
-* 1. Recurse into child filters (`and`/`or`/`not`)
-* 2. Apply the corresponding visitor callback with already-traversed children
-* 3. For leaf nodes, call `leaf` directly
+* 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 traverseFilterSpec(filter, visitor) {
-	return traverseFilterSpecImpl(filter, visitor);
+function rebrandLeafId(node, fromId, toId) {
+	if (fromId === toId) return node;
+	return mapSpecQueryColumns(node, { column: (id) => id === fromId ? toId : id });
 }
-/** Internal implementation with simple generics for clean recursion. */
-function traverseFilterSpecImpl(filter, visitor) {
-	switch (filter.type) {
-		case "and": return visitor.and(filter.filters.filter((f) => f.type !== void 0).map((f) => traverseFilterSpecImpl(f, visitor)));
-		case "or": return visitor.or(filter.filters.filter((f) => f.type !== void 0).map((f) => traverseFilterSpecImpl(f, visitor)));
-		case "not": return visitor.not(traverseFilterSpecImpl(filter.filter, visitor));
-		default: return visitor.leaf(filter);
+//#endregion
+//#region ../../../../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);
 	}
-}
-/** Collects all column references (`column` and `rhs` fields) from filter leaves. */
-function collectFilterSpecColumns(filter) {
-	return traverseFilterSpec(filter, {
-		leaf: (leaf) => {
-			const cols = [];
-			if ("column" in leaf && leaf.column !== void 0) cols.push(leaf.column);
-			if ("rhs" in leaf && leaf.rhs !== void 0) cols.push(leaf.rhs);
-			return cols;
-		},
-		and: (results) => results.flat(),
-		or: (results) => results.flat(),
-		not: (result) => result
-	});
-}
+	/**
+	* 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 ../../../../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" ? {
-		type: "axisRef",
-		value: parsed.id
-	} : {
-		type: "columnRef",
-		value: parsed.id
-	};
-}
-/** Converts a FilterSpec tree into a SpecQueryExpression. */
-function filterSpecToSpecQueryExpr(filter) {
-	return traverseFilterSpec(filter, {
-		leaf: leafToSpecQueryExpr,
-		and: (inputs) => {
-			if (inputs.length === 0) throw new Error("AND filter requires at least one operand");
-			return {
-				type: "and",
-				input: inputs
-			};
-		},
-		or: (inputs) => {
-			if (inputs.length === 0) throw new Error("OR filter requires at least one operand");
-			return {
-				type: "or",
-				input: inputs
-			};
-		},
-		not: (input) => ({
-			type: "not",
-			input
-		})
+//#region ../../../../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 ../../../../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.2/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;
+	#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,
+			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;
+		this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
+			starts[index] = ttl !== 0 ? start : 0;
+			ttls[index] = ttl;
+			if (ttl !== 0 && this.ttlAutopurge) {
+				const t = setTimeout(() => {
+					if (this.#isStale(index)) this.#delete(this.#keyList[index], "expire");
+				}, ttl + 1);
+				/* c8 ignore start */
+				if (t.unref) t.unref();
+			}
+		};
+		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 (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) {
+				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);
+		}
+		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 ../../../../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 ../../../../sdk/model/dist/columns/column_providers/index.js
+/**
+* Build the default set of ColumnsProviders for the ambient render ctx:
+*  - `AccessorColumnsProvider` over `outputs` (if present)
+*  - `AccessorColumnsProvider` over `prerun`  (if present)
+*  - `ResultPoolColumnsProvider` over `rawResultPool`
+*
+* Pulls handles directly from the ambient `cfgRenderCtx`. Returns `[]` when
+* called outside a render context.
+*
+* Result is memoised per-ctx (WeakMap → array). Repeated calls within the
+* same render cycle return the same provider triplet — inner providers are
+* also LRU-memoised by their content keys, so even a cache miss here doesn't
+* re-walk the trees.
+*/
+const _ctxProvidersCache = /* @__PURE__ */ new WeakMap();
+function getCtxProviders(deps) {
+	const ctx = deps?.ctx ?? getCfgRenderCtx();
+	const cached = _ctxProvidersCache.get(ctx);
+	if (cached !== void 0) return cached;
+	const providers = [];
+	const outputs = ctx.getAccessorHandleByName(MainAccessorName);
+	if (outputs !== void 0) providers.push(ColumnsProvider(new TreeNodeAccessor(outputs, [MainAccessorName])));
+	const prerun = ctx.getAccessorHandleByName(StagingAccessorName);
+	if (prerun !== void 0) providers.push(ColumnsProvider(new TreeNodeAccessor(prerun, [StagingAccessorName])));
+	providers.push(ColumnsProvider(ctx.getUpstreamBlockCtx()));
+	_ctxProvidersCache.set(ctx, providers);
+	return providers;
+}
+//#endregion
+//#region ../../../../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 ../../../../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 ../../../../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 ../../../../sdk/model/dist/columns/utils.js
+/**
+* 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() ?? {};
+}
+/**
+* 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;
+		}
+		return;
+	}
+}
+//#endregion
+//#region ../../../../sdk/model/dist/filters/traverse.js
+/**
+* Recursively traverses a FilterSpec tree bottom-up, applying visitor callbacks.
+*
+* Entries with `{ type: undefined }` inside `and`/`or` arrays are skipped
+* (these represent unfilled filter slots in the UI).
+*
+* Traversal order:
+* 1. Recurse into child filters (`and`/`or`/`not`)
+* 2. Apply the corresponding visitor callback with already-traversed children
+* 3. For leaf nodes, call `leaf` directly
+*/
+function traverseFilterSpec(filter, visitor) {
+	return traverseFilterSpecImpl(filter, visitor);
+}
+/** Internal implementation with simple generics for clean recursion. */
+function traverseFilterSpecImpl(filter, visitor) {
+	switch (filter.type) {
+		case "and": return visitor.and(filter.filters.filter((f) => f.type !== void 0).map((f) => traverseFilterSpecImpl(f, visitor)));
+		case "or": return visitor.or(filter.filters.filter((f) => f.type !== void 0).map((f) => traverseFilterSpecImpl(f, visitor)));
+		case "not": return visitor.not(traverseFilterSpecImpl(filter.filter, visitor));
+		default: return visitor.leaf(filter);
+	}
+}
+/** Collects all column references (`column` and `rhs` fields) from filter leaves. */
+function collectFilterSpecColumns(filter) {
+	return traverseFilterSpec(filter, {
+		leaf: (leaf) => {
+			const cols = [];
+			if ("column" in leaf && leaf.column !== void 0) cols.push(leaf.column);
+			if ("rhs" in leaf && leaf.rhs !== void 0) cols.push(leaf.rhs);
+			return cols;
+		},
+		and: (results) => results.flat(),
+		or: (results) => results.flat(),
+		not: (result) => result
+	});
+}
+//#endregion
+//#region ../../../../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: col.id
+	} : {
+		type: "columnRef",
+		value: col.id
+	};
+}
+/** Converts a FilterSpec tree into a SpecQueryExpression. */
+function filterSpecToSpecQueryExpr(filter) {
+	return traverseFilterSpec(filter, {
+		leaf: leafToSpecQueryExpr,
+		and: (inputs) => {
+			if (inputs.length === 0) throw new Error("AND filter requires at least one operand");
+			return {
+				type: "and",
+				input: inputs
+			};
+		},
+		or: (inputs) => {
+			if (inputs.length === 0) throw new Error("OR filter requires at least one operand");
+			return {
+				type: "or",
+				input: inputs
+			};
+		},
+		not: (input) => ({
+			type: "not",
+			input
+		})
 	});
 }
 function leafToSpecQueryExpr(filter) {
@@ -8621,12 +11370,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. */
@@ -8637,7 +11387,7 @@ function migrateV5toV6(state) {
 			...entry,
 			gridState: unwrapV5GridState(entry.gridState)
 		})),
-		pTableParams: createDefaultPTableParams()
+		pTableParams: createDefaultPTableParamsV7()
 	};
 }
 /** Convert v5 wrapped colId JSON to bare PTableColumnSpec JSON, taking `.source`.
@@ -8694,10 +11444,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",
@@ -8725,10 +11472,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) {
@@ -8854,7 +11602,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,
@@ -8863,13 +11613,109 @@ 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 ../../../../sdk/model/dist/components/PlDataTable/createPlDataTable/utils.js
 /** Check if column is hidden by default */
@@ -8932,18 +11778,29 @@ function getMatchingLabelColumns(columns, allLabelColumns) {
 }
 //#endregion
 //#region ../../../../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);
@@ -8963,7 +11820,7 @@ function createPTableDefV3(params) {
 		sortBy: params.sorting.map((s) => ({
 			expression: columnIdToExpr(s.column),
 			ascending: s.ascending,
-			nullsFirst: !s.naAndAbsentAreLeastValues
+			nullsFirst: s.naAndAbsentAreLeastValues
 		}))
 	};
 	return { query };
@@ -8977,28 +11834,10 @@ function columnIdToExpr(col) {
 		value: col.id
 	};
 }
-function toLeaf(col, qs) {
-	return {
-		entry: {
-			type: "column",
-			column: col
-		},
-		qualifications: qs
-	};
-}
-function toJoinEntry(e) {
-	const qs = e.qualifications ?? [];
-	if (isNil(e.linkers) || e.linkers.length === 0) return toLeaf(e.column, qs);
+function columnToJoinEntry(col, qualifications) {
 	return {
-		...e.linkers.reduceRight((inner, linker) => ({
-			entry: {
-				type: "linkerJoin",
-				linker: { column: linker },
-				secondary: [inner]
-			},
-			qualifications: []
-		}), toLeaf(e.column, [])),
-		qualifications: qs
+		entry: col.getQuery(),
+		qualifications
 	};
 }
 //#endregion
@@ -9013,14 +11852,38 @@ function createPTableDefV2(params) {
 	}
 	secondaryColumns.push(...params.labelColumns);
 	return createPTableDefV3({
-		primary: coreColumns.map((column) => ({ column })),
-		secondary: secondaryColumns.map((column) => ({ entries: [{ column }] })),
+		primary: coreColumns.map((column) => ColumnLazyImpl.fromColumn(column)),
+		secondary: secondaryColumns.map((column) => ColumnLazyImpl.fromColumn(column)),
 		primaryJoinType: params.coreJoinType,
 		filters: params.filters,
 		sorting: params.sorting
 	});
 }
 //#endregion
+//#region ../../../../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 ../../../../sdk/model/dist/components/PlDataTable/createPlDataTable/createPlDataTableV2.js
 /**
 * Create p-table spec and handle given ui table state
@@ -9049,31 +11912,19 @@ function createPlDataTableV2(ctx, columns, tableState, options) {
 		};
 	});
 	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 resolver = createColumnResolver(fullColumns.map((c) => ColumnLazyImpl.fromColumn(c)), { warn: ctx.logWarn.bind(ctx) });
+	const rawFilters = tableStateNormalized.pTableParams.filters;
+	const rawDefaultFilters = options?.filters ?? void 0;
+	const filters = remapFiltersThrowing(rawFilters, resolver, "filter");
+	const defaultFilters = remapFiltersThrowing(rawDefaultFilters ?? null, resolver, "default filter");
 	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 sorting = remapSortingThrowing((isNil$1(userSorting) ? options?.sorting : userSorting) ?? [], resolver);
 	const coreJoinType = options?.coreJoinType ?? "full";
 	const fullDef = createPTableDefV2({
 		columns,
 		labelColumns: fullLabelColumns,
 		coreJoinType,
-		filters,
+		filters: filters ?? null,
 		sorting,
 		coreColumnPredicate: options?.coreColumnPredicate
 	});
@@ -9090,10 +11941,7 @@ function createPlDataTableV2(ctx, columns, tableState, options) {
 	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));
+	if (filters) collectFilterSpecColumns(filters).flatMap((c) => c.type === "column" ? [c.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;
@@ -9101,7 +11949,7 @@ function createPlDataTableV2(ctx, columns, tableState, options) {
 		columns: visibleColumns,
 		labelColumns: visibleLabelColumns,
 		coreJoinType,
-		filters,
+		filters: filters ?? null,
 		sorting,
 		coreColumnPredicate
 	});
@@ -9112,9 +11960,53 @@ function createPlDataTableV2(ctx, columns, tableState, options) {
 		fullTableHandle: fullHandle,
 		fullPframeHandle: pframeHandle,
 		visibleTableHandle: visibleHandle,
-		defaultFilters
+		defaultFilters: defaultFilters ?? void 0
 	};
 }
+/** Rewrite filter column refs through the resolver; throw on any unresolved ref. */
+function remapFiltersThrowing(filters, resolver, label) {
+	if (isNil$1(filters)) return filters;
+	return traverseFilterSpec(filters, {
+		leaf: (leaf) => {
+			if (leaf.type === void 0) return leaf;
+			const result = { ...leaf };
+			if ("column" in result) {
+				const c = resolver(result.column);
+				if (isNil$1(c)) throw new Error(`Invalid ${label} column ${JSON.stringify(result.column)}: column reference does not match the table columns`);
+				result.column = c;
+			}
+			if ("rhs" in result) {
+				const c = resolver(result.rhs);
+				if (isNil$1(c)) throw new Error(`Invalid ${label} column ${JSON.stringify(result.rhs)}: column reference does not match the table columns`);
+				result.rhs = c;
+			}
+			return result;
+		},
+		and: (results) => ({
+			type: "and",
+			filters: results
+		}),
+		or: (results) => ({
+			type: "or",
+			filters: results
+		}),
+		not: (result) => ({
+			type: "not",
+			filter: result
+		})
+	});
+}
+/** Rewrite sorting column refs through the resolver; throw on any unresolved ref. */
+function remapSortingThrowing(sorting, resolver) {
+	return sorting.map((s) => {
+		const c = resolver(s.column);
+		if (isNil$1(c)) throw new Error(`Invalid sorting column ${JSON.stringify(s.column)}: column reference does not match the table columns`);
+		return {
+			...s,
+			column: c
+		};
+	});
+}
 function getAllLabelColumns(resultPool) {
 	return new PColumnCollection().addAxisLabelProvider(resultPool).addColumnProvider(resultPool).getColumns({
 		name: PColumnName.Label,