@platforma-open/milaboratories.repertoire-mutation-heatmap.block 1.1.4 → 1.1.6

package/dist/index.js

@@ -1,148 +1,184 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-//#region ../kind/dist/package.js
-var name = "@platforma-open/milaboratories.repertoire-mutation-heatmap.kind";
-var version$1 = "1.0.0";
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+block-kind@1.1.0/node_modules/@platforma-sdk/block-kind/dist/params.js
+import { r as __toESM, t as __commonJSMin } from "./rolldown-runtime-DC62tzP2.js";
+//#region ../model/dist/chart-state.js
 /**
-* Establish that a value is an object whose fields a kind can read — the half of a params
-* check every kind needs and no two kinds differ on.
-*
-* Params that arrived from a template file are `unknown`, and before a single field can be
-* read the value has to be an object. Worth a shared function because the check is easy to
-* get wrong by hand: `typeof null` is `"object"`, `Object.keys(5)` is `[]` and
-* `Object.keys(["a"])` is `["0"]`, so a naive test lets `null`, a number and an array through
-* as if they were empty params.
-*
-* What each field must *be* is the kind's own business and stays in the kind, as plain
-* TypeScript: this package deliberately carries no validation library, so a kind author owes
-* it no schema.
-*
-* A key the kind does not declare is NOT refused. A parser returns the params to use, so a
-* field it never read is dropped and never reaches the block — the only question was whether
-* to also complain, and complaining costs more than it catches. It would mean each kind
-* restating its own field list as strings, with nothing checking that the list stayed in step
-* with the type: a field added to the contract and read by the parser, but missed in the list,
-* would turn into a kind that refuses files that are correct. What an unexpected key can
-* actually mean is a params contract from a different version of the kind, and that is
-* guarded where it belongs — by the version in the entry's `{name}@{selector}` reference.
-*
-* An assertion rather than a parser that returns a copy, so a kind reads its fields off the
-* value it was handed:
-*
-* ```ts
-* function parseInitializationParams(value: unknown): BlockParams {
-*   assertParamsObject(value);
+* Default state for a mutation-landscape chart. Used by `init` for the placeholder and by the UI
+* for each score a run produces, so the two look alike.
 *
-*   const { numbers } = value;
-*   if (numbers !== undefined && !isNumberArray(numbers)) {
-*     throw new Error("'numbers' must be an array of numbers.");
-*   }
-*   return { numbers };
-* }
-* ```
+* @param currentTab `"settings"` opens the Settings drawer, `null` leaves it closed
+*/
+function makeLandscapeChartState(title, currentTab) {
+	return {
+		title,
+		template: "heatmap",
+		currentTab,
+		layersSettings: { heatmap: {
+			normalizationDirection: null,
+			transform: null,
+			NAValueAs: null
+		} },
+		axesSettings: {
+			axisX: {
+				cellSize: 20,
+				axisLabelsAngle: 45
+			},
+			axisY: {
+				hideAxisLabels: false,
+				cellSize: 20
+			}
+		}
+	};
+}
+/**
+* Default state for a drill-down's partner map. Same shape as a landscape chart — one colour
+* scale, no normalization, absent cells left empty — because it is the same map with one
+* mutation held fixed.
+*/
+/**
+* The key a chart's saved aesthetic mapping uses for the region track, as it appears inside
+* `dataBindAes`. The source id embeds the column's resolve path, so this matches it in both
+* frames at once.
+*/
+const REGION_AES_SOURCE = "region/region";
+/**
+* Drops a chart's saved colour mapping for the region track, so it is seeded afresh.
 *
-* Messages are finished sentences addressed to whoever wrote the file, because that is who
-* reads them: a kind's rejection is reported against the entry that carried the params.
+* graph-maker reads the `pl7.app/graph/palette` annotation ONCE, when a mapping is created, and
+* never reasserts it — "after that the mapping is the user's". A chart that already built its own
+* mapping therefore keeps it, whatever the column now declares. Clearing the entry is the only
+* way to let the pinned palette take effect on a chart that predates it.
+*/
+function withRegionColoursReseeded(state) {
+	const aes = state.dataBindAes;
+	if (aes === void 0) return state;
+	const kept = Object.fromEntries(Object.entries(aes).filter(([source]) => !source.includes(REGION_AES_SOURCE)));
+	return {
+		...state,
+		dataBindAes: kept
+	};
+}
+/**
+* Pins "show empty rows/columns" on a drill-down chart.
 *
-* @param value The params as they arrived
-* @throws if `value` is not an object
+* The partner map is sparse by nature — most positions carry no pair with the fixed mutation —
+* and without this it draws only the few positions that do. The region band beneath it then
+* shrinks to those, and the reader loses where in the parent they are looking. With the value
+* column's axes declared dense, the full grid arrives; this is what makes it render.
 */
-function assertParamsObject(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Params must be an object, not ${describe(value)}.`);
+function withEmptyCellsShown(state) {
+	return {
+		...state,
+		layersSettings: {
+			...state.layersSettings,
+			heatmap: {
+				...state.layersSettings?.heatmap,
+				showEmptyRows: true,
+				showEmptyColumns: true
+			}
+		}
+	};
 }
-/** What a value is, for a message that has to say why it is not an object. */
-function describe(value) {
-	if (value === null) return "null";
-	if (value === void 0) return "nothing";
-	if (Array.isArray(value)) return "an array";
-	return `a ${typeof value} (${JSON.stringify(value) ?? String(value)})`;
+function makeDrillDownChartState() {
+	const base = withEmptyCellsShown(makeLandscapeChartState("", null));
+	return {
+		...base,
+		axesSettings: {
+			...base.axesSettings,
+			title: {
+				...base.axesSettings?.title,
+				mode: "hidden"
+			}
+		}
+	};
 }
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+block-kind@1.1.0/node_modules/@platforma-sdk/block-kind/dist/index.js
 /**
-* Define a block kind.
-*
-* `meta` is the kind's identity — its own `{ name, version }`. Source it from
-* the package's `package.json` rather than hand-typing literals, so the on-wire
-* `{name}@{version}` cannot drift from what npm publishes and what the S3
-* manifest records (all read the same `package.json`):
-*
-* ```ts
-* // a kind package's src/index.ts
-* import { name, version } from "../package.json" with { type: "json" };
-* export const kind = defineBlockKind<Params>({ name, version });
-* ```
-*
-* rolldown inlines the JSON import (tree-shaken to the two strings) into the
-* bundled `kind.js`, so no build-time injection is needed.
-*
-* A kind must also declare `parseInitializationParams` — the runtime check applied to params
-* that came from a template file rather than from typed code. See
-* {@link CompiledBlockKind} for what it must do.
-*
-* @typeParam BlockParams - shape of the params a block of this kind reads. Pinned both
-*   as a type and by `parseInitializationParams`, whose return type is checked against it.
+* Pins "Treat NA value as: empty" on a landscape chart's saved state.
+*
+* The landscape's cell axes are declared dense, so the grid now carries a record for every
+* (position, state) and the substitutions no single mutant covered arrive with no value. They
+* must stay empty. Seeding `makeLandscapeChartState` only reaches charts created from now on:
+* graph-maker writes its whole merged layer settings back into the state it is bound to, so any
+* chart opened before this change has the old default of 0 pinned in its own state, and would
+* paint every uncovered substitution as a real zero-valued cell.
 */
-function defineBlockKind(meta) {
-	return Object.freeze({
-		kindSchema: "v1",
-		name: meta.name,
-		version: meta.version,
-		parseInitializationParams: meta.parseInitializationParams
-	});
+function withEmptyNAValue(state) {
+	return {
+		...state,
+		layersSettings: {
+			...state.layersSettings,
+			heatmap: {
+				...state.layersSettings?.heatmap,
+				NAValueAs: null
+			}
+		}
+	};
 }
-//#endregion
-//#region ../kind/dist/index.js
 /**
-* The same contract at runtime, for params that arrive from a template file
-* rather than from typed code.
+* The parent-residue column's key inside both heat-map frames, as it appears inside a saved
+* selector's source id. Distinct from the highlight flag's `parentFlag/isParentResidue`, which
+* contains this word too but not this path.
+*/
+const PARENT_RESIDUE_SOURCE = "parent/parentResidue";
+const carriesParentResidue = (selectedSource) => selectedSource.includes(PARENT_RESIDUE_SOURCE);
+/**
+* Angles the X labels of a chart saved before the parent residue joined the axis, and moves the
+* source across.
 *
-* The contract names no fields, so there is nothing to read and nothing to
-* validate beyond the value being an object at all. Keys a template supplies
-* anyway are dropped by not being read. The return type holds this in step: the
-* moment `BlockParams` declares a required field, `return {}` stops compiling.
+* The move is belt and braces — graph-maker reapplies a default whose value has changed, so it
+* would arrive anyway — but the angle is not a default option. It lives in the chart's own axes
+* settings, which are seeded once when the chart is created, so without this an existing chart gets
+* the two-part label flat and overlapping under a 20px column.
+*
+* Keyed on the parent still being an annotation track, which is what "saved before this" looks
+* like. The region track is deliberately left where it is.
 */
-function parseInitializationParams(value) {
-	assertParamsObject(value);
-	return {};
+function withParentOnXAxis(state) {
+	const options = state.optionsState;
+	if (options?.type !== "heatmap") return state;
+	const annotations = options.components.annotationsX.selectorStates;
+	const parent = annotations.find((selector) => carriesParentResidue(selector.selectedSource));
+	if (!parent) return state;
+	const alreadyOnX = options.components.x.selectorStates.some((selector) => carriesParentResidue(selector.selectedSource));
+	return {
+		...state,
+		optionsState: {
+			...options,
+			components: {
+				...options.components,
+				x: alreadyOnX ? options.components.x : {
+					type: "simple",
+					selectorStates: [...options.components.x.selectorStates, parent]
+				},
+				annotationsX: {
+					type: "simple",
+					selectorStates: annotations.filter((selector) => selector !== parent)
+				}
+			}
+		},
+		axesSettings: {
+			...state.axesSettings,
+			axisX: {
+				...state.axesSettings?.axisX,
+				axisLabelsAngle: 45
+			}
+		}
+	};
+}
+function mapChartStates(data, rewrite) {
+	return {
+		compositionHeatmapState: rewrite(data.compositionHeatmapState),
+		singleMutantHeatmapState: rewrite(data.singleMutantHeatmapState),
+		singleMutantHeatmapStates: Object.fromEntries(Object.entries(data.singleMutantHeatmapStates).map(([key, state]) => [key, rewrite(state)]))
+	};
 }
-const kind = defineBlockKind({
-	name,
-	version: version$1,
-	parseInitializationParams
-});
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/plugin_handle.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/plugin_handle.js
 const PLUGIN_OUTPUT_PREFIX = "plugin-output#";
 /** Construct the output key for a plugin output in the block outputs map. */
 function pluginOutputKey(handle, outputKey) {
 	return `${PLUGIN_OUTPUT_PREFIX}${handle}#${outputKey}`;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_storage.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/block_storage.js
 /**
 * Discriminator key for BlockStorage format detection.
 * This unique hash-based key identifies data as BlockStorage vs legacy formats.
@@ -612,13 +648,14 @@ const errorMap = (issue, _ctx) => {
 			message = `Invalid date`;
 			break;
 		case ZodIssueCode.invalid_string:
-			if (typeof issue.validation === "object") if ("includes" in issue.validation) {
-				message = `Invalid input: must include "${issue.validation.includes}"`;
-				if (typeof issue.validation.position === "number") message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
-			} else if ("startsWith" in issue.validation) message = `Invalid input: must start with "${issue.validation.startsWith}"`;
-			else if ("endsWith" in issue.validation) message = `Invalid input: must end with "${issue.validation.endsWith}"`;
-			else util.assertNever(issue.validation);
-			else if (issue.validation !== "regex") message = `Invalid ${issue.validation}`;
+			if (typeof issue.validation === "object") {
+				if ("includes" in issue.validation) {
+					message = `Invalid input: must include "${issue.validation.includes}"`;
+					if (typeof issue.validation.position === "number") message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+				} else if ("startsWith" in issue.validation) message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+				else if ("endsWith" in issue.validation) message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+				else util.assertNever(issue.validation);
+			} else if (issue.validation !== "regex") message = `Invalid ${issue.validation}`;
 			else message = "Invalid";
 			break;
 		case ZodIssueCode.too_small:
@@ -783,8 +820,10 @@ var ParseInputLazyPath = class {
 		this._key = key;
 	}
 	get path() {
-		if (!this._cachedPath.length) if (Array.isArray(this._key)) this._cachedPath.push(...this._path, ...this._key);
-		else this._cachedPath.push(...this._path, this._key);
+		if (!this._cachedPath.length) {
+			if (Array.isArray(this._key)) this._cachedPath.push(...this._path, ...this._key);
+			else this._cachedPath.push(...this._path, this._key);
+		}
 		return this._cachedPath;
 	}
 };
@@ -883,11 +922,12 @@ var ZodType = class {
 			data,
 			parsedType: getParsedType(data)
 		};
-		return handleResult(ctx, this._parseSync({
+		const result = this._parseSync({
 			data,
 			path: ctx.path,
 			parent: ctx
-		}));
+		});
+		return handleResult(ctx, result);
 	}
 	"~validate"(data) {
 		const ctx = {
@@ -944,7 +984,8 @@ var ZodType = class {
 			path: ctx.path,
 			parent: ctx
 		});
-		return handleResult(ctx, await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult)));
+		const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
+		return handleResult(ctx, result);
 	}
 	refine(check, message) {
 		const getIssueProperties = (val) => {
@@ -3497,7 +3538,8 @@ var ZodPromise = class extends ZodType {
 			});
 			return INVALID;
 		}
-		return OK((ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data)).then((data) => {
+		const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
+		return OK(promisified.then((data) => {
 			return this._def.type.parseAsync(data, {
 				path: ctx.path,
 				errorMap: ctx.common.contextualErrorMap
@@ -3595,30 +3637,32 @@ var ZodEffects = class extends ZodType {
 				});
 			});
 		}
-		if (effect.type === "transform") if (ctx.common.async === false) {
-			const base = this._def.schema._parseSync({
+		if (effect.type === "transform") {
+			if (ctx.common.async === false) {
+				const base = this._def.schema._parseSync({
+					data: ctx.data,
+					path: ctx.path,
+					parent: ctx
+				});
+				if (!isValid(base)) return INVALID;
+				const result = effect.transform(base.value, checkCtx);
+				if (result instanceof Promise) throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
+				return {
+					status: status.value,
+					value: result
+				};
+			} else return this._def.schema._parseAsync({
 				data: ctx.data,
 				path: ctx.path,
 				parent: ctx
+			}).then((base) => {
+				if (!isValid(base)) return INVALID;
+				return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+					status: status.value,
+					value: result
+				}));
 			});
-			if (!isValid(base)) return INVALID;
-			const result = effect.transform(base.value, checkCtx);
-			if (result instanceof Promise) throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
-			return {
-				status: status.value,
-				value: result
-			};
-		} else return this._def.schema._parseAsync({
-			data: ctx.data,
-			path: ctx.path,
-			parent: ctx
-		}).then((base) => {
-			if (!isValid(base)) return INVALID;
-			return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
-				status: status.value,
-				value: result
-			}));
-		});
+		}
 		util.assertNever(effect);
 	}
 };
@@ -3924,12 +3968,34 @@ ZodOptional.create;
 ZodNullable.create;
 ZodEffects.createWithPreprocess;
 ZodPipeline.create;
+const coerce = {
+	string: ((arg) => ZodString.create({
+		...arg,
+		coerce: true
+	})),
+	number: ((arg) => ZodNumber.create({
+		...arg,
+		coerce: true
+	})),
+	boolean: ((arg) => ZodBoolean.create({
+		...arg,
+		coerce: true
+	})),
+	bigint: ((arg) => ZodBigInt.create({
+		...arg,
+		coerce: true
+	})),
+	date: ((arg) => ZodDate.create({
+		...arg,
+		coerce: true
+	}))
+};
 objectType({
 	type: literalType("plain"),
 	content: stringType()
 });
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/bmodel/block_kind_ref.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/bmodel/block_kind_ref.js
 /**
 * Compose a {@link BlockKindReference} from a kind's `name`/`version`.
 *
@@ -3945,12 +4011,19 @@ objectType({
 	to: numberType().min(1)
 });
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/util.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/util.js
 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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.js
 /**
 * Type guard function that checks if the given value is a valid DataInfo.
 *
@@ -4019,9 +4092,7 @@ function visitDataInfo(dataInfo, cb) {
 				cb(chunk.values);
 			});
 			break;
-		case "ParquetPartitioned":
-			Object.values(dataInfo.parts).forEach(cb);
-			break;
+		case "ParquetPartitioned": Object.values(dataInfo.parts).forEach(cb);
 	}
 }
 /**
@@ -4141,7 +4212,7 @@ function entriesToDataInfo(dataInfoEntries) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/errors.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/errors.js
 var ServiceError = class extends Error {
 	name = "ServiceError";
 };
@@ -4165,7 +4236,7 @@ function ensureError(value) {
 	return new Error(stringifyValue(value));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/json.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/json.js
 var import_canonicalize = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = function serialize(object) {
 		if (typeof object === "number" && isNaN(object)) throw new Error("NaN is not allowed");
@@ -4198,7 +4269,7 @@ function parseJsonSafely(value, fallback) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.js
 function readMetadata(metadata, key) {
 	return metadata?.[key];
 }
@@ -4220,6 +4291,36 @@ function readMetadataJson(metadata, metadataJson, key) {
 		return;
 	}
 }
+/**
+* Domain keys whose value is the id of a block, rather than a qualifier of the data.
+*
+* Applying a template repoints these at the blocks of the project being built: an axis a block
+* produced names that block in its domain, so an axis left naming the exported-from project
+* resolves to nothing. Listing the keys is what makes that safe — a template's entry ids are
+* arbitrary non-empty strings, so a hand-written template may name an entry `closest`, and a
+* qualifier that happens to read `closest` must not be mistaken for a reference to it.
+*
+* A key absent from here is simply left alone, which is the behaviour from before relocation
+* reached domains at all. Adding one is therefore safe; omitting one costs only that a template
+* carrying it applies still pointing at the project it came from.
+*/
+const BlockScopedDomain = /* @__PURE__ */ new Set([
+	"pl7.app/blockId",
+	"pl7.app/block",
+	"pl7.app/redefined-by",
+	"pl7.app/annotationRunId",
+	"pl7.app/clonotypeAnnotationRunId",
+	"pl7.app/clustering/blockId",
+	"pl7.app/umap/blockId",
+	"pl7.app/peptide/extractionRunId",
+	"pl7.app/repertoire/extractionRunId",
+	"pl7.app/antibodyVariantDesigner/designRunId",
+	"pl7.app/vdj/clonotypingRunId",
+	"pl7.app/vdj/clustering/blockId",
+	"pl7.app/vdj/integration/blockId",
+	"pl7.app/vdj/spatiotemporalAnalysis/blockId",
+	"pl7.app/vdj/libraryId"
+]);
 const Annotation = {
 	AxisNature: "pl7.app/axisNature",
 	Alphabet: "pl7.app/alphabet",
@@ -4237,6 +4338,7 @@ const Annotation = {
 		IsDenseAxis: "pl7.app/graph/isDenseAxis",
 		IsVirtual: "pl7.app/graph/isVirtual",
 		Palette: "pl7.app/graph/palette",
+		Shape: "pl7.app/graph/shape",
 		Thresholds: "pl7.app/graph/thresholds",
 		TreatAbsentValuesAs: "pl7.app/graph/treatAbsentValuesAs"
 	},
@@ -4292,9 +4394,14 @@ const AnnotationJson = {
 	[Annotation.Graph.Axis.SymmetricRange]: booleanType(),
 	[Annotation.Graph.IsDenseAxis]: booleanType(),
 	[Annotation.Graph.Palette]: objectType({
-		mapping: recordType(numberType()),
-		name: stringType()
+		name: stringType(),
+		mapping: recordType(coerce.number()).optional(),
+		midPoint: numberType().optional(),
+		min: numberType().optional(),
+		max: numberType().optional(),
+		log: booleanType().optional()
 	}),
+	[Annotation.Graph.Shape]: objectType({ mapping: recordType(stringType()) }),
 	[Annotation.Graph.Thresholds]: arrayType(objectType({
 		columnId: objectType({
 			valueType: ValueTypeSchema,
@@ -4490,7 +4597,22 @@ function matchAxisId(query, target) {
 	return query.name === target.name && matchDomain$1(query.domain, target.domain) && matchDomain$1(query.contextDomain, target.contextDomain);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/utils.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/utils.js
+const BOOLEAN_TYPES = /* @__PURE__ */ new Set([
+	"numericComparison",
+	"stringEquals",
+	"stringContains",
+	"stringContainsFuzzy",
+	"stringRegex",
+	"isNull",
+	"not",
+	"and",
+	"or",
+	"isIn"
+]);
+function isBooleanExpression(expr) {
+	return BOOLEAN_TYPES.has(expr.type);
+}
 /**
 * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.
 *
@@ -4570,8 +4692,17 @@ function traverseQuerySpec(query, visitor) {
 function mapSpecQueryColumns(query, visitor) {
 	return traverseQuerySpec(query, visitor);
 }
+/** Collects all column references from a SpecQuery tree. */
+function collectSpecQueryColumns(query) {
+	const result = [];
+	traverseQuerySpec(query, { column: (c) => {
+		result.push(c);
+		return c;
+	} });
+	return result;
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.js
 function mapPTableDef(def, cb) {
 	return {
 		...def,
@@ -4614,7 +4745,21 @@ function mapJoinEntry(entry, cb) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/filtered_column.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.js
+function getPTableColumnId(spec) {
+	switch (spec.type) {
+		case "axis": return {
+			type: "axis",
+			id: spec.id
+		};
+		case "column": return {
+			type: "column",
+			id: spec.id
+		};
+	}
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/filtered_column.js
 function stringifyColumnFilteredId(key) {
 	return canonicalizeJson(createColumnFilteredKey(key));
 }
@@ -4647,7 +4792,7 @@ function applyAxisFilters(spec, axisFilters) {
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/pool/spec.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/pool/spec.js
 function isPObjectId(value) {
 	if (typeof value !== "string") return false;
 	return isPObjectKey(parseJsonSafely(value));
@@ -4729,7 +4874,39 @@ function extractAllColumns(entry) {
 	addAllColumns(entry);
 	return [...columns.values()];
 }
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.5/node_modules/@milaboratories/helpers/dist/utils.js
+function isNil$1(v) {
+	return v === null || v === void 0;
+}
 Array.isArray;
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Checks if the given value is a plain object.
+*
+* A plain object is defined as an object created by the `{}` literal,
+* an object created with `Object.create(null)`, or an object with a
+* prototype that resolves to `Object.prototype`.
+*
+* @param value - The value to check.
+* @returns `true` if the value is a plain object, otherwise `false`.
+*
+* @example
+* ```typescript
+* isPlainObject({}); // true
+* isPlainObject(Object.create(null)); // true
+* isPlainObject(new Date()); // false
+* isPlainObject(null); // false
+* isPlainObject([]); // false
+* ```
+*/
+function isPlainObject$1(value) {
+	if (!isObject(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.5/node_modules/@milaboratories/helpers/dist/error.js
 function throwError(v) {
@@ -4737,7 +4914,7 @@ function throwError(v) {
 	else throw v;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/discovered_column.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/discovered_column.js
 function isColumnDiscoveredKey(obj) {
 	return typeof obj === "object" && obj !== null && "__isDiscovered" in obj;
 }
@@ -4757,56 +4934,252 @@ function stringifyColumnDiscoveredId(id) {
 	}));
 }
 //#endregion
-//#region ../node_modules/.pnpm/es-toolkit@1.48.1/node_modules/es-toolkit/dist/predicate/isFunction.mjs
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/array/uniq.mjs
 /**
-* Checks if `value` is a function.
+* Creates a duplicate-free version of an array.
 *
-* @param value The value to check.
-* @returns Returns `true` if `value` is a function, else `false`.
+* This function takes an array and returns a new array containing only the unique values
+* from the original array, preserving the order of first occurrence.
+*
+* @template T - The type of elements in the array.
+* @param arr - The array to process.
+* @returns A new array with only unique values from the original array.
 *
 * @example
-* isFunction(Array.prototype.slice); // true
-* isFunction(async function () {}); // true
-* isFunction(function* () {}); // true
-* isFunction(Proxy); // true
-* isFunction(Int8Array); // true
+* const array = [1, 2, 2, 3, 4, 4, 5];
+* const result = uniq(array);
+* // result will be [1, 2, 3, 4, 5]
 */
-function isFunction(value) {
-	return typeof value === "function";
+function uniq(arr) {
+	return [...new Set(arr)];
 }
 //#endregion
-//#region ../node_modules/.pnpm/es-toolkit@1.48.1/node_modules/es-toolkit/dist/predicate/isNil.mjs
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/array/uniqBy.mjs
 /**
-* Checks if a given value is null or undefined.
+* Returns a new array containing only the unique elements from the original array,
+* based on the values returned by the mapper function.
 *
-* This function tests whether the provided value is either `null` or `undefined`.
-* It returns `true` if the value is `null` or `undefined`, and `false` otherwise.
+* When duplicates are found, the first occurrence is kept and the rest are discarded.
 *
-* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.
+* @template T - The type of elements in the array.
+* @template U - The type of mapped elements.
+* @param arr - The array to process.
+* @param mapper - The function used to convert the array elements.
+* @returns A new array containing only the unique elements from the original array, based on the values returned by the mapper function.
 *
-* @param x - The value to test for null or undefined.
-* @returns `true` if the value is null or undefined, `false` otherwise.
+* @example
+* ```ts
+* uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);
+* // [1.2, 2.1, 3.2, 5.7, 7.19]
+* ```
 *
 * @example
-* const value1 = null;
-* const value2 = undefined;
-* const value3 = 42;
-* const result1 = isNil(value1); // true
-* const result2 = isNil(value2); // true
-* const result3 = isNil(value3); // false
+* const array = [
+*   { category: 'fruit', name: 'apple' },
+*   { category: 'fruit', name: 'banana' },
+*   { category: 'vegetable', name: 'carrot' },
+* ];
+* uniqBy(array, item => item.category).length
+* // 2
+* ```
 */
-function isNil(x) {
-	return x == null;
+function uniqBy(arr, mapper) {
+	const map = /* @__PURE__ */ new Map();
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		const key = mapper(item, i, arr);
+		if (!map.has(key)) map.set(key, item);
+	}
+	return Array.from(map.values());
 }
 //#endregion
-//#region ../node_modules/.pnpm/es-toolkit@1.48.1/node_modules/es-toolkit/dist/predicate/isString.mjs
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/_internal/globalThis.mjs
+const globalThis_ = typeof globalThis === "object" && globalThis || typeof window === "object" && window || typeof self === "object" && self || typeof global === "object" && global || (function() {
+	return this;
+})();
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
 /**
-* Checks if a given value is string.
+* Checks if a value is a TypedArray.
+* @param x The value to check.
+* @returns Returns true if `x` is a TypedArray, false otherwise.
 *
-* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `string`.
+* @example
+* const arr = new Uint8Array([1, 2, 3]);
+* isTypedArray(arr); // true
 *
-* @param value The value to check if it is string.
-* @returns Returns `true` if `value` is a string, else `false`.
+* const regularArray = [1, 2, 3];
+* isTypedArray(regularArray); // false
+*
+* const buffer = new ArrayBuffer(16);
+* isTypedArray(buffer); // false
+*/
+function isTypedArray$1(x) {
+	return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/predicate/isBuffer.mjs
+/**
+* Checks if the given value is a Buffer instance.
+*
+* This function tests whether the provided value is an instance of Buffer.
+* It returns `true` if the value is a Buffer, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`.
+*
+* @param x - The value to check if it is a Buffer.
+* @returns Returns `true` if `x` is a Buffer, else `false`.
+*
+* @example
+* const buffer = Buffer.from("test");
+* console.log(isBuffer(buffer)); // true
+*
+* const notBuffer = "not a buffer";
+* console.log(isBuffer(notBuffer)); // false
+*/
+function isBuffer(x) {
+	return typeof globalThis_.Buffer !== "undefined" && globalThis_.Buffer.isBuffer(x);
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+/**
+* Gets the `toStringTag` of `value`.
+*
+* @private
+* @param {T} value The value to query.
+* @returns {string} Returns the `Object.prototype.toString.call` result.
+*/
+function getTag(value) {
+	if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
+	return Object.prototype.toString.call(value);
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+/**
+* Checks if a given value is a plain object.
+*
+* @param value - The value to check.
+* @returns True if the value is a plain object, otherwise false.
+*
+* @example
+* ```typescript
+* // ✅👇 True
+*
+* isPlainObject({ });                       // ✅
+* isPlainObject({ key: 'value' });          // ✅
+* isPlainObject({ key: new Date() });       // ✅
+* isPlainObject(new Object());              // ✅
+* isPlainObject(Object.create(null));       // ✅
+* isPlainObject({ nested: { key: true} });  // ✅
+* isPlainObject(new Proxy({}, {}));         // ✅
+* isPlainObject({ [Symbol('tag')]: 'A' });  // ✅
+*
+* // ✅👇 (cross-realms, node context, workers, ...)
+* const runInNewContext = await import('node:vm').then(
+*     (mod) => mod.runInNewContext
+* );
+* isPlainObject(runInNewContext('({})'));   // ✅
+*
+* // ❌👇 False
+*
+* class Test { };
+* isPlainObject(new Test())           // ❌
+* isPlainObject(10);                  // ❌
+* isPlainObject(null);                // ❌
+* isPlainObject('hello');             // ❌
+* isPlainObject([]);                  // ❌
+* isPlainObject(new Date());          // ❌
+* isPlainObject(new Uint8Array([1])); // ❌
+* isPlainObject(Buffer.from('ABC'));  // ❌
+* isPlainObject(Promise.resolve({})); // ❌
+* isPlainObject(Object.create({}));   // ❌
+* isPlainObject(new (class Cls {}));  // ❌
+* isPlainObject(globalThis);          // ❌,
+* ```
+*/
+function isPlainObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/predicate/isFunction.mjs
+/**
+* Checks if `value` is a function.
+*
+* @param value The value to check.
+* @returns Returns `true` if `value` is a function, else `false`.
+*
+* @example
+* isFunction(Array.prototype.slice); // true
+* isFunction(async function () {}); // true
+* isFunction(function* () {}); // true
+* isFunction(Proxy); // true
+* isFunction(Int8Array); // true
+*/
+function isFunction(value) {
+	return typeof value === "function";
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/predicate/isLength.mjs
+/**
+* Checks if a given value is a valid length.
+*
+* A valid length is of type `number`, is a non-negative integer, and is less than or equal to
+* JavaScript's maximum safe integer (`Number.MAX_SAFE_INTEGER`).
+* It returns `true` if the value is a valid length, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the
+* argument to a valid length (`number`).
+*
+* @param value The value to check.
+* @returns Returns `true` if `value` is a valid length, else `false`.
+*
+* @example
+* isLength(0); // true
+* isLength(42); // true
+* isLength(-1); // false
+* isLength(1.5); // false
+* isLength(Number.MAX_SAFE_INTEGER); // true
+* isLength(Number.MAX_SAFE_INTEGER + 1); // false
+*/
+function isLength(value) {
+	return Number.isSafeInteger(value) && value >= 0;
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/predicate/isNil.mjs
+/**
+* Checks if a given value is null or undefined.
+*
+* This function tests whether the provided value is either `null` or `undefined`.
+* It returns `true` if the value is `null` or `undefined`, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.
+*
+* @param x - The value to test for null or undefined.
+* @returns `true` if the value is null or undefined, `false` otherwise.
+*
+* @example
+* const value1 = null;
+* const value2 = undefined;
+* const value3 = 42;
+* const result1 = isNil(value1); // true
+* const result2 = isNil(value2); // true
+* const result3 = isNil(value3); // false
+*/
+function isNil(x) {
+	return x == null;
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/predicate/isString.mjs
+/**
+* Checks if a given value is string.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `string`.
+*
+* @param value The value to check if it is string.
+* @returns Returns `true` if `value` is a string, else `false`.
 *
 * @example
 * const value1 = 'abc';
@@ -4821,7 +5194,7 @@ function isString(value) {
 	return typeof value === "string";
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.js
 /**
 * Canonically serializes a column key to a branded string id. Accepts both
 * the new {@link ColumnUniversalKey} and the deprecated {@link UniversalPColumnId}
@@ -4995,7 +5368,7 @@ function extractPObjectId(id) {
 	throw new Error(`extractPObjectId: unrecognized column id structure: ${JSON.stringify(id)}`);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/overridden.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/overridden.js
 function isColumnOverriddenKey(obj) {
 	return typeof obj === "object" && obj !== null && "__isOverridden" in obj;
 }
@@ -5117,7 +5490,7 @@ function mergeRecord(a, b) {
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/anchored.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/anchored.js
 function axisKey(axis) {
 	return (0, import_canonicalize.default)(getAxisId(axis));
 }
@@ -5363,7 +5736,7 @@ function isAnchorAxisRef(value) {
 	return typeof value === "object" && "anchor" in value;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.js
 /**
 * Determines if an axis ID matches an axis selector.
 *
@@ -5444,7 +5817,7 @@ function legacyColumnSelectorsToPredicate(predicateOrSelectors) {
 	else return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/native_id.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/native_id.js
 function deriveNativeId(spec) {
 	const result = {
 		kind: spec.kind,
@@ -5456,7 +5829,7 @@ function deriveNativeId(spec) {
 	return (0, import_canonicalize.default)(result);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/linker_columns.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/linker_columns.js
 var LinkerMap = class LinkerMap {
 	/** Graph of linkers connected by axes (single or grouped by parents) */
 	data;
@@ -5591,7 +5964,6 @@ var LinkerMap = class LinkerMap {
 		switch (axesSpec.length) {
 			case 0: return [];
 			case 1: return [[axesSpec[0]]];
-			default: break;
 		}
 		const axisKeys = axesSpec.map((spec) => canonicalizeJson(getAxisId(spec)));
 		const axisParentsIdxs = axesSpec.map((spec) => new Set(spec.parentAxesSpec.map((spec) => canonicalizeJson(getAxisId(spec))).map((el) => {
@@ -5634,7 +6006,7 @@ var LinkerMap = class LinkerMap {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.js
 /**
 * Required PFrames version. Bump this in lockstep with the `@milaboratories/pframes-rs-*`
 * version in `pnpm-workspace.yaml` so blocks built against the new SDK refuse to load on
@@ -5677,7 +6049,7 @@ function withEnrichments(ref, requireEnrichments = true) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/value_or_error.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/value_or_error.js
 function mapValueInVOE(voe, cb) {
 	return voe.ok ? {
 		ok: true,
@@ -5685,7 +6057,7 @@ function mapValueInVOE(voe, cb) {
 	} : voe;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/resource_types.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/resource_types.js
 /** Well-known resource type names used across the platform. */
 const ResourceTypeName = {
 	StreamManager: "StreamManager",
@@ -5729,7 +6101,7 @@ const ResourceTypeName = {
 	SharedEnvelope: "SharedEnvelope"
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_types.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/services/service_types.js
 const SERVICE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9]*$/;
 const { service, isNodeService, isWasmService, isMainService, getServiceKind, getServiceModelMethods, getServiceUiMethods } = (() => {
 	const typeMap = /* @__PURE__ */ new Map();
@@ -5768,7 +6140,7 @@ const { service, isNodeService, isWasmService, isMainService, getServiceKind, ge
 	};
 })();
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.js
 const Services = {
 	PFrameSpec: service()({
 		type: "wasm",
@@ -5862,7 +6234,7 @@ function resolveRequiredServices(flags) {
 }
 Object.fromEntries(Object.keys(Services).map((key) => [`requires${key}`, true]));
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_injectors.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/services/service_injectors.js
 function buildMethodMap(pick) {
 	const result = {};
 	for (const id of Object.values(Services)) result[id] = [...pick(id)];
@@ -5871,7 +6243,7 @@ function buildMethodMap(pick) {
 buildMethodMap(getServiceUiMethods);
 buildMethodMap(getServiceModelMethods);
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/accessor_traversal.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/columns/accessor_traversal.js
 /** Resource types that hold column collections — DFS stops here and collects. */
 const COLLECT_TYPES = [ResourceTypeName.PFrame];
 /** Resource types DFS descends through when looking for PFrames. */
@@ -5979,7 +6351,7 @@ function indexPoolBlock(block) {
 	return result;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/column_registry.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/columns/column_registry.js
 /**
 * Id-index over a set of {@link ColumnEntriesProvider}s. Sole job:
 * {@link PObjectId} → {@link LeafEntry}. Generic over the accessor flavour, so
@@ -6016,7 +6388,48 @@ var ColumnRegistry = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/providers.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/columns/dedup.js
+/**
+* Two-track dedup over an item stream keyed by `ColumnUniversalId`:
+*
+* - **Raw `PObjectId`s** are deduped by `deriveNativeId(spec)`. The same
+*   physical column reached via outputs vs. result_pool has different
+*   id shapes but identical nativeId — first occurrence wins so the
+*   provider order (outputs before pool) decides which id is canonical.
+* - **Non-`PObjectId` ids** (e.g. `SUniversalPColumnUniversalId`,
+*   `ColumnDiscoveredId`) keep raw-id dedup — they legitimately share
+*   nativeId with siblings.
+*
+* When `getSpec` returns `undefined` for a `PObjectId`, falls back to raw-id
+* dedup (so an unresolvable id still survives instead of dropping silently).
+*
+* Shared by sandbox-side `extractColumns` (column_providers) and host-side
+* `ColumnsCollectionDriverImpl.getColumns` — both layers need identical
+* dedup semantics, but operate on different concrete item types (DataColumnRecipe
+* vs. raw ColumnUniversalId).
+*/
+function dedupColumns(items, getId, getSpec) {
+	const seenNative = /* @__PURE__ */ new Set();
+	const seenId = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const item of items) {
+		const id = getId(item);
+		if (seenId.has(id)) continue;
+		if (isPObjectId(id)) {
+			const spec = getSpec(item);
+			if (spec !== void 0) {
+				const nativeId = deriveNativeId(spec);
+				if (seenNative.has(nativeId)) continue;
+				seenNative.add(nativeId);
+			}
+		}
+		seenId.add(id);
+		out.push(item);
+	}
+	return out;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/columns/providers.js
 /**
 * Generic entries provider over a single accessor root. Walks `<root>` once
 * from the supplied `rootPath`, builds an id → {@link LeafEntry} map and
@@ -6073,7 +6486,7 @@ var ResultPoolEntriesProvider = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/template/template_ref_form.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/template/template_ref_form.js
 /**
 * Whether `value` is a reference in the readable spelling.
 *
@@ -6142,7 +6555,7 @@ function expandTemplatePlRef(ref) {
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/template/template_relocate.js
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.51.0/node_modules/@milaboratories/pl-model-common/dist/template/template_relocate.js
 /**
 * Point every column identifier in a block's params at the blocks of the project being built.
 *
@@ -6158,8 +6571,13 @@ function expandTemplatePlRef(ref) {
 *
 * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields
 * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*
-* like an id — a `domain` entry, an axis filter — from being rewritten along with it, and
-* what re-sorts a qualifications map whose keys are identifiers.
+* like an id — an axis filter, a domain this package can see belongs to an identifier it
+* knows — from being rewritten along with it, and what re-sorts a qualifications map whose
+* keys are identifiers.
+*
+* A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is
+* qualified by the block that produced it. Only the domain keys known to name a block are
+* repointed — matching an entry id is not on its own evidence of a reference.
 *
 * An id the map does not mention is left as it is. That is the ordering rule doing its work:
 * a caller building the map as it creates blocks passes only the entries already created, so
@@ -6177,13 +6595,27 @@ function relocateBlockIds(params, blockIds) {
 		if (typeof node === "string") return remapColumnIdBlockIds(node, remapBlockId);
 		if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);
 		if (Array.isArray(node)) return node.map(walk);
-		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [remapColumnIdBlockIds(key, remapBlockId), walk(value)]));
+		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [remapColumnIdBlockIds(key, remapBlockId), key === "domain" && isPlainObject(value) ? relocateDomain(value) : walk(value)]));
 		return node;
 	};
+	/**
+	* The block-naming entries of a domain, repointed at the project being built: an axis a block
+	* produced names that block in its domain, so those are references like any other.
+	*
+	* Only the keys {@link BlockScopedDomain} lists, because a template's entry ids are arbitrary
+	* non-empty strings — a hand-written template may name an entry `closest`, and a qualifier
+	* reading `closest` is not a reference to it. Matching the map is not on its own enough to
+	* tell one from the other; the key is.
+	*
+	* Reached only from the generic object case — inside an identifier this package recognizes a
+	* domain is spec data and stays as it is, which is what keeps an overridden column's
+	* `specOverrides.domain` untouched.
+	*/
+	const relocateDomain = (domain) => Object.fromEntries(Object.entries(domain).map(([key, value]) => [key, typeof value === "string" && BlockScopedDomain.has(key) ? remapBlockId(value) : walk(value)]));
 	return walk(params);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_migrations.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/block_migrations.js
 /** Create a DataVersioned wrapper with correct shape */
 function makeVersionedData(version, data) {
 	return {
@@ -6761,7 +7193,7 @@ var DataModel = class DataModel {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/internal.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/internal.js
 /** Utility code helping to identify whether the code is running in actual UI environment */
 function isInUI() {
 	return typeof globalThis.getPlatforma !== "undefined" || typeof globalThis.platforma !== "undefined";
@@ -6831,7 +7263,7 @@ function registerFutureAwait(handle, onResolve) {
 	futureResolves.get(handle).push(onResolve);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_storage_facade.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/block_storage_facade.js
 /**
 * All facade callback names as constants.
 * These are the source of truth - the interface is derived from these.
@@ -6869,7 +7301,23 @@ function registerFacadeCallbacks(callbacks) {
 	for (const key of Object.values(BlockStorageFacadeCallbacks)) tryRegisterCallback(key, callbacks[key]);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/render/future.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/services/block_services.js
+/**
+* Services required by all V3 blocks by default.
+* Edit this when a new service should be available to all blocks.
+*
+* Standalone module to avoid circular dependencies between block_model.ts
+* and service type resolution.
+*/
+const BLOCK_SERVICE_FLAGS = {
+	requiresPFrameSpec: true,
+	requiresPFrame: true,
+	requiresDialog: true,
+	requiresColumnsCollection: true
+};
+resolveRequiredServices(BLOCK_SERVICE_FLAGS);
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/render/future.js
 var FutureRef = class FutureRef {
 	handle;
 	postProcess;
@@ -6897,7 +7345,7 @@ var FutureRef = class FutureRef {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/render/accessor.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/render/accessor.js
 function ifDef(value, cb) {
 	return value === void 0 ? void 0 : cb(value);
 }
@@ -7147,11 +7595,11 @@ var TreeNodeAccessor = class TreeNodeAccessor {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/render/internal.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/render/internal.js
 const MainAccessorName = "main";
 const StagingAccessorName = "staging";
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/render/util/axis_filtering.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/render/util/axis_filtering.js
 function filterDataInfoEntries(dataInfoEntries, axisFilters) {
 	const sortedFilters = [...axisFilters].sort((a, b) => b[0] - a[0]);
 	const { type } = dataInfoEntries;
@@ -7215,7 +7663,7 @@ function filterDataInfoEntries(dataInfoEntries, axisFilters) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/labels/linked_column_postfix.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/labels/linked_column_postfix.js
 /**
 * Structural postfix derivation for linked columns (phase 2 of `deriveDistinctLabels`).
 *
@@ -7398,7 +7846,7 @@ function derivePostfixes(entries, format = defaultLinkerFormatter) {
 	});
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/labels/derive_distinct_labels.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/labels/derive_distinct_labels.js
 const DISTANCE_PENALTY = .001;
 const LABEL_TYPE = "__LABEL__";
 const LABEL_TYPE_FULL = "__LABEL__@1";
@@ -7686,7 +8134,7 @@ function repairBareByPresence(labels, minimized, records, stats, forcedSet, forc
 	return patched;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/render/util/label.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/render/util/label.js
 /** @deprecated Use deriveDistinctLabels */
 function deriveLabels(values, getSpec, options = {}) {
 	return deriveDistinctLabels(values.map(getSpec), options).map((label, i) => ({
@@ -7695,7 +8143,7 @@ function deriveLabels(values, getSpec, options = {}) {
 	}));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/render/util/pcolumn_data.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/render/util/pcolumn_data.js
 const RT_RESOURCE_MAP = "PColumnData/ResourceMap";
 const RT_RESOURCE_MAP_PARTITIONED = "PColumnData/Partitioned/ResourceMap";
 const RT_JSON_PARTITIONED = "PColumnData/JsonPartitioned";
@@ -7736,9 +8184,7 @@ function getPartitionKeysList(acc) {
 			break;
 		case RT_BINARY_SUPER_PARTITIONED:
 		case RT_JSON_SUPER_PARTITIONED:
-		case RT_PARQUET_SUPER_PARTITIONED:
-			keyLength = meta["superPartitionKeyLength"] + meta["partitionKeyLength"];
-			break;
+		case RT_PARQUET_SUPER_PARTITIONED: keyLength = meta["superPartitionKeyLength"] + meta["partitionKeyLength"];
 	}
 	switch (rt) {
 		case RT_RESOURCE_MAP:
@@ -7754,20 +8200,18 @@ function getPartitionKeysList(acc) {
 		case RT_RESOURCE_MAP_PARTITIONED:
 		case RT_BINARY_SUPER_PARTITIONED:
 		case RT_JSON_SUPER_PARTITIONED:
-		case RT_PARQUET_SUPER_PARTITIONED:
-			for (const supKeyStr of acc.listInputFields()) {
-				const keyPrefix = [...JSON.parse(supKeyStr)];
-				const value = acc.resolve({
-					field: supKeyStr,
-					assertFieldType: "Input"
-				});
-				if (value !== void 0) for (let keyStr of value.listInputFields()) {
-					if (rt === "PColumnData/Partitioned/BinaryPartitioned") keyStr = removeIndexSuffix(keyStr).baseKey;
-					const key = [...keyPrefix, ...JSON.parse(keyStr)];
-					data.push(key);
-				}
+		case RT_PARQUET_SUPER_PARTITIONED: for (const supKeyStr of acc.listInputFields()) {
+			const keyPrefix = [...JSON.parse(supKeyStr)];
+			const value = acc.resolve({
+				field: supKeyStr,
+				assertFieldType: "Input"
+			});
+			if (value !== void 0) for (let keyStr of value.listInputFields()) {
+				if (rt === "PColumnData/Partitioned/BinaryPartitioned") keyStr = removeIndexSuffix(keyStr).baseKey;
+				const key = [...keyPrefix, ...JSON.parse(keyStr)];
+				data.push(key);
 			}
-			break;
+		}
 	}
 	return {
 		data,
@@ -7993,7 +8437,7 @@ function allPColumnsReady(columns) {
 	return columns.every(isPColumnReady);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/render/util/column_collection.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/render/util/column_collection.js
 function isPColumnValues(value) {
 	if (!Array.isArray(value)) return false;
 	if (value.length === 0) return true;
@@ -8271,23 +8715,7 @@ var PColumnCollection = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/services/block_services.js
-/**
-* Services required by all V3 blocks by default.
-* Edit this when a new service should be available to all blocks.
-*
-* Standalone module to avoid circular dependencies between block_model.ts
-* and service type resolution.
-*/
-const BLOCK_SERVICE_FLAGS = {
-	requiresPFrameSpec: true,
-	requiresPFrame: true,
-	requiresDialog: true,
-	requiresColumnsCollection: true
-};
-resolveRequiredServices(BLOCK_SERVICE_FLAGS);
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/services/service_bridge.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/services/service_bridge.js
 /**
 * Builds a ServiceProxy from a ServiceDispatch.
 * Each service method call is forwarded to dispatch.callServiceMethod.
@@ -8296,7 +8724,7 @@ function createServiceProxy(dispatch) {
 	return ((serviceId) => Object.freeze(Object.fromEntries(dispatch.getServiceMethods(serviceId).map((method) => [method, (...args) => dispatch.callServiceMethod(serviceId, method, ...args)]))));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/services/get_services.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/services/get_services.js
 const cachedServices = /* @__PURE__ */ new WeakMap();
 function getService(name, deps) {
 	const ctx = deps?.ctx ?? getCfgRenderCtx();
@@ -8310,7 +8738,7 @@ function getService(name, deps) {
 	})();
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/render/util/pframe_upgraders.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/render/util/pframe_upgraders.js
 function patchInSetFilters(filters) {
 	const inSetToOrEqual = (predicate) => {
 		if (predicate.operator !== "InSet") return predicate;
@@ -8348,7 +8776,7 @@ function patchInSetFilters(filters) {
 	return filters.map((filter) => mapFilter(filter, inSetToOrEqual));
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/render/api.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/render/api.js
 /**
 * Helper function to match domain objects
 * @param query Optional domain to match against
@@ -8797,27 +9225,27 @@ var PluginRenderCtx = class extends RenderCtxBase {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/version.js
-const PlatformaSDKVersion = "1.82.0";
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/plugin_model.js
+/** Internal plugin↔block handshake. `Symbol.for` (not `Symbol`) so it stays
+* identical across multiple `@platforma-sdk/model` copies in one process. */
+const CREATE_PLUGIN_MODEL = Symbol.for("@platforma-sdk/model:createPluginModel");
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/version.js
+const PlatformaSDKVersion = "1.84.1";
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/bconfig/types.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/bconfig/types.js
 function isConfigLambda(cfgOrFh) {
 	return cfgOrFh.__renderLambda === true;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/bconfig/normalization.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/bconfig/normalization.js
 function downgradeCfgOrLambda(data) {
 	if (data === void 0) return void 0;
 	if (isConfigLambda(data)) return data.handle;
 	return data;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/plugin_model.js
-/** Internal plugin↔block handshake. `Symbol.for` (not `Symbol`) so it stays
-* identical across multiple `@platforma-sdk/model` copies in one process. */
-const CREATE_PLUGIN_MODEL = Symbol.for("@platforma-sdk/model:createPluginModel");
-//#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_storage_callbacks.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/block_storage_callbacks.js
 /**
 * BlockStorage Callback Implementations - wired to facade callbacks in BlockModelV3.done().
 *
@@ -9171,7 +9599,7 @@ function deriveTemplateParamsFromStorage(storageJson, deriveTemplateParams) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_model.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/block_model.js
 /**
 * Merges two feature flag objects with type-aware logic:
 * - `supports*` (boolean): OR — `true` if either side is `true`
@@ -9537,7 +9965,7 @@ var BlockModelV3 = class BlockModelV3 {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/pframe_utils/axes.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/pframe_utils/axes.js
 /** Create id for column copy with added keys in axes domains */
 const colId = (id, domains, contextDomains) => {
 	let wid = id.toString();
@@ -9643,7 +10071,7 @@ function getAdditionalColumnsForColumn(blockAxes, column) {
 	})];
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/leaf_rebrand.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/leaf_rebrand.js
 /**
 * Replace every column leaf whose id equals `fromId` with `toId`, leaving
 * other column refs (linkers, sub-anchors) intact. Wrapper recipes
@@ -9661,29 +10089,38 @@ function rebrandLeafId(node, fromId, toId) {
 	return mapSpecQueryColumns(node, { column: (id) => id === fromId ? toId : id });
 }
 //#endregion
-//#region ../node_modules/.pnpm/lru-cache@11.5.1/node_modules/lru-cache/dist/esm/browser/index.min.js
-var L = { hasSubscribers: !1 }, S = L, W = L;
+//#region ../node_modules/.pnpm/lru-cache@11.5.3/node_modules/lru-cache/dist/esm/browser/index.min.js
+var L = { hasSubscribers: !1 };
+var S = L;
+var W = L;
 var M = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
-var D = () => S.hasSubscribers || W.hasSubscribers, j = /* @__PURE__ */ new Set(), I = typeof process == "object" && process ? process : {}, P = (u, e, t, i) => {
-	typeof I.emitWarning == "function" ? I.emitWarning(u, e, t, i) : console.error(`[${t}] ${e}: ${u}`);
-}, k = (u) => !j.has(u);
-var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(u) ? u <= Math.pow(2, 8) ? Uint8Array : u <= Math.pow(2, 16) ? Uint16Array : u <= Math.pow(2, 32) ? Uint32Array : u <= Number.MAX_SAFE_INTEGER ? O : null : null, O = class extends Array {
+var R = () => S.hasSubscribers || W.hasSubscribers;
+var j = /* @__PURE__ */ new Set();
+var I = typeof process == "object" && process ? process : {};
+var P = (d, e, t, i) => {
+	typeof I.emitWarning == "function" ? I.emitWarning(d, e, t, i) : console.error(`[${t}] ${e}: ${d}`);
+};
+var k = (d) => !j.has(d);
+var T = (d) => !!d && d === Math.floor(d) && d > 0 && isFinite(d);
+var G = (d) => T(d) ? d <= Math.pow(2, 8) ? Uint8Array : d <= Math.pow(2, 16) ? Uint16Array : d <= Math.pow(2, 32) ? Uint32Array : d <= Number.MAX_SAFE_INTEGER ? O : null : null;
+var O = class extends Array {
 	constructor(e) {
 		super(e), this.fill(0);
 	}
-}, R = class u {
+};
+var x = class d {
 	heap;
 	length;
 	static #o = !1;
 	static create(e) {
 		let t = G(e);
 		if (!t) return [];
-		u.#o = !0;
-		let i = new u(e, t);
-		return u.#o = !1, i;
+		d.#o = !0;
+		let i = new d(e, t);
+		return d.#o = !1, i;
 	}
 	constructor(e, t) {
-		if (!u.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+		if (!d.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
 		this.heap = new t(e), this.length = 0;
 	}
 	push(e) {
@@ -9692,7 +10129,8 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 	pop() {
 		return this.heap[--this.length];
 	}
-}, U = class u {
+};
+var U = class d {
 	#o;
 	#c;
 	#S;
@@ -9738,7 +10176,7 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 	#T;
 	#U;
 	#f;
-	#x;
+	#D;
 	static unsafeExposeInternals(e) {
 		return {
 			starts: e.#F,
@@ -9793,87 +10231,90 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 		return this.#w;
 	}
 	constructor(e) {
-		let { max: t = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: r, updateAgeOnHas: h, allowStale: a, dispose: o, onInsert: d, disposeAfter: y, noDisposeOnSet: _, noUpdateTTL: c, maxSize: g = 0, maxEntrySize: f = 0, sizeCalculation: b, fetchMethod: l, memoMethod: w, noDeleteOnFetchRejection: F, noDeleteOnStaleGet: m, allowStaleOnFetchRejection: p, allowStaleOnFetchAbort: A, ignoreFetchAbort: z, backgroundFetchSize: C = 1, perf: E } = e;
+		let { max: t = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: l, allowStale: h, dispose: r, onInsert: c, disposeAfter: m, noDisposeOnSet: _, noUpdateTTL: u, maxSize: g = 0, maxEntrySize: f = 0, sizeCalculation: y, fetchMethod: a, memoMethod: w, noDeleteOnFetchRejection: F, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: p, allowStaleOnFetchAbort: A, ignoreFetchAbort: z, backgroundFetchSize: C = 1, perf: E } = e;
 		if (this.backgroundFetchSize = C, E !== void 0 && typeof E?.now != "function") throw new TypeError("perf option must have a now() method if specified");
 		if (this.#m = E ?? M, t !== 0 && !T(t)) throw new TypeError("max option must be a nonnegative integer");
 		let v = t ? G(t) : Array;
 		if (!v) throw new Error("invalid max value: " + t);
-		if (this.#o = t, this.#c = g, this.maxEntrySize = f || this.#c, this.sizeCalculation = b, this.sizeCalculation) {
+		if (this.#o = t, this.#c = g, this.maxEntrySize = f || this.#c, this.sizeCalculation = y, this.sizeCalculation) {
 			if (!this.#c && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
 			if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
 		}
 		if (w !== void 0 && typeof w != "function") throw new TypeError("memoMethod must be a function if defined");
-		if (this.#I = w, l !== void 0 && typeof l != "function") throw new TypeError("fetchMethod must be a function if specified");
-		if (this.#M = l, this.#U = !!l, this.#s = /* @__PURE__ */ new Map(), this.#i = Array.from({ length: t }).fill(void 0), this.#t = Array.from({ length: t }).fill(void 0), this.#l = new v(t), this.#u = new v(t), this.#a = 0, this.#h = 0, this.#y = R.create(t), this.#n = 0, this.#b = 0, typeof o == "function" && (this.#S = o), typeof d == "function" && (this.#O = d), typeof y == "function" ? (this.#w = y, this.#r = []) : (this.#w = void 0, this.#r = void 0), this.#T = !!this.#S, this.#x = !!this.#O, this.#f = !!this.#w, this.noDisposeOnSet = !!_, this.noUpdateTTL = !!c, this.noDeleteOnFetchRejection = !!F, this.allowStaleOnFetchRejection = !!p, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z, this.maxEntrySize !== 0) {
+		if (this.#I = w, a !== void 0 && typeof a != "function") throw new TypeError("fetchMethod must be a function if specified");
+		if (this.#M = a, this.#U = !!a, this.#s = /* @__PURE__ */ new Map(), this.#i = Array.from({ length: t }).fill(void 0), this.#t = Array.from({ length: t }).fill(void 0), this.#l = new v(t), this.#u = new v(t), this.#a = 0, this.#h = 0, this.#y = x.create(t), this.#n = 0, this.#b = 0, typeof r == "function" && (this.#S = r), typeof c == "function" && (this.#O = c), typeof m == "function" ? (this.#w = m, this.#r = []) : (this.#w = void 0, this.#r = void 0), this.#T = !!this.#S, this.#D = !!this.#O, this.#f = !!this.#w, this.noDisposeOnSet = !!_, this.noUpdateTTL = !!u, this.noDeleteOnFetchRejection = !!F, this.allowStaleOnFetchRejection = !!p, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z, this.maxEntrySize !== 0) {
 			if (this.#c !== 0 && !T(this.#c)) throw new TypeError("maxSize must be a positive integer if specified");
 			if (!T(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
 			this.#X();
 		}
-		if (this.allowStale = !!a, this.noDeleteOnStaleGet = !!m, this.updateAgeOnGet = !!r, this.updateAgeOnHas = !!h, this.ttlResolution = T(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
+		if (this.allowStale = !!h, this.noDeleteOnStaleGet = !!b, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!l, this.ttlResolution = T(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
 			if (!T(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
 			this.#k();
 		}
 		if (this.#o === 0 && this.ttl === 0 && this.#c === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
 		if (!this.ttlAutopurge && !this.#o && !this.#c) {
-			let x = "LRU_CACHE_UNBOUNDED";
-			k(x) && (j.add(x), P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", x, u));
+			let D = "LRU_CACHE_UNBOUNDED";
+			k(D) && (j.add(D), P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", D, d));
 		}
 	}
 	getRemainingTTL(e) {
-		return this.#s.has(e) ? Infinity : 0;
+		return this.#s.has(e) ? 1 / 0 : 0;
 	}
 	#k() {
 		let e = new O(this.#o), t = new O(this.#o);
 		this.#d = e, this.#F = t;
 		let i = this.ttlAutopurge ? Array.from({ length: this.#o }) : void 0;
-		this.#g = i, this.#H = (h, a, o = this.#m.now()) => {
-			t[h] = a !== 0 ? o : 0, e[h] = a, s(h, a);
-		}, this.#D = (h) => {
+		this.#g = i, this.#H = (h, r, c = this.#m.now()) => {
+			t[h] = r !== 0 ? c : 0, e[h] = r, s(h, r);
+		}, this.#R = (h) => {
 			t[h] = e[h] !== 0 ? this.#m.now() : 0, s(h, e[h]);
 		};
-		let s = this.ttlAutopurge ? (h, a) => {
-			if (i?.[h] && (clearTimeout(i[h]), i[h] = void 0), a && a !== 0 && i) {
-				let o = setTimeout(() => {
-					this.#p(h) && this.#E(this.#i[h], "expire");
-				}, a + 1);
-				o.unref && o.unref(), i[h] = o;
+		let s = this.ttlAutopurge ? (h, r) => {
+			if (i?.[h] && (clearTimeout(i[h]), i[h] = void 0), r && r !== 0 && i) {
+				let c = setTimeout(() => {
+					this.#p(h) ? (this.#E(this.#i[h], "expire"), i[h] = void 0) : s(h, l(h));
+				}, r + 1);
+				c.unref && c.unref(), i[h] = c;
 			}
 		} : () => {};
-		this.#v = (h, a) => {
-			if (e[a]) {
-				let o = e[a], d = t[a];
-				if (!o || !d) return;
-				h.ttl = o, h.start = d, h.now = n || r();
-				h.remainingTTL = o - (h.now - d);
+		this.#v = (h, r) => {
+			if (e[r]) {
+				let c = e[r], m = t[r];
+				if (!c || !m) return;
+				h.ttl = c, h.start = m, h.now = n || o();
+				h.remainingTTL = c - (h.now - m);
 			}
 		};
-		let n = 0, r = () => {
+		let n = 0, o = () => {
 			let h = this.#m.now();
 			if (this.ttlResolution > 0) {
 				n = h;
-				let a = setTimeout(() => n = 0, this.ttlResolution);
-				a.unref && a.unref();
+				let r = setTimeout(() => n = 0, this.ttlResolution);
+				r.unref && r.unref();
 			}
 			return h;
 		};
 		this.getRemainingTTL = (h) => {
-			let a = this.#s.get(h);
-			if (a === void 0) return 0;
-			let o = e[a], d = t[a];
-			if (!o || !d) return Infinity;
-			return o - ((n || r()) - d);
-		}, this.#p = (h) => {
-			let a = t[h], o = e[h];
-			return !!o && !!a && (n || r()) - a > o;
+			let r = this.#s.get(h);
+			return r === void 0 ? 0 : l(r);
+		};
+		let l = (h) => {
+			let r = e[h], c = t[h];
+			if (!r || !c) return 1 / 0;
+			return r - ((n || o()) - c);
+		};
+		this.#p = (h) => {
+			let r = t[h], c = e[h];
+			return !!c && !!r && (n || o()) - r > c;
 		};
 	}
-	#D = () => {};
+	#R = () => {};
 	#v = () => {};
 	#H = () => {};
 	#p = () => !1;
 	#X() {
 		let e = new O(this.#o);
-		this.#b = 0, this.#_ = e, this.#R = (t) => {
+		this.#b = 0, this.#_ = e, this.#x = (t) => {
 			this.#b -= e[t], e[t] = 0;
 		}, this.#N = (t, i, s, n) => {
 			if (!T(s)) {
@@ -9892,7 +10333,7 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 			this.#b += e[t], s && (s.entrySize = i, s.totalCalculatedSize = this.#b);
 		};
 	}
-	#R = (e) => {};
+	#x = (e) => {};
 	#j = (e, t, i) => {};
 	#N = (e, t, i, s) => {
 		if (i || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
@@ -9965,8 +10406,8 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 		if (s === void 0) return;
 		let n = { value: s };
 		if (this.#d && this.#F) {
-			let r = this.#d[t], h = this.#F[t];
-			if (r && h) n.ttl = r - (this.#m.now() - h), n.start = Date.now();
+			let o = this.#d[t], l = this.#F[t];
+			if (o && l) n.ttl = o - (this.#m.now() - l), n.start = Date.now();
 		}
 		return this.#_ && (n.size = this.#_[t]), n;
 	}
@@ -9975,13 +10416,13 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 		for (let t of this.#A({ allowStale: !0 })) {
 			let i = this.#i[t], s = this.#t[t], n = this.#e(s) ? s.__staleWhileFetching : s;
 			if (n === void 0 || i === void 0) continue;
-			let r = { value: n };
+			let o = { value: n };
 			if (this.#d && this.#F) {
-				r.ttl = this.#d[t];
-				let h = this.#m.now() - this.#F[t];
-				r.start = Math.floor(Date.now() - h);
+				o.ttl = this.#d[t];
+				let l = this.#m.now() - this.#F[t];
+				o.start = Math.floor(Date.now() - l);
 			}
-			this.#_ && (r.size = this.#_[t]), e.unshift([i, r]);
+			this.#_ && (o.size = this.#_[t]), e.unshift([i, o]);
 		}
 		return e;
 	}
@@ -10002,19 +10443,19 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 		return s && S.hasSubscribers && S.publish(s), n;
 	}
 	#W(e, t, i, s) {
-		let { ttl: n = this.ttl, start: r, noDisposeOnSet: h = this.noDisposeOnSet, sizeCalculation: a = this.sizeCalculation, status: o } = i, d = this.#e(t);
-		if (t === void 0) return o && (o.set = "deleted"), this.delete(e), this;
-		let { noUpdateTTL: y = this.noUpdateTTL } = i;
-		o && !d && (o.value = t);
-		let _ = this.#N(e, t, i.size || 0, a, o);
-		if (this.maxEntrySize && _ > this.maxEntrySize) return this.#E(e, "set"), o && (o.set = "miss", o.maxEntrySizeExceeded = !0), this;
-		let c = this.#n === 0 ? void 0 : this.#s.get(e);
-		if (c === void 0) c = this.#n === 0 ? this.#h : this.#y.length !== 0 ? this.#y.pop() : this.#n === this.#o ? this.#G(!1) : this.#n, this.#i[c] = e, this.#t[c] = t, this.#s.set(e, c), this.#l[this.#h] = c, this.#u[c] = this.#h, this.#h = c, this.#n++, this.#j(c, _, o), o && (o.set = "add"), y = !1, this.#x && !d && this.#O?.(t, e, "add");
+		let { ttl: n = this.ttl, start: o, noDisposeOnSet: l = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: r } = i, c = this.#e(t);
+		if (t === void 0) return r && (r.set = "deleted"), this.delete(e), this;
+		let { noUpdateTTL: m = this.noUpdateTTL } = i;
+		r && !c && (r.value = t);
+		let _ = this.#N(e, t, i.size || 0, h, r);
+		if (this.maxEntrySize && _ > this.maxEntrySize) return this.#E(e, "set"), r && (r.set = "miss", r.maxEntrySizeExceeded = !0), this;
+		let u = this.#n === 0 ? void 0 : this.#s.get(e);
+		if (u === void 0) u = this.#n === 0 ? this.#h : this.#y.length !== 0 ? this.#y.pop() : this.#n === this.#o ? this.#G(!1) : this.#n, this.#i[u] = e, this.#t[u] = t, this.#s.set(e, u), this.#l[this.#h] = u, this.#u[u] = this.#h, this.#h = u, this.#n++, this.#j(u, _, r), r && (r.set = "add"), m = !1, this.#D && !c && this.#O?.(t, e, "add");
 		else {
-			this.#L(c);
-			let g = this.#t[c];
+			this.#L(u);
+			let g = this.#t[u];
 			if (t !== g) {
-				if (!h) if (this.#e(g)) {
+				if (!l) if (this.#e(g)) {
 					g !== s && g.__abortController.abort(/* @__PURE__ */ new Error("replaced"));
 					let { __staleWhileFetching: f } = g;
 					f !== void 0 && f !== t && (this.#T && this.#S?.(f, e, "set"), this.#f && this.#r?.push([
@@ -10027,13 +10468,13 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 					e,
 					"set"
 				]);
-				if (this.#R(c), this.#j(c, _, o), this.#t[c] = t, !d) {
-					let f = g && this.#e(g) ? g.__staleWhileFetching : g, b = f === void 0 ? "add" : t !== f ? "replace" : "update";
-					o && (o.set = b, f !== void 0 && (o.oldValue = f)), this.#x && this.onInsert?.(t, e, b);
+				if (this.#x(u), this.#j(u, _, r), this.#t[u] = t, !c) {
+					let f = g && this.#e(g) ? g.__staleWhileFetching : g, y = f === void 0 ? "add" : t !== f ? "replace" : "update";
+					r && (r.set = y, f !== void 0 && (r.oldValue = f)), this.#D && this.onInsert?.(t, e, y);
 				}
-			} else d || (o && (o.set = "update"), this.#x && this.onInsert?.(t, e, "update"));
+			} else c || (r && (r.set = "update"), this.#D && this.onInsert?.(t, e, "update"));
 		}
-		if (n !== 0 && !this.#d && this.#k(), this.#d && (y || this.#H(c, n, r), o && this.#v(o, c)), !h && this.#f && this.#r) {
+		if (n !== 0 && !this.#d && this.#k(), this.#d && (m || this.#H(u, n, o), r && this.#v(r, u)), !l && this.#f && this.#r) {
 			let g = this.#r, f;
 			for (; f = g?.shift();) this.#w?.(...f);
 		}
@@ -10057,12 +10498,12 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 	#G(e) {
 		let t = this.#a, i = this.#i[t], s = this.#t[t], n = this.#e(s);
 		n && s.__abortController.abort(/* @__PURE__ */ new Error("evicted"));
-		let r = n ? s.__staleWhileFetching : s;
-		return (this.#T || this.#f) && r !== void 0 && (this.#T && this.#S?.(r, i, "evict"), this.#f && this.#r?.push([
-			r,
+		let o = n ? s.__staleWhileFetching : s;
+		return (this.#T || this.#f) && o !== void 0 && (this.#T && this.#S?.(o, i, "evict"), this.#f && this.#r?.push([
+			o,
 			i,
 			"evict"
-		])), this.#R(t), this.#g?.[t] && (clearTimeout(this.#g[t]), this.#g[t] = void 0), e && (this.#i[t] = void 0, this.#t[t] = void 0, this.#y.push(t)), this.#n === 1 ? (this.#a = this.#h = 0, this.#y.length = 0) : this.#a = this.#l[t], this.#s.delete(i), this.#n--, t;
+		])), this.#x(t), this.#g?.[t] && (clearTimeout(this.#g[t]), this.#g[t] = void 0), e && (this.#i[t] = void 0, this.#t[t] = void 0, this.#y.push(t)), this.#n === 1 ? (this.#a = this.#h = 0, this.#y.length = 0) : this.#a = this.#l[t], this.#s.delete(i), this.#n--, t;
 	}
 	has(e, t = {}) {
 		let { status: i = S.hasSubscribers ? {} : void 0 } = t;
@@ -10073,15 +10514,15 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 	#Y(e, t = {}) {
 		let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = t, n = this.#s.get(e);
 		if (n !== void 0) {
-			let r = this.#t[n];
-			if (this.#e(r) && r.__staleWhileFetching === void 0) return !1;
+			let o = this.#t[n];
+			if (this.#e(o) && o.__staleWhileFetching === void 0) return !1;
 			if (this.#p(n)) s && (s.has = "stale", this.#v(s, n));
-			else return i && this.#D(n), s && (s.has = "hit", this.#v(s, n)), !0;
+			else return i && this.#R(n), s && (s.has = "hit", this.#v(s, n)), !0;
 		} else s && (s.has = "miss");
 		return !1;
 	}
 	peek(e, t = {}) {
-		let { status: i = D() ? {} : void 0 } = t;
+		let { status: i = R() ? {} : void 0 } = t;
 		i && (i.op = "peek", i.key = e, i.cache = this), t.status = i;
 		let s = this.#J(e, t);
 		return S.hasSubscribers && S.publish(i), s;
@@ -10092,41 +10533,41 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 			i && (i.peek = n === void 0 ? "miss" : "stale");
 			return;
 		}
-		let r = this.#t[n], h = this.#e(r) ? r.__staleWhileFetching : r;
-		return i && (h !== void 0 ? (i.peek = "hit", i.value = h) : i.peek = "miss"), h;
+		let o = this.#t[n], l = this.#e(o) ? o.__staleWhileFetching : o;
+		return i && (l !== void 0 ? (i.peek = "hit", i.value = l) : i.peek = "miss"), l;
 	}
 	#P(e, t, i, s) {
 		let n = t === void 0 ? void 0 : this.#t[t];
 		if (this.#e(n)) return n;
-		let r = new AbortController(), { signal: h } = i;
-		h?.addEventListener("abort", () => r.abort(h.reason), { signal: r.signal });
-		let a = {
-			signal: r.signal,
+		let o = new AbortController(), { signal: l } = i;
+		l?.addEventListener("abort", () => o.abort(l.reason), { signal: o.signal });
+		let h = {
+			signal: o.signal,
 			options: i,
 			context: s
-		}, o = (f, b = !1) => {
-			let { aborted: l } = r.signal, w = i.ignoreFetchAbort && f !== void 0, F = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && f !== void 0);
-			if (i.status && (l && !b ? (i.status.fetchAborted = !0, i.status.fetchError = r.signal.reason, w && (i.status.fetchAbortIgnored = !0)) : i.status.fetchResolved = !0), l && !w && !b) return y(r.signal.reason, F);
-			let m = c, p = this.#t[t];
-			return (p === c || p === void 0 && w && b) && (f === void 0 ? m.__staleWhileFetching !== void 0 ? this.#t[t] = m.__staleWhileFetching : this.#E(e, "fetch") : (i.status && (i.status.fetchUpdated = !0), this.#W(e, f, a.options, m))), f;
-		}, d = (f) => (i.status && (i.status.fetchRejected = !0, i.status.fetchError = f), y(f, !1)), y = (f, b) => {
-			let { aborted: l } = r.signal, w = l && i.allowStaleOnFetchAbort, F = w || i.allowStaleOnFetchRejection, m = F || i.noDeleteOnFetchRejection, p = c;
-			if (this.#t[t] === c && (!m || !b && p.__staleWhileFetching === void 0 ? this.#E(e, "fetch") : w || (this.#t[t] = p.__staleWhileFetching)), F) return i.status && p.__staleWhileFetching !== void 0 && (i.status.returnedStale = !0), p.__staleWhileFetching;
+		}, r = (f, y = !1) => {
+			let { aborted: a } = o.signal, w = i.ignoreFetchAbort && f !== void 0, F = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && f !== void 0);
+			if (i.status && (a && !y ? (i.status.fetchAborted = !0, i.status.fetchError = o.signal.reason, w && (i.status.fetchAbortIgnored = !0)) : i.status.fetchResolved = !0), a && !w && !y) return m(o.signal.reason, F);
+			let b = u, p = this.#t[t];
+			return (p === u || p === void 0 && w && y) && (f === void 0 ? b.__staleWhileFetching !== void 0 ? this.#t[t] = b.__staleWhileFetching : this.#E(e, "fetch") : (i.status && (i.status.fetchUpdated = !0), this.#W(e, f, h.options, b))), f;
+		}, c = (f) => (i.status && (i.status.fetchRejected = !0, i.status.fetchError = f), m(f, !1)), m = (f, y) => {
+			let { aborted: a } = o.signal, w = a && i.allowStaleOnFetchAbort, F = w || i.allowStaleOnFetchRejection, b = F || i.noDeleteOnFetchRejection, p = u;
+			if (this.#t[t] === u && (!b || !y && p.__staleWhileFetching === void 0 ? this.#E(e, "fetch") : w || (this.#t[t] = p.__staleWhileFetching)), F) return i.status && p.__staleWhileFetching !== void 0 && (i.status.returnedStale = !0), p.__staleWhileFetching;
 			if (p.__returned === p) throw f;
-		}, _ = (f, b) => {
-			let l = this.#M?.(e, n, a);
-			r.signal.addEventListener("abort", () => {
-				(!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (f(void 0), i.allowStaleOnFetchAbort && (f = (w) => o(w, !0)));
-			}), l && l instanceof Promise ? l.then((w) => f(w === void 0 ? void 0 : w), b) : l !== void 0 && f(l);
+		}, _ = (f, y) => {
+			let a = this.#M?.(e, n, h);
+			o.signal.addEventListener("abort", () => {
+				(!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (f(void 0), i.allowStaleOnFetchAbort && (f = (w) => r(w, !0)));
+			}), a && a instanceof Promise ? a.then((w) => f(w === void 0 ? void 0 : w), y) : a !== void 0 && f(a);
 		};
 		i.status && (i.status.fetchDispatched = !0);
-		let c = new Promise(_).then(o, d), g = Object.assign(c, {
-			__abortController: r,
+		let u = new Promise(_).then(r, c), g = Object.assign(u, {
+			__abortController: o,
 			__staleWhileFetching: n,
 			__returned: void 0
 		});
 		return t === void 0 ? (this.#W(e, g, {
-			...a.options,
+			...h.options,
 			status: void 0
 		}), t = this.#s.get(e)) : this.#t[t] = g, g;
 	}
@@ -10136,53 +10577,53 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 		return !!t && t instanceof Promise && t.hasOwnProperty("__staleWhileFetching") && t.__abortController instanceof AbortController;
 	}
 	fetch(e, t = {}) {
-		let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t;
+		let i = W.hasSubscribers, { status: s = R() ? {} : void 0 } = t;
 		t.status = s, s && t.context && (s.context = t.context);
 		let n = this.#B(e, t);
 		return s && i && (s.trace = !0, W.tracePromise(() => n, s).catch(() => {})), n;
 	}
 	async #B(e, t = {}) {
-		let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: r = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: a = 0, sizeCalculation: o = this.sizeCalculation, noUpdateTTL: d = this.noUpdateTTL, noDeleteOnFetchRejection: y = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: _ = this.allowStaleOnFetchRejection, ignoreFetchAbort: c = this.ignoreFetchAbort, allowStaleOnFetchAbort: g = this.allowStaleOnFetchAbort, context: f, forceRefresh: b = !1, status: l, signal: w } = t;
-		if (l && (l.op = "fetch", l.key = e, b && (l.forceRefresh = !0), l.cache = this), !this.#U) return l && (l.fetch = "get"), this.#C(e, {
+		let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: l = this.noDisposeOnSet, size: h = 0, sizeCalculation: r = this.sizeCalculation, noUpdateTTL: c = this.noUpdateTTL, noDeleteOnFetchRejection: m = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: _ = this.allowStaleOnFetchRejection, ignoreFetchAbort: u = this.ignoreFetchAbort, allowStaleOnFetchAbort: g = this.allowStaleOnFetchAbort, context: f, forceRefresh: y = !1, status: a, signal: w } = t;
+		if (a && (a.op = "fetch", a.key = e, y && (a.forceRefresh = !0), a.cache = this), !this.#U) return a && (a.fetch = "get"), this.#C(e, {
 			allowStale: i,
 			updateAgeOnGet: s,
 			noDeleteOnStaleGet: n,
-			status: l
+			status: a
 		});
 		let F = {
 			allowStale: i,
 			updateAgeOnGet: s,
 			noDeleteOnStaleGet: n,
-			ttl: r,
-			noDisposeOnSet: h,
-			size: a,
-			sizeCalculation: o,
-			noUpdateTTL: d,
-			noDeleteOnFetchRejection: y,
+			ttl: o,
+			noDisposeOnSet: l,
+			size: h,
+			sizeCalculation: r,
+			noUpdateTTL: c,
+			noDeleteOnFetchRejection: m,
 			allowStaleOnFetchRejection: _,
 			allowStaleOnFetchAbort: g,
-			ignoreFetchAbort: c,
-			status: l,
+			ignoreFetchAbort: u,
+			status: a,
 			signal: w
-		}, m = this.#s.get(e);
-		if (m === void 0) {
-			l && (l.fetch = "miss");
-			let p = this.#P(e, m, F, f);
+		}, b = this.#s.get(e);
+		if (b === void 0) {
+			a && (a.fetch = "miss");
+			let p = this.#P(e, b, F, f);
 			return p.__returned = p;
 		} else {
-			let p = this.#t[m];
+			let p = this.#t[b];
 			if (this.#e(p)) {
 				let v = i && p.__staleWhileFetching !== void 0;
-				return l && (l.fetch = "inflight", v && (l.returnedStale = !0)), v ? p.__staleWhileFetching : p.__returned = p;
+				return a && (a.fetch = "inflight", v && (a.returnedStale = !0)), v ? p.__staleWhileFetching : p.__returned = p;
 			}
-			let A = this.#p(m);
-			if (!b && !A) return l && (l.fetch = "hit"), this.#L(m), s && this.#D(m), l && this.#v(l, m), p;
-			let z = this.#P(e, m, F, f), E = z.__staleWhileFetching !== void 0 && i;
-			return l && (l.fetch = A ? "stale" : "refresh", E && A && (l.returnedStale = !0)), E ? z.__staleWhileFetching : z.__returned = z;
+			let A = this.#p(b);
+			if (!y && !A) return a && (a.fetch = "hit"), this.#L(b), s && this.#R(b), a && this.#v(a, b), p;
+			let z = this.#P(e, b, F, f), E = z.__staleWhileFetching !== void 0 && i;
+			return a && (a.fetch = A ? "stale" : "refresh", E && A && (a.returnedStale = !0)), E ? z.__staleWhileFetching : z.__returned = z;
 		}
 	}
 	forceFetch(e, t = {}) {
-		let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t;
+		let i = W.hasSubscribers, { status: s = R() ? {} : void 0 } = t;
 		t.status = s, s && t.context && (s.context = t.context);
 		let n = this.#K(e, t);
 		return s && i && (s.trace = !0, W.tracePromise(() => n, s).catch(() => {})), n;
@@ -10201,15 +10642,15 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 	#Q(e, t = {}) {
 		let i = this.#I;
 		if (!i) throw new Error("no memoMethod provided to constructor");
-		let { context: s, status: n, forceRefresh: r, ...h } = t;
-		n && r && (n.forceRefresh = !0);
-		let a = this.#C(e, h), o = r || a === void 0;
-		if (n && (n.memo = o ? "miss" : "hit", o || (n.value = a)), !o) return a;
-		let d = i(e, a, {
-			options: h,
+		let { context: s, status: n, forceRefresh: o, ...l } = t;
+		n && o && (n.forceRefresh = !0);
+		let h = this.#C(e, l), r = o || h === void 0;
+		if (n && (n.memo = r ? "miss" : "hit", r || (n.value = h)), !r) return h;
+		let c = i(e, h, {
+			options: l,
 			context: s
 		});
-		return n && (n.value = d), this.#W(e, d, h), d;
+		return n && (n.value = c), this.#W(e, c, l), c;
 	}
 	get(e, t = {}) {
 		let { status: i = S.hasSubscribers ? {} : void 0 } = t;
@@ -10218,13 +10659,13 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 		return i && (s !== void 0 && (i.value = s), S.hasSubscribers && S.publish(i)), s;
 	}
 	#C(e, t = {}) {
-		let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: r } = t, h = this.#s.get(e);
-		if (h === void 0) {
-			r && (r.get = "miss");
+		let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = t, l = this.#s.get(e);
+		if (l === void 0) {
+			o && (o.get = "miss");
 			return;
 		}
-		let a = this.#t[h], o = this.#e(a);
-		return r && this.#v(r, h), this.#p(h) ? o ? (r && (r.get = "stale-fetching"), i && a.__staleWhileFetching !== void 0 ? (r && (r.returnedStale = !0), a.__staleWhileFetching) : void 0) : (n || this.#E(e, "expire"), r && (r.get = "stale"), i ? (r && (r.returnedStale = !0), a) : void 0) : (r && (r.get = o ? "fetching" : "hit"), this.#L(h), s && this.#D(h), o ? a.__staleWhileFetching : a);
+		let h = this.#t[l], r = this.#e(h);
+		return o && this.#v(o, l), this.#p(l) ? r ? (o && (o.get = "stale-fetching"), i && h.__staleWhileFetching !== void 0 ? (o && (o.returnedStale = !0), h.__staleWhileFetching) : void 0) : (n || this.#E(e, "expire"), o && (o.get = "stale"), i ? (o && (o.returnedStale = !0), h) : void 0) : (o && (o.get = r ? "fetching" : "hit"), this.#L(l), s && this.#R(l), r ? h.__staleWhileFetching : h);
 	}
 	#$(e, t) {
 		this.#u[t] = e, this.#l[e] = t;
@@ -10245,9 +10686,9 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 		let i = !1;
 		if (this.#n !== 0) {
 			let s = this.#s.get(e);
-			if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i = !0, this.#n === 1) this.#q(t);
+			if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g[s]), this.#g[s] = void 0), i = !0, this.#n === 1) this.#q(t);
 			else {
-				this.#R(s);
+				this.#x(s);
 				let n = this.#t[s];
 				if (this.#e(n) ? n.__abortController.abort(/* @__PURE__ */ new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#S?.(n, e, t), this.#f && this.#r?.push([
 					n,
@@ -10256,10 +10697,10 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 				])), this.#s.delete(e), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#u[s];
 				else if (s === this.#a) this.#a = this.#l[s];
 				else {
-					let r = this.#u[s];
-					this.#l[r] = this.#l[s];
-					let h = this.#l[s];
-					this.#u[h] = this.#u[s];
+					let o = this.#u[s];
+					this.#l[o] = this.#l[s];
+					let l = this.#l[s];
+					this.#u[l] = this.#u[s];
 				}
 				this.#n--, this.#y.push(s);
 			}
@@ -10298,7 +10739,7 @@ var T = (u) => !!u && u === Math.floor(u) && u > 0 && isFinite(u), G = (u) => T(
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/column_providers/providers.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/column_providers/providers.js
 /**
 * Unified memoised factory dispatching to the right provider flavour by the
 * source shape:
@@ -10387,7 +10828,7 @@ function hashRawPool(rawPool) {
 	return rawPool.map((b) => `${b.blockId}\x1f${b.prodCtx ?? ""}\x1f${b.stagingCtx ?? ""}\x1f${b.prodIncomplete ? 1 : 0}\x1f${b.stagingIncomplete ? 1 : 0}`).join("");
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/column_providers/index.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/column_providers/index.js
 /**
 * Build the default set of ColumnsProviders for the ambient render ctx:
 *  - `AccessorColumnsProvider` over `outputs` (if present)
@@ -10422,7 +10863,7 @@ function isColumnProvider(source) {
 	return typeof p.getColumns === "function" && typeof p.isFinal === "function";
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/data_column.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/data_column.js
 /**
 * Thrown by leaf-recipe factories when the requested column is provably
 * absent in the active render ctx — i.e. every relevant accessor reports
@@ -10662,7 +11103,7 @@ function memoizeByEntry(fn) {
 	};
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_overrided_recipe.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_overrided_recipe.js
 /**
 * Recipe wrapper that overlays {@link SpecOverrides} on top of any other
 * recipe. The id is `ColumnOverriddenKey { source: inner.id, specOverrides }`.
@@ -10800,7 +11241,7 @@ var DataColumnOverriddenRecipe = class extends ColumnOverriddenRecipe {
 	}
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_filtered_recipe.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_filtered_recipe.js
 /**
 * Recipe wrapper that fixes the values of selected axes of an inner recipe
 * (axis slicing). The id is `FilteredPColumnId { source: inner.id,
@@ -10926,7 +11367,7 @@ function toAxisSelector(axis) {
 	return selector;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/index.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/index.js
 /**
 * Build a `ColumnRecipe` from a stringified id. Dispatches to the matching
 * concrete recipe variant based on the id's encoding and recurses on
@@ -10977,7 +11418,7 @@ function ColumnRecipeGetStatus(id, opts = {}) {
 }
 const ColumnRecipe = Object.assign(ColumnRecipeBuild, { getStatus: ColumnRecipeGetStatus });
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_discovered_recipe.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/column_recipes/column_discovered_recipe.js
 /**
 * Recipe for columns identified by a {@link ColumnDiscoveredKey}: a base
 * column + a `path` of linkers + qualifications.
@@ -11148,7 +11589,7 @@ function referencedUniIdsOf(key) {
 	return /* @__PURE__ */ new Set([key.column, ...(key.path ?? []).map((item) => item.column)]);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/column.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/column.js
 /**
 * Unified entry point — routes between the two top-level dispatchers:
 *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}
@@ -11162,7 +11603,7 @@ function Column(source, opts) {
 	return DataColumn(source, opts);
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/columns/columns_collection.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/columns_collection.js
 /**
 * Build a {@link ColumnsCollection} from sandbox-side source descriptors.
 * Resolves the `columnsCollection` driver (either from `deps.driver` or via
@@ -11271,7 +11712,138 @@ function defaultCtxSources(ctx) {
 	return [...currentBlockSources(ctx), { kind: "result_pool" }];
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/pframe_utils/columns.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/columns/utils.js
+/**
+* PObjectIds of every non-hit column referenced by `recipe.getQuery()`,
+* deduped in traversal order. The hit column is
+* `extractPObjectId(recipe.id)`; anything else in the query is a linker or
+* other engine-consumed column.
+*
+* Pure query walk — no registry access. Use {@link collectLinkerColumns} for
+* the resolved {@link DataColumnRecipe} variant.
+*/
+function collectLinkerIds(recipe) {
+	const hit = extractPObjectId(recipe.id);
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const id of collectSpecQueryColumns(recipe.getQuery())) {
+		const bare = extractPObjectId(id);
+		if (bare === hit) continue;
+		if (seen.has(bare)) continue;
+		seen.add(bare);
+		out.push(bare);
+	}
+	return out;
+}
+/**
+* {@link collectLinkerIds} resolved against the ambient context as
+* {@link DataColumnRecipe} leaves. Throws if any id fails to resolve —
+* matches the contract of the legacy `resolveLinkers` it replaces.
+*/
+function collectLinkerColumns(recipe, opts = {}) {
+	return collectLinkerIds(recipe).map((id) => DataColumnImpl.fromId(id, opts) ?? throwError(`materializeLinkers: linker ${id} not resolvable`));
+}
+/**
+* Hit-side axis qualifications for the recipe — the ones that should land on
+* the outer-join entry wrapping this column at the consumer boundary.
+*
+* Descends {@link ColumnOverriddenRecipe} / {@link ColumnFilteredRecipe} via
+* `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise
+* returns `[]`. Pure recipe walk — no query-tree introspection.
+*/
+function hitQualifications(recipe) {
+	return findDiscovered(recipe)?.getColumnQualifications() ?? [];
+}
+/**
+* Per-primary-column axis qualifications for the recipe — applied to the
+* outer primary anchors on this recipe's group side. Keyed by the external
+* primary column id (NOT by columns inside this recipe's own query).
+*
+* Same walk strategy as {@link hitQualifications}.
+*/
+function queriesQualifications(recipe) {
+	return findDiscovered(recipe)?.getQueriesQualifications() ?? {};
+}
+/**
+* Whether the recipe's underlying data resources actually carry bytes —
+* strictly stronger than `getDataStatus() === "present"`, which only tells
+* that the `.data` field is wired onto the accessor.
+*
+* Walks every physical leaf the recipe depends on via
+* {@link ColumnRecipe.getReferencedIds} (resolves each id back to a
+* {@link DataColumnRecipe} through the ambient ctx) and ANDs `hasData()` across
+* all of them. Inline {@link PColumnValues} payloads count as present.
+*
+* Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as
+* "not yet ready") rather than throwing — this is a UI-facing predicate, not
+* a contract assertion.
+*/
+function hasColumnData(recipe, opts = {}) {
+	for (const id of recipe.getReferencedIds()) {
+		const leaf = DataColumnImpl.fromId(id, opts);
+		if (leaf === void 0) return false;
+		if (leaf.getDataStatus() !== "present") return false;
+		if (!isLeafDataPresent(leaf.getData())) return false;
+	}
+	return true;
+}
+function isLeafDataPresent(data) {
+	if (data === void 0) return false;
+	if (Array.isArray(data)) return true;
+	if (data instanceof TreeNodeAccessor) return data.hasData();
+	if (isDataInfo(data)) {
+		let ok = true;
+		visitDataInfo(data, (blob) => {
+			ok &&= blob.hasData();
+		});
+		return ok;
+	}
+	return false;
+}
+/**
+* Walk wrapper layers (Overridden, Filtered) until a {@link
+* ColumnDiscoveredRecipe} is found. Returns `undefined` if the recipe chain
+* has no Discovered layer (bare leaves and Overridden-over-leaf cases).
+*
+* Invariant from the wrapper classes themselves: there is at most one
+* Discovered layer in any recipe chain — Discovered is constructed only via
+* its own factory and is never re-wrapped by Discovered.
+*/
+function findDiscovered(recipe) {
+	let current = recipe;
+	while (true) {
+		if (current instanceof ColumnDiscoveredRecipe) return current;
+		if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {
+			current = current.getInner();
+			continue;
+		}
+		return;
+	}
+}
+/**
+* Whether the recipe reads exactly one data column — its own — rather than
+* reaching through others.
+*
+* True for a bare leaf and for projections over one (spec overrides, axis
+* slicing): those add layers but no new columns. False when the recipe gets at
+* its data through further columns, which happens when discovery reached it via
+* a linker chain.
+*
+* **Why callers care.** A recipe over a single data column is co-indexed by its
+* own axes, so its spec is the whole truth about them. One that needs other
+* columns only lines up after they are joined in, and therefore drags axes into
+* the join that its own spec never mentions — which is why it cannot serve as a
+* primary column, and why `createPlDataTableV3` splits on this.
+*
+* The count comes from {@link ColumnRecipe.getReferencedIds}, which resolves
+* through the whole wrapper chain, so no class walk is involved and foreign
+* `ColumnRecipe` implementations are handled too.
+*/
+function hasSingleDataColumn(recipe) {
+	return recipe.getReferencedIds().length === 1;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/pframe_utils/columns.js
 function getAllRelatedColumns(ctx, predicate) {
 	const columns = new PColumnCollection();
 	columns.addColumnProvider(ctx.resultPool);
@@ -11347,7 +11919,7 @@ function discoverIntegrableColumnIds(ctx, rootColumns) {
 	}
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/components/PFrameForGraphs.js
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/components/PFrameForGraphs.js
 function isHiddenFromGraphColumn(column) {
 	return !!readAnnotationJson(column, Annotation.HideDataFromGraphs);
 }
@@ -11375,47 +11947,1478 @@ function createPFrameForGraphs(ctx, blockColumns) {
 		predicate: suitableSpec
 	}));
 }
-(/* @__PURE__ */ __commonJSMin(((exports, module) => {
-	exports = module.exports = stringify;
-	exports.getSerialize = serializer;
-	function stringify(obj, replacer, spaces, cycleReplacer) {
-		return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
-	}
-	function serializer(replacer, cycleReplacer) {
-		var stack = [], keys = [];
-		if (cycleReplacer == null) cycleReplacer = function(key, value) {
-			if (stack[0] === value) return "[Circular ~]";
-			return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-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 ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/filters/converters/filterToQuery.js
+/** Converts a QueryColumnId object into a SpecQueryExpression reference. */
+function resolveColumnRef(col) {
+	return col.type === "axis" ? {
+		type: "axisRef",
+		value: 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) {
+	switch (filter.type) {
+		case "patternEquals": return {
+			type: "stringEquals",
+			input: resolveColumnRef(filter.column),
+			value: filter.value,
+			caseInsensitive: false
 		};
-		return function(key, value) {
-			if (stack.length > 0) {
-				var thisPos = stack.indexOf(this);
-				~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
-				~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
-				if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value);
-			} else stack.push(value);
-			return replacer == null ? value : replacer.call(this, key, value);
+		case "patternNotEquals": return {
+			type: "not",
+			input: {
+				type: "stringEquals",
+				input: resolveColumnRef(filter.column),
+				value: filter.value,
+				caseInsensitive: false
+			}
 		};
-	}
-})))();
-const PlErrorLike = objectType({
-	type: literalType("PlError"),
-	name: stringType(),
-	message: stringType(),
-	fullMessage: stringType().optional(),
-	stack: stringType().optional()
-}).extend({
-	cause: lazyType(() => ErrorLike).optional(),
-	errors: lazyType(() => ErrorLike.array()).optional()
-});
-const ErrorLike = unionType([objectType({
-	type: literalType("StandardError"),
-	name: stringType(),
-	message: stringType(),
-	stack: stringType().optional()
-}).extend({
-	cause: lazyType(() => ErrorLike).optional(),
-	errors: lazyType(() => ErrorLike.array()).optional()
+		case "patternContainSubsequence": return {
+			type: "stringContains",
+			input: resolveColumnRef(filter.column),
+			value: filter.value,
+			caseInsensitive: false
+		};
+		case "patternNotContainSubsequence": return {
+			type: "not",
+			input: {
+				type: "stringContains",
+				input: resolveColumnRef(filter.column),
+				value: filter.value,
+				caseInsensitive: false
+			}
+		};
+		case "patternMatchesRegularExpression": return {
+			type: "stringRegex",
+			input: resolveColumnRef(filter.column),
+			value: filter.value
+		};
+		case "patternFuzzyContainSubsequence": return {
+			type: "stringContainsFuzzy",
+			input: resolveColumnRef(filter.column),
+			value: filter.value,
+			maxEdits: filter.maxEdits ?? 1,
+			caseInsensitive: false,
+			substitutionsOnly: filter.substitutionsOnly ?? false,
+			wildcard: filter.wildcard ?? null
+		};
+		case "equal": return {
+			type: "numericComparison",
+			operand: "eq",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "notEqual": return {
+			type: "numericComparison",
+			operand: "ne",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "lessThan": return {
+			type: "numericComparison",
+			operand: "lt",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "greaterThan": return {
+			type: "numericComparison",
+			operand: "gt",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "lessThanOrEqual": return {
+			type: "numericComparison",
+			operand: "le",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "greaterThanOrEqual": return {
+			type: "numericComparison",
+			operand: "ge",
+			left: resolveColumnRef(filter.column),
+			right: {
+				type: "constant",
+				value: filter.x
+			}
+		};
+		case "equalToColumn": return {
+			type: "numericComparison",
+			operand: "eq",
+			left: resolveColumnRef(filter.column),
+			right: resolveColumnRef(filter.rhs)
+		};
+		case "lessThanColumn": {
+			const left = resolveColumnRef(filter.column);
+			const right = resolveColumnRef(filter.rhs);
+			if (filter.minDiff !== void 0 && filter.minDiff !== 0) return {
+				type: "numericComparison",
+				operand: "lt",
+				left: {
+					type: "numericBinary",
+					operand: "add",
+					left,
+					right: {
+						type: "constant",
+						value: filter.minDiff
+					}
+				},
+				right
+			};
+			return {
+				type: "numericComparison",
+				operand: "lt",
+				left,
+				right
+			};
+		}
+		case "greaterThanColumn": {
+			const left = resolveColumnRef(filter.column);
+			const right = resolveColumnRef(filter.rhs);
+			if (filter.minDiff !== void 0 && filter.minDiff !== 0) return {
+				type: "numericComparison",
+				operand: "gt",
+				left: {
+					type: "numericBinary",
+					operand: "add",
+					left,
+					right: {
+						type: "constant",
+						value: filter.minDiff
+					}
+				},
+				right
+			};
+			return {
+				type: "numericComparison",
+				operand: "gt",
+				left,
+				right
+			};
+		}
+		case "lessThanColumnOrEqual": {
+			const left = resolveColumnRef(filter.column);
+			const right = resolveColumnRef(filter.rhs);
+			if (filter.minDiff !== void 0 && filter.minDiff !== 0) return {
+				type: "numericComparison",
+				operand: "le",
+				left: {
+					type: "numericBinary",
+					operand: "add",
+					left,
+					right: {
+						type: "constant",
+						value: filter.minDiff
+					}
+				},
+				right
+			};
+			return {
+				type: "numericComparison",
+				operand: "le",
+				left,
+				right
+			};
+		}
+		case "greaterThanColumnOrEqual": {
+			const left = resolveColumnRef(filter.column);
+			const right = resolveColumnRef(filter.rhs);
+			if (filter.minDiff !== void 0 && filter.minDiff !== 0) return {
+				type: "numericComparison",
+				operand: "ge",
+				left: {
+					type: "numericBinary",
+					operand: "add",
+					left,
+					right: {
+						type: "constant",
+						value: filter.minDiff
+					}
+				},
+				right
+			};
+			return {
+				type: "numericComparison",
+				operand: "ge",
+				left,
+				right
+			};
+		}
+		case "inSet": return {
+			type: "isIn",
+			input: resolveColumnRef(filter.column),
+			set: filter.value,
+			negate: false
+		};
+		case "notInSet": return {
+			type: "isIn",
+			input: resolveColumnRef(filter.column),
+			set: filter.value,
+			negate: true
+		};
+		case "isNA": return {
+			type: "isNull",
+			input: resolveColumnRef(filter.column)
+		};
+		case "isNotNA": return {
+			type: "not",
+			input: {
+				type: "isNull",
+				input: resolveColumnRef(filter.column)
+			}
+		};
+		case "ifNa": return {
+			type: "fillNull",
+			input: resolveColumnRef(filter.column),
+			replacement: {
+				type: "constant",
+				value: filter.replacement
+			}
+		};
+		case "topN":
+		case "bottomN": throw new Error(`Filter type "${filter.type}" is not supported in query expressions`);
+		case void 0: throw new Error("Filter type is undefined");
+		default: assertNever(filter);
+	}
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.mjs
+/**
+* Checks if `value` is array-like.
+*
+* @param value The value to check.
+* @returns Returns `true` if `value` is array-like, else `false`.
+*
+* @example
+* isArrayLike([1, 2, 3]); // true
+* isArrayLike('abc'); // true
+* isArrayLike({ 0: 'a', length: 1 }); // true
+* isArrayLike({}); // false
+* isArrayLike(null); // false
+* isArrayLike(undefined); // false
+*/
+function isArrayLike(value) {
+	return value != null && typeof value !== "function" && isLength(value.length);
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/compat/predicate/isArguments.mjs
+/**
+* Checks if the given value is an arguments object.
+*
+* This function tests whether the provided value is an arguments object or not.
+* It returns `true` if the value is an arguments object, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an arguments object.
+*
+* @param value - The value to test if it is an arguments object.
+* @returns `true` if the value is an arguments, `false` otherwise.
+*
+* @example
+* const args = (function() { return arguments; })();
+* const strictArgs = (function() { 'use strict'; return arguments; })();
+* const value = [1, 2, 3];
+*
+* console.log(isArguments(args)); // true
+* console.log(isArguments(strictArgs)); // true
+* console.log(isArguments(value)); // false
+*/
+function isArguments(value) {
+	return value !== null && typeof value === "object" && getTag(value) === "[object Arguments]";
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.mjs
+/**
+* Checks if a value is a TypedArray.
+* @param x The value to check.
+* @returns Returns true if `x` is a TypedArray, false otherwise.
+*
+* @example
+* const arr = new Uint8Array([1, 2, 3]);
+* isTypedArray(arr); // true
+*
+* const regularArray = [1, 2, 3];
+* isTypedArray(regularArray); // false
+*
+* const buffer = new ArrayBuffer(16);
+* isTypedArray(buffer); // false
+*/
+function isTypedArray(x) {
+	return isTypedArray$1(x);
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/compat/_internal/isPrototype.mjs
+function isPrototype(value) {
+	const constructor = value?.constructor;
+	return value === (typeof constructor === "function" ? constructor.prototype : Object.prototype);
+}
+//#endregion
+//#region ../node_modules/.pnpm/es-toolkit@1.52.0/node_modules/es-toolkit/dist/compat/predicate/isEmpty.mjs
+/**
+* Checks if a given value is empty.
+*
+* - If the given value is a string, checks if it is an empty string.
+* - If the given value is an array, `Map`, or `Set`, checks if its size is 0.
+* - If the given value is an [array-like object](../predicate/isArrayLike.md), checks if its length is 0.
+* - If the given value is an object, checks if it is an empty object with no properties.
+* - Primitive values (booleans, numbers, or bigints) are considered empty.
+*
+* @param [value] - The value to check.
+* @returns `true` if the value is empty, `false` otherwise.
+*
+* @example
+* isEmpty(); // true
+* isEmpty(null); // true
+* isEmpty(""); // true
+* isEmpty([]); // true
+* isEmpty({}); // true
+* isEmpty(new Map()); // true
+* isEmpty(new Set()); // true
+* isEmpty("hello"); // false
+* isEmpty([1, 2, 3]); // false
+* isEmpty({ a: 1 }); // false
+* isEmpty(new Map([["key", "value"]])); // false
+* isEmpty(new Set([1, 2, 3])); // false
+*/
+function isEmpty(value) {
+	if (value == null) return true;
+	if (isArrayLike(value)) {
+		if (typeof value.splice !== "function" && typeof value !== "string" && !isBuffer(value) && !isTypedArray(value) && !isArguments(value)) return false;
+		return value.length === 0;
+	}
+	if (typeof value === "object" || typeof value === "function") {
+		if (value instanceof Map || value instanceof Set) return value.size === 0;
+		const keys = Object.keys(value);
+		if (isPrototype(value)) return keys.filter((x) => x !== "constructor").length === 0;
+		return keys.length === 0;
+	}
+	return true;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/filters/distill.js
+/**
+* Strips non-FilterSpec metadata (whitelist approach) and removes
+* unfilled leaves (type is undefined or any required field is undefined).
+*/
+function distillFilterSpec(filter) {
+	if (filter == null) return null;
+	return traverseFilterSpec(filter, {
+		leaf: (leaf) => {
+			const distilled = distillLeaf(leaf);
+			return isFilledLeaf(distilled) ? distilled : null;
+		},
+		and: (results) => {
+			const filtered = results.filter((f) => f !== null);
+			return filtered.length === 0 ? null : {
+				type: "and",
+				filters: filtered
+			};
+		},
+		or: (results) => {
+			const filtered = results.filter((f) => f !== null);
+			return filtered.length === 0 ? null : {
+				type: "or",
+				filters: filtered
+			};
+		},
+		not: (result) => result === null ? null : {
+			type: "not",
+			filter: result
+		}
+	});
+}
+function distillLeaf(node) {
+	const result = {};
+	for (const [key, value] of Object.entries(node)) if (KNOWN_LEAF_KEYS.has(key)) result[key] = value;
+	return result;
+}
+/** Returns true if the leaf is filled — type is defined and every required field per-type is filled. */
+function isFilledLeaf(node) {
+	if (isNil$1(node.type)) return false;
+	const required = REQUIRED_KEYS_BY_TYPE[node.type];
+	const record = node;
+	return required.every((key) => isFilledValue(record[key]));
+}
+/**
+* Returns true if the value is considered "filled":
+* - primitives (number, boolean): always true
+* - string: non-empty after trim
+* - array: non-empty AND every item is filled
+* - plain object: non-empty AND every field value is filled
+* - null/undefined: false
+*/
+function isFilledValue(value) {
+	if (isNil$1(value)) return false;
+	switch (typeof value) {
+		case "number":
+		case "boolean": return true;
+		case "string": return value.trim() !== "";
+		default:
+			if (isEmpty(value)) return false;
+			if (Array.isArray(value)) return value.every(isFilledValue);
+			return Object.values(value).every(isFilledValue);
+	}
+}
+const KNOWN_LEAF_KEYS = /* @__PURE__ */ new Set([
+	"n",
+	"x",
+	"rhs",
+	"type",
+	"value",
+	"column",
+	"minDiff",
+	"maxEdits",
+	"wildcard",
+	"replacement",
+	"substitutionsOnly"
+]);
+/** Required fields per leaf type. Optional fields (e.g. minDiff, maxEdits) excluded. */
+const REQUIRED_KEYS_BY_TYPE = {
+	isNA: ["column"],
+	isNotNA: ["column"],
+	ifNa: ["column", "replacement"],
+	patternEquals: ["column", "value"],
+	patternNotEquals: ["column", "value"],
+	patternContainSubsequence: ["column", "value"],
+	patternNotContainSubsequence: ["column", "value"],
+	patternMatchesRegularExpression: ["column", "value"],
+	patternFuzzyContainSubsequence: ["column", "value"],
+	inSet: ["column", "value"],
+	notInSet: ["column", "value"],
+	topN: ["column", "n"],
+	bottomN: ["column", "n"],
+	equal: ["column", "x"],
+	notEqual: ["column", "x"],
+	lessThan: ["column", "x"],
+	greaterThan: ["column", "x"],
+	lessThanOrEqual: ["column", "x"],
+	greaterThanOrEqual: ["column", "x"],
+	equalToColumn: ["column", "rhs"],
+	lessThanColumn: ["column", "rhs"],
+	greaterThanColumn: ["column", "rhs"],
+	lessThanColumnOrEqual: ["column", "rhs"],
+	greaterThanColumnOrEqual: ["column", "rhs"]
+};
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/state-migration.js
+/** Upgrade PlDataTableStateV2 to the latest version */
+function upgradePlDataTableStateV2(state) {
+	if (!state) return createPlDataTableStateV2();
+	if (!("version" in state)) state = createPlDataTableStateV2();
+	if (state.version === 2) state = {
+		version: 3,
+		stateCache: state.stateCache.map((entry) => ({
+			...entry,
+			filtersState: []
+		})),
+		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. */
+function migrateV5toV6(state) {
+	return {
+		version: 6,
+		stateCache: state.stateCache.map((entry) => ({
+			...entry,
+			gridState: unwrapV5GridState(entry.gridState)
+		})),
+		pTableParams: createDefaultPTableParamsV7()
+	};
+}
+/** Convert v5 wrapped colId JSON to bare PTableColumnSpec JSON, taking `.source`.
+* gridState colIds may include the row-number sentinel (a JSON-stringified
+* literal, not a wrapped spec) — those pass through unchanged. */
+function unwrapV5ColId(json) {
+	const parsed = parseJsonSafely(json);
+	return !isNil(parsed) && typeof parsed === "object" && "source" in parsed ? canonicalizeJson(parsed.source) : json;
+}
+function unwrapV5GridState(gridState) {
+	const unwrapAs = (json) => unwrapV5ColId(json);
+	return {
+		columnOrder: gridState.columnOrder ? { orderedColIds: gridState.columnOrder.orderedColIds.map(unwrapAs) } : void 0,
+		sort: gridState.sort ? { sortModel: gridState.sort.sortModel.map((s) => ({
+			colId: unwrapAs(s.colId),
+			sort: s.sort
+		})) } : void 0,
+		columnVisibility: gridState.columnVisibility ? { hiddenColIds: gridState.columnVisibility.hiddenColIds.map(unwrapAs) } : void 0
+	};
+}
+/** Migrate v6 to v7: rewrite each colId from a full PTableColumnSpec to its
+* compact PTableColumnId (drops annotations/spec body, ~16× smaller per column). */
+function migrateV6toV7(state) {
+	return {
+		version: 7,
+		stateCache: state.stateCache.map((entry) => ({
+			...entry,
+			gridState: shrinkV6GridState(entry.gridState)
+		})),
+		pTableParams: state.pTableParams
+	};
+}
+/** Convert a v6 fat colId (canonicalized PTableColumnSpec) to a v7 compact colId
+* (canonicalized PTableColumnId). The row-number sentinel is a string literal,
+* not a spec — pass it through unchanged. */
+function shrinkV6ColId(json) {
+	const parsed = parseJsonSafely(json);
+	if (!isNil(parsed) && typeof parsed === "object" && "type" in parsed && "id" in parsed) return canonicalizeJson(getPTableColumnId(parsed));
+	return json;
+}
+function shrinkV6GridState(gridState) {
+	return {
+		columnOrder: gridState.columnOrder ? { orderedColIds: gridState.columnOrder.orderedColIds.map(shrinkV6ColId) } : void 0,
+		sort: gridState.sort ? { sortModel: gridState.sort.sortModel.map((s) => ({
+			colId: shrinkV6ColId(s.colId),
+			sort: s.sort
+		})) } : void 0,
+		columnVisibility: gridState.columnVisibility ? { hiddenColIds: gridState.columnVisibility.hiddenColIds.map(shrinkV6ColId) } : void 0
+	};
+}
+/** Migrate v4 state to v6: convert per-column filters to tree-based format (skips v5). */
+function migrateV4toV6(state) {
+	let idCounter = 0;
+	const nextId = () => ++idCounter;
+	const migratedCache = state.stateCache.map((entry) => {
+		const leaves = [];
+		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",
+			filters: leaves
+		} : null;
+		return {
+			sourceId: entry.sourceId,
+			gridState: entry.gridState,
+			sheetsState: entry.sheetsState,
+			filtersState,
+			defaultFiltersState: null
+		};
+	});
+	const oldSourceId = state.pTableParams.sourceId;
+	const currentCache = oldSourceId ? migratedCache.find((e) => e.sourceId === oldSourceId) : void 0;
+	return {
+		version: 6,
+		stateCache: migratedCache,
+		pTableParams: currentCache && oldSourceId ? {
+			sourceId: oldSourceId,
+			hiddenColIds: state.pTableParams.hiddenColIds?.map((id) => ({
+				type: "column",
+				id
+			})) ?? null,
+			filters: distillFilterSpec(currentCache.filtersState),
+			defaultFilters: null,
+			sorting: state.pTableParams.sorting
+		} : createDefaultPTableParamsV7()
+	};
+}
+/** 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) {
+		case "isNA": return {
+			id,
+			type: "isNA",
+			column
+		};
+		case "isNotNA": return {
+			id,
+			type: "isNotNA",
+			column
+		};
+		case "number_equals": return {
+			id,
+			type: "equal",
+			column,
+			x: filter.reference
+		};
+		case "number_notEquals": return {
+			id,
+			type: "notEqual",
+			column,
+			x: filter.reference
+		};
+		case "number_greaterThan": return {
+			id,
+			type: "greaterThan",
+			column,
+			x: filter.reference
+		};
+		case "number_greaterThanOrEqualTo": return {
+			id,
+			type: "greaterThanOrEqual",
+			column,
+			x: filter.reference
+		};
+		case "number_lessThan": return {
+			id,
+			type: "lessThan",
+			column,
+			x: filter.reference
+		};
+		case "number_lessThanOrEqualTo": return {
+			id,
+			type: "lessThanOrEqual",
+			column,
+			x: filter.reference
+		};
+		case "number_between": return {
+			id,
+			type: "and",
+			filters: [filter.includeLowerBound ? {
+				id: nextId(),
+				type: "greaterThanOrEqual",
+				column,
+				x: filter.lowerBound
+			} : {
+				id: nextId(),
+				type: "greaterThan",
+				column,
+				x: filter.lowerBound
+			}, filter.includeUpperBound ? {
+				id: nextId(),
+				type: "lessThanOrEqual",
+				column,
+				x: filter.upperBound
+			} : {
+				id: nextId(),
+				type: "lessThan",
+				column,
+				x: filter.upperBound
+			}]
+		};
+		case "string_equals": return {
+			id,
+			type: "patternEquals",
+			column,
+			value: filter.reference
+		};
+		case "string_notEquals": return {
+			id,
+			type: "patternNotEquals",
+			column,
+			value: filter.reference
+		};
+		case "string_contains": return {
+			id,
+			type: "patternContainSubsequence",
+			column,
+			value: filter.reference
+		};
+		case "string_doesNotContain": return {
+			id,
+			type: "patternNotContainSubsequence",
+			column,
+			value: filter.reference
+		};
+		case "string_matches": return {
+			id,
+			type: "patternMatchesRegularExpression",
+			column,
+			value: filter.reference
+		};
+		case "string_doesNotMatch": return {
+			id,
+			type: "not",
+			filter: {
+				id: nextId(),
+				type: "patternMatchesRegularExpression",
+				column,
+				value: filter.reference
+			}
+		};
+		case "string_containsFuzzyMatch": return {
+			id,
+			type: "patternFuzzyContainSubsequence",
+			column,
+			value: filter.reference,
+			maxEdits: filter.maxEdits,
+			substitutionsOnly: filter.substitutionsOnly,
+			...filter.wildcard !== void 0 ? { wildcard: filter.wildcard } : {}
+		};
+	}
+}
+/** 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,
+		filters: null,
+		defaultFilters: null,
+		sorting: []
+	};
+}
+function createDefaultPTableParams() {
+	return {
+		sourceId: null,
+		hiddenColIds: null,
+		filters: null,
+		defaultFilters: null,
+		sorting: null
+	};
+}
+function createPlDataTableStateV2() {
+	return {
+		version: 8,
+		stateCache: [],
+		pTableParams: createDefaultPTableParams()
+	};
+}
+function migrateV7toV8(state) {
+	const newCache = state.stateCache.map((entry) => ({
+		sourceId: entry.sourceId,
+		gridState: entry.gridState,
+		sheetsState: entry.sheetsState,
+		filtersState: convertFiltersWithMeta(entry.filtersState),
+		defaultFiltersState: convertFiltersWithMeta(entry.defaultFiltersState),
+		searchString: entry.searchString
+	}));
+	const params = state.pTableParams;
+	let pTableParams;
+	if (params.sourceId === null) pTableParams = createDefaultPTableParams();
+	else pTableParams = {
+		sourceId: params.sourceId,
+		hiddenColIds: params.hiddenColIds,
+		sorting: params.sorting.length === 0 ? null : params.sorting,
+		filters: convertFiltersPlain(params.filters),
+		defaultFilters: convertFiltersPlain(params.defaultFilters)
+	};
+	return {
+		version: 8,
+		stateCache: newCache,
+		pTableParams
+	};
+}
+function convertFiltersWithMeta(node) {
+	if (node === null) return null;
+	const result = pruneFilterNode(node);
+	if (result === void 0) return null;
+	return result;
+}
+function convertFiltersPlain(node) {
+	if (node === null) return null;
+	const result = pruneFilterNode(node);
+	if (result === void 0) return null;
+	return result;
+}
+/** Recursively converts and prunes a legacy v7 filter tree. Preserves meta
+*  fields (id/isExpanded/source/isSuppressed) on non-leaf nodes. Returns
+*  `undefined` when the subtree is empty after pruning. */
+function pruneFilterNode(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const n = node;
+	if (n.type === "and" || n.type === "or") {
+		const kept = (n.filters ?? []).map((f) => pruneFilterNode(f)).filter((f) => f !== void 0);
+		if (kept.length === 0) return void 0;
+		return {
+			...n,
+			type: n.type,
+			filters: kept
+		};
+	}
+	if (n.type === "not") {
+		const inner = pruneFilterNode(n.filter);
+		if (inner === void 0) return void 0;
+		return {
+			...n,
+			type: "not",
+			filter: inner
+		};
+	}
+	return convertLegacyLeaf(n);
+}
+function convertLegacyLeaf(leaf) {
+	if (leaf.type === void 0) return leaf;
+	const result = { ...leaf };
+	if ("column" in result) {
+		const c = parseLegacyLeafColumn(result.column);
+		if (c === void 0) return void 0;
+		result.column = c;
+	}
+	if ("rhs" in result) {
+		const c = parseLegacyLeafColumn(result.rhs);
+		if (c === void 0) return void 0;
+		result.rhs = c;
+	}
+	return result;
+}
+function parseLegacyLeafColumn(s) {
+	if (typeof s !== "string") return void 0;
+	const parsed = parseJsonSafely(s);
+	if (!parsed || typeof parsed !== "object") return void 0;
+	if (!("type" in parsed) || !("id" in parsed)) return void 0;
+	const t = parsed.type;
+	if (t !== "axis" && t !== "column") return void 0;
+	return parsed;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/utils.js
+/** Adapt a {@link ColumnRecipe} to the plain {@link RuleColumn} shape. */
+function toRuleColumn(col) {
+	return {
+		id: extractPObjectId(col.id),
+		spec: col.getSpec()
+	};
+}
+/** Check if column should be omitted from the table */
+function isColumnHidden(spec) {
+	return readAnnotation(spec, Annotation.Table.Visibility) === "hidden";
+}
+/** Check if column is hidden by default */
+function isColumnOptional(spec) {
+	return readAnnotation(spec, Annotation.Table.Visibility) === "optional";
+}
+/** Get effective visibility for a column. Rule map lookup first, then annotation fallback. */
+function getEffectiveVisibility(col, visibilityByColId) {
+	const rule = visibilityByColId?.get(col.id);
+	if (rule !== void 0) return rule.visibility;
+	if (isColumnHidden(col.spec)) return "hidden";
+	if (isColumnOptional(col.spec)) return "optional";
+}
+/** Get ordering priority for a column. Rule map lookup first, then annotation fallback. */
+function getOrderPriority(col, orderByColId) {
+	const rule = orderByColId?.get(col.id);
+	if (rule !== void 0) return rule.priority;
+	const annotation = Number(readAnnotation(col.spec, Annotation.Table.OrderPriority));
+	return isNaN(annotation) ? void 0 : annotation;
+}
+/**
+* Evaluate display rules against a set of columns and return a map of `colId → winning rule`
+* (first-match-wins, preserving original rule order).
+*
+* Predicate-based rules (`ColumnMatcher`) are evaluated directly on the spec.
+* Selector-based rules (`ColumnSelector`) are matched via the
+* `columnsCollection` service — the inline column ids must be resolvable in
+* the active render ctx for the host to read their specs.
+*/
+function evaluateRules(rules, columns) {
+	const result = /* @__PURE__ */ new Map();
+	if (rules.length === 0 || columns.length === 0) return result;
+	const selectorRules = rules.filter((rule) => typeof rule.match !== "function");
+	const selectorHitsByRule = /* @__PURE__ */ new Map();
+	if (selectorRules.length > 0) {
+		const baseCollection = ColumnsCollection([{
+			columns: uniqBy(columns, (col) => col.id),
+			isFinal: true
+		}]);
+		for (const rule of selectorRules) {
+			const hitIds = baseCollection.filter({ include: rule.match }).getColumnIds();
+			if (hitIds.length === 0) continue;
+			selectorHitsByRule.set(rule, new Set(hitIds.map((id) => extractPObjectId(id))));
+		}
+	}
+	for (const col of columns) {
+		const colKey = extractPObjectId(col.id);
+		for (const rule of rules) if (selectorHitsByRule.get(rule)?.has(colKey) ?? false) {
+			result.set(colKey, rule);
+			break;
+		}
+	}
+	return result;
+}
+/**
+* Build a sidecar map `columnId → AnnotationDataStatus` derived from each
+* recipe's own status. This is *rendering* metadata — kept out of the spec
+* so it cannot perturb column identity (id-bearing spec overrides would
+* diverge the visible PTable's column ids from the full table / pframe).
+*
+* Mapping `ColumnFieldStatus` × actual byte-presence → `AnnotationDataStatus`:
+*   - `absent`                       → `"absent"`
+*   - `resolving`                    → `"computing"`
+*   - `present` + `hasColumnData()`  → `"ready"`
+*   - `present` + no bytes yet       → `"computing"`
+*
+* Intentionally scoped to visible columns — the probe is meaningful only for
+* what the user will actually see.
+*/
+function buildDataStatusMap(columns, opts = {}) {
+	return columns.reduce((acc, c) => (acc[c.id] = deriveDataStatus(c, opts), acc), {});
+}
+function deriveDataStatus(column, opts) {
+	const field = column.getDataStatus();
+	if (field === "absent") return "absent";
+	if (field === "resolving") return "computing";
+	return hasColumnData(column, opts) ? "ready" : "computing";
+}
+/** Derive labels for all table elements: columns via deriveDistinctLabels, axes from label columns. */
+function deriveAllLabels(options) {
+	const { columns, deriveLabelsOptions } = options;
+	return deriveDistinctLabels(columns.map((c) => ({
+		spec: c.spec,
+		linkerPath: c.linkerPath?.map((step) => ({ spec: step.linker.spec })),
+		qualifications: c.qualifications
+	})), deriveLabelsOptions).reduce((acc, label, index) => (acc[columns[index].id] = label, acc), {});
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPTableDefV3.js
+/**
+* Assemble a ptable def directly from recipes. Each secondary recipe is its own
+* outer-joined subtree: `getQuery()` encodes its linker chain, and its
+* hit-/queries-qualifications are derived on the spot via {@link hitQualifications}
+* / {@link queriesQualifications} — no pre-extracted DTO. Bare leaves yield empty
+* qualifications, so plain {@link ColumnRecipe} arrays (e.g. label columns) work
+* unchanged.
+*/
+function createPTableDefV3(params) {
+	let query = {
+		type: params.primaryJoinType === "inner" ? "innerJoin" : "fullJoin",
+		entries: params.primary.map((c) => columnToJoinEntry(c, []))
+	};
+	if (params.secondary.length > 0) query = {
+		type: "outerJoin",
+		primary: {
+			entry: query,
+			qualifications: params.secondary.flatMap((s) => {
+				const quals = queriesQualifications(s);
+				return params.primary.flatMap((p) => quals[p.id] ?? []);
+			})
+		},
+		secondary: params.secondary.map((c) => columnToJoinEntry(c, hitQualifications(c)))
+	};
+	if (!isNil(params.filters)) {
+		const nonEmpty = distillFilterSpec(params.filters);
+		if (!isNil(nonEmpty)) {
+			const pridicate = filterSpecToSpecQueryExpr(nonEmpty);
+			if (!isBooleanExpression(pridicate)) throw new Error(`Filter conversion produced a non-boolean expression (got type "${pridicate.type}"), expected a boolean predicate for query filtering`);
+			query = {
+				type: "filter",
+				input: query,
+				predicate: pridicate
+			};
+		}
+	}
+	if (!isNil(params.sorting) && params.sorting.length > 0) query = {
+		type: "sort",
+		input: query,
+		sortBy: params.sorting.map((s) => ({
+			expression: columnIdToExpr(s.column),
+			ascending: s.ascending,
+			nullsFirst: s.naAndAbsentAreLeastValues
+		}))
+	};
+	return { query };
+}
+function columnIdToExpr(col) {
+	return col.type === "axis" ? {
+		type: "axisRef",
+		value: col.id
+	} : {
+		type: "columnRef",
+		value: col.id
+	};
+}
+function columnToJoinEntry(col, qualifications) {
+	return {
+		entry: col.getQuery(),
+		qualifications
+	};
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/columnResolver.js
+function createColumnResolver(columns) {
+	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);
+		if (!byPObjectId.has(pid)) byPObjectId.set(pid, c);
+	}
+	return (ref) => {
+		if (ref.type === "axis") return axisIds.some((a) => matchAxisId(ref.id, a)) ? ref : void 0;
+		const hit = byFullId.get(ref.id) ?? byPObjectId.get(extractPObjectId(ref.id));
+		if (hit === void 0) return void 0;
+		return {
+			type: "column",
+			id: hit.id
+		};
+	};
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/discoverColumns.js
+/**
+* Discover columns from sources/anchors and split them into primary
+* (direct anchor hits — zero-hop, query is a bare column) and secondary
+* (reached via a linker chain, query carries a join).
+*/
+function discoverTableColumns(ctx, options) {
+	const discoveredColumns = ColumnsCollection(options.sources, { ctx: ctx.ctx }).discover({
+		...options.selector,
+		anchors: options.anchors
+	}).getColumns();
+	const primary = [];
+	const secondary = [];
+	for (const col of discoveredColumns) if (hasSingleDataColumn(col)) primary.push(col);
+	else secondary.push(col);
+	return {
+		primary,
+		secondary
+	};
+}
+/**
+* Discover label columns matching the axes of the given value columns from
+* ctx providers. Returns a list of label {@link ColumnRecipe}s.
+*
+* Primary columns are used as anchors for axis-aware label discovery.
+* `maxHops` is taken from the longest linker chain present in `columns`.
+*/
+function discoverLabelColumns(ctx, primary) {
+	if (primary.length === 0) return [];
+	const axes = primary.flatMap((col) => col.getSpec().axesSpec);
+	return ColumnsCollection(void 0, { ctx: ctx.ctx }).discover({
+		include: axes.map((a) => ({
+			name: {
+				type: "exact",
+				value: PColumnName.Label
+			},
+			axes: [{ name: {
+				type: "exact",
+				value: a.name
+			} }]
+		})),
+		anchors: Object.fromEntries(primary.map((col, i) => [`anchor_${i}`, col.getSpec()])),
+		maxHops: 0
+	}).getColumns();
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.84.1/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPlDataTableV3.js
+function createPlDataTableV3(ctx, options) {
+	const state = upgradePlDataTableStateV2(options.tableState);
+	const primaryJoinType = options.primaryJoinType ?? "full";
+	const resolved = resolveInputColumns(ctx, options);
+	if (resolved === void 0) return void 0;
+	const { primary, secondary } = resolved;
+	if (primary.length === 0) return void 0;
+	const { direct, linked } = splitByTopology(secondary);
+	const derivedLabels = deriveAllLabels({
+		columns: [...primary, ...secondary].filter((c) => !isColumnHidden(c.getSpec())).map(toLabelableColumn),
+		deriveLabelsOptions: {
+			includeNativeLabel: true,
+			...options.labelsOptions
+		}
+	});
+	const allColumnsForRules = [
+		...primary,
+		...direct,
+		...linked,
+		...collectLinkerSnapshots(linked)
+	];
+	const visibilityByColId = evaluateRules(options.displayOptions?.visibility ?? [], allColumnsForRules);
+	const orderByColId = evaluateRules(options.displayOptions?.ordering ?? [], allColumnsForRules);
+	const resolver = createColumnResolver([
+		...primary,
+		...direct,
+		...linked.flatMap((lc) => [...collectLinkerColumns(lc), lc])
+	]);
+	const remapedDefaultFilters = remapFilterColumnIds(options.filters, resolver);
+	const filters = filterFilters(concatFilters(state.pTableParams.filters, state.pTableParams.defaultFilters ?? remapedDefaultFilters), resolver);
+	const sorting = filterSorting(resolveSorting(state.pTableParams.sorting, remapSortingColumnIds(options.sorting, resolver)), resolver);
+	const fullDef = createPTableDefV3({
+		primaryJoinType,
+		primary,
+		secondary: [...direct, ...linked],
+		filters,
+		sorting
+	});
+	const fullHandle = ctx.createPTableV2(fullDef);
+	const pframeHandle = ctx.createPFrame(uniq([
+		...primary.map((v) => extractPObjectId(v.id)),
+		...direct.map((v) => extractPObjectId(v.id)),
+		...linked.map((v) => extractPObjectId(v.id))
+	]));
+	const hiddenSpecs = state.pTableParams.hiddenColIds;
+	const hiddenColumnIds = computeHiddenColumns({
+		columns: [
+			...primary,
+			...direct,
+			...linked
+		],
+		visibilityByColId,
+		sorting,
+		filters,
+		hiddenSpecs
+	});
+	const visible = {
+		primary,
+		direct: direct.filter((c) => !hiddenColumnIds.has(c.id)),
+		linked: linked.filter((c) => !hiddenColumnIds.has(c.id))
+	};
+	const visibleDef = createPTableDefV3({
+		primaryJoinType,
+		primary,
+		secondary: [...visible.direct, ...visible.linked],
+		filters,
+		sorting
+	});
+	const visibleHandle = ctx.createPTableV2(visibleDef);
+	const columnsMeta = buildColumnsMeta({
+		fullColumns: [
+			...primary,
+			...direct,
+			...linked
+		],
+		visibleColumns: [
+			...visible.primary,
+			...visible.direct,
+			...visible.linked
+		],
+		primaryColumns: primary,
+		derivedLabels,
+		visibilityByColId,
+		orderByColId
+	});
+	return {
+		sourceId: state.pTableParams.sourceId,
+		fullTableHandle: fullHandle,
+		fullPframeHandle: pframeHandle,
+		visibleTableHandle: visibleHandle,
+		defaultFilters: remapedDefaultFilters,
+		columnsMeta
+	};
+}
+/** Normalize either option branch into a {primary, secondary} pair of recipes. */
+function resolveInputColumns(ctx, options) {
+	if ("primaryColumns" in options) {
+		const primary = options.primaryColumns;
+		const secondary = options.columns ?? [];
+		const labels = discoverLabelColumns(ctx, primary);
+		const primaryIds = new Set(primary.map((c) => c.id));
+		return {
+			primary,
+			secondary: dedupColumns([...secondary, ...labels].filter((c) => !primaryIds.has(c.id)), (c) => c.id, (c) => c.getSpec())
+		};
+	}
+	if (isPlainObject$1(options.columns)) return discoverTableColumns(ctx, options.columns);
+}
+/** Split secondary recipes by query topology: leaves (no linker chain) vs joined. */
+function splitByTopology(columns) {
+	const direct = [];
+	const linked = [];
+	for (const c of columns) if (hasSingleDataColumn(c)) direct.push(c);
+	else linked.push(c);
+	return {
+		direct,
+		linked
+	};
+}
+/** All linker recipes across the given linked columns, deduped by id. */
+function collectLinkerSnapshots(linked) {
+	return uniqueBy(linked.flatMap((c) => collectLinkerColumns(c)), (c) => c.id);
+}
+function toLabelableColumn(col) {
+	return {
+		id: col.id,
+		spec: col.getSpec(),
+		linkerPath: collectLinkerColumns(col).map((linker) => ({ linker: { spec: linker.getSpec() } })),
+		qualifications: {
+			forHit: [...hitQualifications(col)],
+			forQueries: queriesQualifications(col)
+		}
+	};
+}
+/**
+* Compute display metadata as a sidecar keyed by each emitted column's
+* `ColumnUniversalId` (and axis `AxisId`), instead of baking it into the specs
+* via `withSpecs`. Spec overrides change a recipe's id, so the same physical
+* column reached two ways would diverge into two ids and render twice; keeping
+* meta out of the spec preserves identity and lets dedup collapse such cases.
+* The UI overlays this onto the engine-emitted specs at render time.
+*/
+function buildColumnsMeta(params) {
+	const { fullColumns, visibleColumns, primaryColumns, derivedLabels } = params;
+	const { visibilityByColId, orderByColId } = params;
+	const visibleStatus = buildDataStatusMap(visibleColumns);
+	const columns = fullColumns.reduce((acc, c) => {
+		const rc = toRuleColumn(c);
+		acc[c.id] = {
+			label: derivedLabels[c.id],
+			visibility: getEffectiveVisibility(rc, visibilityByColId),
+			order: getOrderPriority(rc, orderByColId),
+			status: visibleStatus[c.id]
+		};
+		return acc;
+	}, {});
+	const primaryAxisKeys = new Set(primaryColumns.flatMap((c) => c.getSpec().axesSpec.map((a) => canonicalizeAxisId(a))));
+	return {
+		columns,
+		axes: fullColumns.reduce((acc, c) => c.getSpec().axesSpec.reduce((inner, ax) => {
+			const key = canonicalizeAxisId(ax);
+			if (inner[key] === void 0) inner[key] = { hidden: !primaryAxisKeys.has(key) };
+			return inner;
+		}, acc), {})
+	};
+}
+/** Drop filter leaves whose column references cannot be resolved; rewrite the
+*  resolvable ones through the resolver. Prune empty and/or/not groups. */
+function filterFilters(filters, resolver) {
+	if (isNil$1(filters)) return filters;
+	const rewriteLeaf = (leaf) => {
+		if (leaf.type === void 0) return leaf;
+		const result = { ...leaf };
+		if ("column" in result) {
+			const c = resolver(result.column);
+			if (isNil$1(c)) return void 0;
+			result.column = c;
+		}
+		if ("rhs" in result) {
+			const c = resolver(result.rhs);
+			if (isNil$1(c)) return void 0;
+			result.rhs = c;
+		}
+		return result;
+	};
+	const prune = (node) => {
+		if (node.type === "and" || node.type === "or") {
+			const kept = node.filters.map((f) => prune(f)).filter((f) => !isNil$1(f));
+			if (kept.length === 0) return void 0;
+			return {
+				type: node.type,
+				filters: kept
+			};
+		}
+		if (node.type === "not") {
+			const inner = prune(node.filter);
+			return isNil$1(inner) ? void 0 : {
+				type: "not",
+				filter: inner
+			};
+		}
+		return rewriteLeaf(node);
+	};
+	return prune(filters);
+}
+/** Merge two filter trees into one AND-combined tree. Returns the non-nil one if the other is nil.
+*  Exported for unit testing. */
+function concatFilters(a, b) {
+	if (isNil$1(a)) return b;
+	if (isNil$1(b)) return a;
+	const operands = (f) => f.type === "and" ? f.filters : [f];
+	return {
+		type: "and",
+		filters: [...operands(a), ...operands(b)]
+	};
+}
+/** Pick user sorting from state if set, otherwise fall back to options default.
+*  null = user has not touched sorting → use default;
+*  [] = user has explicitly cleared sorting → no sorting (default ignored). */
+function resolveSorting(userSorting, defaultSorting) {
+	return (isNil$1(userSorting) ? defaultSorting : userSorting) ?? [];
+}
+/** Rewrite sorting entries through the resolver; drop those that fail to resolve. */
+function filterSorting(sorting, resolver) {
+	return sorting.flatMap((s) => {
+		const col = resolver(s.column);
+		return isNil$1(col) ? [] : [{
+			...s,
+			column: col
+		}];
+	});
+}
+/** Determine which columns should be hidden based on state or optional-column defaults.
+*  Keyed by the recipe's logical {@link ColumnUniversalId} (rich) — variants of
+*  the same physical column are independently visible/hidden. */
+function computeHiddenColumns(params) {
+	const { columns, visibilityByColId, sorting, filters, hiddenSpecs } = params;
+	const visibilityOf = (c) => getEffectiveVisibility(toRuleColumn(c), visibilityByColId);
+	const alwaysHidden = columns.filter((c) => visibilityOf(c) === "hidden").map((c) => c.id);
+	const optionalHidden = !isNil$1(hiddenSpecs) ? hiddenSpecs.filter((s) => s.type === "column").map((s) => s.id) : columns.filter((c) => visibilityOf(c) === "optional").map((c) => c.id);
+	const initial = [...alwaysHidden, ...optionalHidden];
+	const preserved = collectPreservedColumnIds(sorting, filters);
+	return new Set(initial.filter((id) => !preserved.has(id)));
+}
+/** Collect IDs of columns that must remain visible (sorted, filtered). */
+function collectPreservedColumnIds(sorting, filters) {
+	const sortedIds = (sorting ?? []).map((s) => s.column).filter((c) => c.type === "column").map((c) => c.id);
+	const filterIds = !isNil$1(filters) ? collectFilterSpecColumns(filters).flatMap((c) => c.type === "column" ? [c.id] : []) : [];
+	return /* @__PURE__ */ new Set([...sortedIds, ...filterIds]);
+}
+/** Remap column references in sorting entries through the resolver.
+*  Unresolved entries are dropped with a warning (best-effort contract). */
+function remapSortingColumnIds(sorting, resolver) {
+	return sorting?.flatMap((s) => {
+		const col = resolver(s.column);
+		if (isNil$1(col)) {
+			console.warn(`Sorting column ${JSON.stringify(s.column)} does not match any discovered column — dropped.`);
+			return [];
+		}
+		return [{
+			...s,
+			column: col
+		}];
+	});
+}
+/** Remap column references in a filter tree through the resolver.
+*  Unresolved leaves are dropped with a warning; empty groups are pruned. */
+function remapFilterColumnIds(filters, resolver) {
+	if (isNil$1(filters)) return filters;
+	const mapLeaf = (leaf) => {
+		if (leaf.type === void 0) return leaf;
+		const result = { ...leaf };
+		if ("column" in result) {
+			const c = resolver(result.column);
+			if (isNil$1(c)) {
+				console.warn(`Filter column ${JSON.stringify(result.column)} does not match any discovered column — dropped.`);
+				return;
+			}
+			result.column = c;
+		}
+		if ("rhs" in result) {
+			const c = resolver(result.rhs);
+			if (isNil$1(c)) {
+				console.warn(`Filter rhs ${JSON.stringify(result.rhs)} does not match any discovered column — dropped.`);
+				return;
+			}
+			result.rhs = c;
+		}
+		return result;
+	};
+	const prune = (node) => {
+		if (node.type === "and" || node.type === "or") {
+			const kept = node.filters.map((f) => prune(f)).filter((f) => !isNil$1(f));
+			if (kept.length === 0) return void 0;
+			return {
+				type: node.type,
+				filters: kept
+			};
+		}
+		if (node.type === "not") {
+			const inner = prune(node.filter);
+			return isNil$1(inner) ? void 0 : {
+				type: "not",
+				filter: inner
+			};
+		}
+		return mapLeaf(node);
+	};
+	return prune(filters);
+}
+(/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports = module.exports = stringify;
+	exports.getSerialize = serializer;
+	function stringify(obj, replacer, spaces, cycleReplacer) {
+		return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
+	}
+	function serializer(replacer, cycleReplacer) {
+		var stack = [], keys = [];
+		if (cycleReplacer == null) cycleReplacer = function(key, value) {
+			if (stack[0] === value) return "[Circular ~]";
+			return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+		};
+		return function(key, value) {
+			if (stack.length > 0) {
+				var thisPos = stack.indexOf(this);
+				~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+				~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+				if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value);
+			} else stack.push(value);
+			return replacer == null ? value : replacer.call(this, key, value);
+		};
+	}
+})))();
+const PlErrorLike = objectType({
+	type: literalType("PlError"),
+	name: stringType(),
+	message: stringType(),
+	fullMessage: stringType().optional(),
+	stack: stringType().optional()
+}).extend({
+	cause: lazyType(() => ErrorLike).optional(),
+	errors: lazyType(() => ErrorLike.array()).optional()
+});
+const ErrorLike = unionType([objectType({
+	type: literalType("StandardError"),
+	name: stringType(),
+	message: stringType(),
+	stack: stringType().optional()
+}).extend({
+	cause: lazyType(() => ErrorLike).optional(),
+	errors: lazyType(() => ErrorLike.array()).optional()
 }), PlErrorLike]);
 const ErrorShape = objectType({
 	name: stringType(),
@@ -11427,7 +13430,7 @@ const ErrorShape = objectType({
 	errors: lazyType(() => ErrorShape.array()).optional()
 });
 //#endregion
-//#region ../model/dist/index.js
+//#region ../model/dist/render-utils.js
 /** A selector `name`/`domain` given as a bare string normalizes to a REGEX matcher, so an
 *  exact name must be spelled out. `"pl7.app/frequency"` as a regex is unanchored and `.`
 *  matches any character, which would also admit `pl7.app/frequencyRatio`. */
@@ -11450,39 +13453,343 @@ function dedupByLeafId(recipes) {
 		return true;
 	});
 }
+/**
+* The p-columns of one workflow output, or undefined while the block is still computing.
+*
+* `getPColumns()` throws two different ways and they must not be treated alike. Mid-run the
+* resource tree is incomplete and traversal can throw — that is transient and means "not yet".
+* Once the block is ready-or-error, a throw means the workflow FAILED, and swallowing it makes a
+* crashed run indistinguishable from a healthy empty one: the output reports ok with no value,
+* the block shows Done, and the map is simply blank. That cost a day of debugging once already,
+* so past readiness the error is rethrown and surfaces on the output.
+*/
+function outputPColumns(ctx, name) {
+	try {
+		const node = ctx.outputs?.resolve(name);
+		if (node === void 0) return void 0;
+		return node.getPColumns();
+	} catch (e) {
+		if (String(e).includes("field not found")) return void 0;
+		if (ctx.outputs?.getIsReadyOrError() === false) return void 0;
+		throw e;
+	}
+}
+/**
+* Spec for a ref from the result pool, reported absent only once that absence has settled.
+*
+* `getPColumnSpecByRef` answers from the pool as it stands and registers nothing, so a column
+* that has not reached the pool yet is indistinguishable from one that never will. The output
+* settles at `undefined`, and a table fed by it then renders its not-ready text ("Select score
+* columns in Settings, then Run") for the seconds the pool takes to fill, although nothing is
+* wrong and the data is on its way. `getSpecs` does register — the middle layer marks the render
+* unstable while the pool is incomplete (`specs_from_pool_incomplete`) — so consulting it on a
+* miss keeps the output unsettled until the pool is complete and the absence is real.
+*/
+function poolSpecByRef(ctx, ref) {
+	const spec = ctx.resultPool.getPColumnSpecByRef(ref);
+	if (spec !== void 0) return spec;
+	ctx.resultPool.getSpecs();
+}
+//#endregion
+//#region ../model/dist/specs.js
+/**
+* Column and axis names this block shares with its workflow and with the profiler upstream.
+*
+* Every string here is a contract: change one and the matching literal in
+* `workflow/src/main.tpl.tengo` — or in the profiler that emits it — has to change with it, or
+* the column simply stops being found and an output goes quietly empty. They live in one file so
+* that obligation is visible rather than buried among the render helpers.
+*/
 const STATE_MATRIX = "pl7.app/repertoire/stateMatrix";
-const LANDSCAPE_VALUE = "pl7.app/repertoire/singleMutantValue";
 const LANDSCAPE_SCORE_REF = "pl7.app/repertoire/landscapeScoreRef";
-const LANDSCAPE_SCORE_INDEX = "pl7.app/repertoire/landscapeScoreIndex";
-const NO_DATASET_LABEL = "No dataset selected";
+const MUTATION_ID_AXIS = "pl7.app/repertoire/mutationId";
+const MUTATION_VARIANT_LINK = "pl7.app/repertoire/mutationVariantLink";
+const BROWSABLE_MUTATION = "pl7.app/repertoire/browsableMutation";
+//#endregion
+//#region ../model/dist/drill-down-table.js
 /**
-* Default state for a mutation-landscape chart. Used by `init` for the placeholder and by the UI
-* for each score a run produces, so the two look alike.
+* The Table tab: every variant carrying the active drill-down's substitution, at any mutation
+* count.
 *
-* @param currentTab `"settings"` opens the Settings drawer, `null` leaves it closed
+* The block exports only the `[variantKey, mutationId]` linker as the primary column; sequence,
+* mutations, mutation count, abundance and the scores are joined in from the result pool on the
+* shared variantKey axis, so none of them is copied into this block's own exports and the user
+* can surface any other variant-keyed column later.
 */
-function makeLandscapeChartState(title, currentTab) {
-	return {
-		title,
-		template: "heatmap",
-		currentTab,
-		layersSettings: { heatmap: {
-			normalizationDirection: null,
-			transform: null
-		} },
-		axesSettings: {
-			axisX: { cellSize: 20 },
-			axisY: {
-				hideAxisLabels: false,
-				cellSize: 20
-			}
+function drillDownTableModel(ctx) {
+	const mutationId = ctx.data.activeDrillDown;
+	const linker = outputPColumns(ctx, "mutationVariantLinkPf")?.find((c) => c.spec.name === MUTATION_VARIANT_LINK);
+	if (linker === void 0) return void 0;
+	const mutationAxis = linker.spec.axesSpec.find((a) => a.name === MUTATION_ID_AXIS);
+	if (mutationAxis === void 0) return void 0;
+	const stateMatrixRef = ctx.data.stateMatrixRef;
+	if (stateMatrixRef === void 0) return void 0;
+	const stateSpec = poolSpecByRef(ctx, stateMatrixRef);
+	if (!stateSpec) return void 0;
+	const discovered = ColumnsCollection(["result_pool"]).discover({
+		anchors: { main: stateSpec },
+		mode: "enrichment",
+		maxHops: 0,
+		exclude: [{ annotations: { "pl7.app/isLinkerColumn": exactMatch("true") } }]
+	}).getColumns();
+	const secondary = dedupByLeafId(discovered).filter((recipe) => {
+		const axes = recipe.getSpec().axesSpec;
+		return axes.length === 1 && axes[0].name === "pl7.app/variantKey";
+	});
+	const scoreKey = ctx.data.drillDowns.find((d) => d.mutationId === mutationId)?.scoreKey;
+	const activeScoreSpec = scoreKey === void 0 ? void 0 : discovered.find((recipe) => recipe.id === scoreKey)?.getSpec();
+	const visibility = [
+		{
+			match: { name: exactMatch("pl7.app/label") },
+			visibility: "default"
+		},
+		{
+			match: { name: exactMatch("pl7.app/repertoire/mutations") },
+			visibility: "default"
+		},
+		{
+			match: { name: exactMatch("pl7.app/repertoire/mutationCount") },
+			visibility: "default"
+		},
+		{
+			match: {
+				name: exactMatch("pl7.app/sequence"),
+				annotations: { "pl7.app/isMainSequence": exactMatch("true") }
+			},
+			visibility: "default"
 		}
-	};
+	];
+	if (activeScoreSpec !== void 0) visibility.push({
+		match: {
+			name: exactMatch(activeScoreSpec.name),
+			domain: Object.fromEntries(Object.entries(activeScoreSpec.domain ?? {}).map(([k, v]) => [k, exactMatch(v)]))
+		},
+		visibility: "default"
+	});
+	visibility.push({
+		match: { name: ".*" },
+		visibility: "optional"
+	});
+	return createPlDataTableV3(ctx, {
+		primaryColumns: [DataColumn.fromColumn(linker)],
+		columns: secondary,
+		displayOptions: { visibility },
+		filters: mutationId === void 0 ? void 0 : {
+			type: "and",
+			filters: [{
+				type: "patternEquals",
+				column: {
+					type: "axis",
+					id: {
+						name: mutationAxis.name,
+						type: mutationAxis.type,
+						domain: mutationAxis.domain
+					}
+				},
+				value: mutationId
+			}]
+		},
+		tableState: ctx.data.drillDownTableState
+	});
+}
+//#endregion
+//#region ../kind/dist/package.js
+var name = "@platforma-open/milaboratories.repertoire-mutation-heatmap.kind";
+var version = "1.0.0";
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+block-kind@1.1.0/node_modules/@platforma-sdk/block-kind/dist/params.js
+/**
+* Establish that a value is an object whose fields a kind can read — the half of a params
+* check every kind needs and no two kinds differ on.
+*
+* Params that arrived from a template file are `unknown`, and before a single field can be
+* read the value has to be an object. Worth a shared function because the check is easy to
+* get wrong by hand: `typeof null` is `"object"`, `Object.keys(5)` is `[]` and
+* `Object.keys(["a"])` is `["0"]`, so a naive test lets `null`, a number and an array through
+* as if they were empty params.
+*
+* What each field must *be* is the kind's own business and stays in the kind, as plain
+* TypeScript: this package deliberately carries no validation library, so a kind author owes
+* it no schema.
+*
+* A key the kind does not declare is NOT refused. A parser returns the params to use, so a
+* field it never read is dropped and never reaches the block — the only question was whether
+* to also complain, and complaining costs more than it catches. It would mean each kind
+* restating its own field list as strings, with nothing checking that the list stayed in step
+* with the type: a field added to the contract and read by the parser, but missed in the list,
+* would turn into a kind that refuses files that are correct. What an unexpected key can
+* actually mean is a params contract from a different version of the kind, and that is
+* guarded where it belongs — by the version in the entry's `{name}@{selector}` reference.
+*
+* An assertion rather than a parser that returns a copy, so a kind reads its fields off the
+* value it was handed:
+*
+* ```ts
+* function parseInitializationParams(value: unknown): BlockParams {
+*   assertParamsObject(value);
+*
+*   const { numbers } = value;
+*   if (numbers !== undefined && !isNumberArray(numbers)) {
+*     throw new Error("'numbers' must be an array of numbers.");
+*   }
+*   return { numbers };
+* }
+* ```
+*
+* Messages are finished sentences addressed to whoever wrote the file, because that is who
+* reads them: a kind's rejection is reported against the entry that carried the params.
+*
+* @param value The params as they arrived
+* @throws if `value` is not an object
+*/
+function assertParamsObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Params must be an object, not ${describe(value)}.`);
+}
+/** What a value is, for a message that has to say why it is not an object. */
+function describe(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "nothing";
+	if (Array.isArray(value)) return "an array";
+	return `a ${typeof value} (${JSON.stringify(value) ?? String(value)})`;
+}
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+block-kind@1.1.0/node_modules/@platforma-sdk/block-kind/dist/index.js
+/**
+* Define a block kind.
+*
+* `meta` is the kind's identity — its own `{ name, version }`. Source it from
+* the package's `package.json` rather than hand-typing literals, so the on-wire
+* `{name}@{version}` cannot drift from what npm publishes and what the S3
+* manifest records (all read the same `package.json`):
+*
+* ```ts
+* // a kind package's src/index.ts
+* import { name, version } from "../package.json" with { type: "json" };
+* export const kind = defineBlockKind<Params>({ name, version });
+* ```
+*
+* rolldown inlines the JSON import (tree-shaken to the two strings) into the
+* bundled `kind.js`, so no build-time injection is needed.
+*
+* A kind must also declare `parseInitializationParams` — the runtime check applied to params
+* that came from a template file rather than from typed code. See
+* {@link CompiledBlockKind} for what it must do.
+*
+* @typeParam BlockParams - shape of the params a block of this kind reads. Pinned both
+*   as a type and by `parseInitializationParams`, whose return type is checked against it.
+*/
+function defineBlockKind(meta) {
+	return Object.freeze({
+		kindSchema: "v1",
+		name: meta.name,
+		version: meta.version,
+		parseInitializationParams: meta.parseInitializationParams
+	});
+}
+//#endregion
+//#region ../kind/dist/index.js
+/**
+* The same contract at runtime, for params that arrive from a template file
+* rather than from typed code.
+*
+* The contract names no fields, so there is nothing to read and nothing to
+* validate beyond the value being an object at all. Keys a template supplies
+* anyway are dropped by not being read. The return type holds this in step: the
+* moment `BlockParams` declares a required field, `return {}` stops compiling.
+*/
+function parseInitializationParams(value) {
+	assertParamsObject(value);
+	return {};
+}
+const kind = defineBlockKind({
+	name,
+	version,
+	parseInitializationParams
+});
+//#endregion
+//#region ../model/dist/index.js
+/**
+* The section href of one drill-down. The model builds the section list with it and the UI
+* navigates with it, so the two cannot drift apart on the encoding — which they would, silently,
+* the first time a designator needed escaping.
+*/
+/**
+* `A5C · Bin score (5.5)` — the substitution and the score it is measured on.
+*
+* Derived from the produced columns rather than stored on the drill-down: a stored label goes
+* stale when a score is renamed upstream, and would be missing entirely on any drill-down opened
+* before it was introduced. Falls back to the bare designator before a run has produced columns.
+*/
+function drillDownLabel(mutationId, scoreLabel) {
+	return scoreLabel ? `${mutationId} · ${scoreLabel}` : mutationId;
+}
+/**
+* The landscape charts the last run produced, in the user's score order.
+*
+* Shared by the `landscapePanels` output and by `.sections()`, which needs the same list to name
+* one page per score — two derivations of "which charts exist" would drift the moment one of
+* them changed.
+*/
+function landscapePanelsFrom(pCols) {
+	if (pCols === void 0) return void 0;
+	const panels = [];
+	for (const col of pCols) {
+		if (col.spec.name !== "pl7.app/repertoire/singleMutantValue") continue;
+		const key = col.spec.annotations?.[LANDSCAPE_SCORE_REF];
+		if (key === void 0) continue;
+		panels.push({
+			key,
+			label: col.spec.annotations?.["pl7.app/label"] ?? "Score",
+			index: Number(col.spec.annotations?.["pl7.app/repertoire/landscapeScoreIndex"] ?? "0"),
+			spec: col.spec
+		});
+	}
+	panels.sort((a, b) => a.index - b.index);
+	return panels;
 }
+/** The section href of one landscape page. */
+function landscapeHref(scoreKey) {
+	return `/?score=${encodeURIComponent(scoreKey)}`;
+}
+/** `Landscape · Bin score (5.5)` — what the sidebar shows for one landscape page. */
+function landscapeLabel(scoreLabel) {
+	return `Landscape · ${scoreLabel}`;
+}
+/** score id -> display label, from the columns the last run produced. */
+function scoreLabelsByKey(pCols) {
+	const labels = {};
+	for (const col of pCols ?? []) {
+		if (col.spec.name !== "pl7.app/repertoire/singleMutantValue") continue;
+		const key = col.spec.annotations?.[LANDSCAPE_SCORE_REF];
+		const label = col.spec.annotations?.["pl7.app/label"];
+		if (key !== void 0 && label !== void 0) labels[key] = label;
+	}
+	return labels;
+}
+function drillDownHref(mutationId) {
+	return `/drilldown?m=${encodeURIComponent(mutationId)}`;
+}
+const NO_DATASET_LABEL = "No dataset selected";
 const dataModel = new DataModelBuilder({ kind }).from("v1").migrate("v2", (v1) => ({
 	...v1,
 	singleMutantHeatmapStates: {}
+})).migrate("v3", (v2) => ({
+	...v2,
+	singleMutantHeatmapState: withEmptyNAValue(v2.singleMutantHeatmapState),
+	singleMutantHeatmapStates: Object.fromEntries(Object.entries(v2.singleMutantHeatmapStates).map(([key, state]) => [key, withEmptyNAValue(state)]))
+})).migrate("v4", (v3) => ({
+	...v3,
+	...mapChartStates(v3, withParentOnXAxis)
+})).migrate("v5", (v4) => ({
+	...v4,
+	drillDowns: [],
+	drillDownChartState: makeDrillDownChartState(),
+	drillDownTableState: createPlDataTableStateV2(),
+	...mapChartStates(v4, withRegionColoursReseeded)
 })).init(() => ({
+	drillDowns: [],
+	drillDownChartState: makeDrillDownChartState(),
+	drillDownTableState: createPlDataTableStateV2(),
 	roundFrequencyRefs: [],
 	compositionEpsilon: 1e-6,
 	scoreRefs: [],
@@ -11498,7 +13805,10 @@ const dataModel = new DataModelBuilder({ kind }).from("v1").migrate("v2", (v1) =
 		} },
 		axesSettings: {
 			other: { facetColumns: 1 },
-			axisX: { cellSize: 20 },
+			axisX: {
+				cellSize: 20,
+				axisLabelsAngle: 45
+			},
 			axisY: {
 				hideAxisLabels: false,
 				cellSize: 20
@@ -11535,7 +13845,7 @@ const platforma$1 = BlockModelV3.create({
 }).output("scoreOptions", (ctx) => {
 	const stateMatrixRef = ctx.data.stateMatrixRef;
 	if (stateMatrixRef === void 0) return void 0;
-	const stateSpec = ctx.resultPool.getPColumnSpecByRef(stateMatrixRef);
+	const stateSpec = poolSpecByRef(ctx, stateMatrixRef);
 	if (!stateSpec) return void 0;
 	const anchors = { main: stateSpec };
 	const columns = ColumnsCollection(["result_pool"]).discover({
@@ -11567,7 +13877,7 @@ const platforma$1 = BlockModelV3.create({
 }).output("roundFrequencyOptions", (ctx) => {
 	const stateMatrixRef = ctx.data.stateMatrixRef;
 	if (stateMatrixRef === void 0) return void 0;
-	const stateSpec = ctx.resultPool.getPColumnSpecByRef(stateMatrixRef);
+	const stateSpec = poolSpecByRef(ctx, stateMatrixRef);
 	if (!stateSpec) return void 0;
 	return dedupByLeafId(ColumnsCollection(["result_pool"]).discover({
 		include: { name: exactMatch("pl7.app/frequency") },
@@ -11591,66 +13901,61 @@ const platforma$1 = BlockModelV3.create({
 	if (stateMatrixRef === void 0) return void 0;
 	return ctx.resultPool.getPColumnByRef(stateMatrixRef)?.id;
 }).outputWithStatus("singleMutantHeatmapPf", (ctx) => {
-	try {
-		const pCols = ctx.outputs?.resolve("singleMutantHeatmapPf")?.getPColumns();
-		if (pCols === void 0) return void 0;
-		return createPFrameForGraphs(ctx, pCols);
-	} catch {
-		return;
-	}
+	const pCols = outputPColumns(ctx, "singleMutantHeatmapPf");
+	if (pCols === void 0) return void 0;
+	return createPFrameForGraphs(ctx, pCols);
 }).output("singleMutantHeatmapPCols", (ctx) => {
-	try {
-		return ctx.outputs?.resolve("singleMutantHeatmapPf")?.getPColumns();
-	} catch {
-		return;
-	}
-}).output("landscapePanels", (ctx) => {
-	let pCols;
-	try {
-		pCols = ctx.outputs?.resolve("singleMutantHeatmapPf")?.getPColumns();
-	} catch {
-		return;
-	}
+	return outputPColumns(ctx, "singleMutantHeatmapPf");
+}).output("landscapePanels", (ctx) => landscapePanelsFrom(outputPColumns(ctx, "singleMutantHeatmapPf"))).outputWithStatus("drillDownHeatmapPf", (ctx) => {
+	const pCols = outputPColumns(ctx, "drillDownHeatmapPf");
 	if (pCols === void 0) return void 0;
-	const panels = [];
-	for (const col of pCols) {
-		if (col.spec.name !== LANDSCAPE_VALUE) continue;
-		const key = col.spec.annotations?.[LANDSCAPE_SCORE_REF];
-		if (key === void 0) continue;
-		panels.push({
-			key,
-			label: col.spec.annotations?.["pl7.app/label"] ?? "Score",
-			index: Number(col.spec.annotations?.[LANDSCAPE_SCORE_INDEX] ?? "0"),
-			spec: col.spec
-		});
-	}
-	panels.sort((a, b) => a.index - b.index);
-	return panels;
-}).outputWithStatus("compositionHeatmapPf", (ctx) => {
-	try {
-		const pCols = ctx.outputs?.resolve("compositionHeatmapPf")?.getPColumns();
-		if (pCols === void 0) return void 0;
-		return createPFrameForGraphs(ctx, pCols);
-	} catch {
-		return;
-	}
+	return createPFrameForGraphs(ctx, pCols);
+}).output("drillDownHeatmapPCols", (ctx) => {
+	return outputPColumns(ctx, "drillDownHeatmapPf");
+}).output("browsableMutationsPf", (ctx) => {
+	const pCols = outputPColumns(ctx, "browsableMutationsPf");
+	if (pCols === void 0 || pCols.length === 0) return void 0;
+	return ctx.createPFrame(pCols);
+}).output("browsableMutationsColId", (ctx) => {
+	return outputPColumns(ctx, "browsableMutationsPf")?.find((c) => c.spec.name === BROWSABLE_MUTATION)?.id;
+}).outputWithStatus("drillDownTable", (ctx) => drillDownTableModel(ctx)).outputWithStatus("compositionHeatmapPf", (ctx) => {
+	const pCols = outputPColumns(ctx, "compositionHeatmapPf");
+	if (pCols === void 0) return void 0;
+	return createPFrameForGraphs(ctx, pCols);
 }).output("compositionHeatmapPCols", (ctx) => {
-	try {
-		return ctx.outputs?.resolve("compositionHeatmapPf")?.getPColumns();
-	} catch {
-		return;
-	}
+	return outputPColumns(ctx, "compositionHeatmapPf");
 }).output("isRunning", (ctx) => ctx.outputs?.getIsReadyOrError() === false).title(() => "Mutation Explorer").subtitle((ctx) => ctx.data.customBlockLabel || ctx.data.defaultBlockLabel || NO_DATASET_LABEL).sections((ctx) => {
-	const sections = [{
+	const pCols = outputPColumns(ctx, "singleMutantHeatmapPf");
+	const panels = landscapePanelsFrom(pCols) ?? [];
+	const sections = [];
+	if (panels.length === 0) sections.push({
 		type: "link",
 		href: "/",
 		label: "Single Mutation Landscape"
-	}];
-	if (ctx.data.roundFrequencyRefs.length >= 2) sections.push({
+	});
+	else for (const p of panels) sections.push({
 		type: "link",
-		href: "/composition",
-		label: "Enrichment Analysis"
+		href: landscapeHref(p.key),
+		label: landscapeLabel(p.label)
 	});
+	const drillDowns = ctx.data.drillDowns ?? [];
+	if (drillDowns.length > 0) {
+		const scoreLabels = scoreLabelsByKey(pCols);
+		sections.push({ type: "delimiter" });
+		for (const d of drillDowns) sections.push({
+			type: "link",
+			href: drillDownHref(d.mutationId),
+			label: drillDownLabel(d.mutationId, scoreLabels[d.scoreKey])
+		});
+	}
+	if (ctx.data.roundFrequencyRefs.length >= 2) {
+		sections.push({ type: "delimiter" });
+		sections.push({
+			type: "link",
+			href: "/composition",
+			label: "Enrichment Analysis"
+		});
+	}
 	return sections;
 }).done();
 //#endregion