@platforma-open/milaboratories.sequence-properties.model 1.2.1 → 1.2.3

package/dist/bundle.js

@@ -4973,6 +4973,9 @@
 			Sequence: "pl7.app/vdj/sequence"
 		}
 	};
+	function isLabelColumn(column) {
+		return column.axesSpec.length === 1 && column.name === PColumnName.Label;
+	}
 	/** Get column id and spec from a column */
 	function getColumnIdAndSpec(column) {
 		return {
@@ -5545,47 +5548,6 @@
 		return v === null || v === void 0;
 	}
 	Array.isArray;
-	function isObject(value) {
-		return typeof value === "object" && value !== null;
-	}
-	/**
-	* Checks if the given value is a plain object.
-	*
-	* A plain object is defined as an object created by the `{}` literal,
-	* an object created with `Object.create(null)`, or an object with a
-	* prototype that resolves to `Object.prototype`.
-	*
-	* @param value - The value to check.
-	* @returns `true` if the value is a plain object, otherwise `false`.
-	*
-	* @example
-	* ```typescript
-	* isPlainObject({}); // true
-	* isPlainObject(Object.create(null)); // true
-	* isPlainObject(new Date()); // false
-	* isPlainObject(null); // false
-	* isPlainObject([]); // false
-	* ```
-	*/
-	function isPlainObject(value) {
-		if (!isObject(value)) return false;
-		const prototype = Object.getPrototypeOf(value);
-		return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
-	}
-	/**
-	* Reads a property from a union-typed object where the key may exist only on some members of the union.
-	*
-	* `K` is constrained to keys of the union's intersection, so any key present on at least one union
-	* member is accepted. The return type resolves to `T[K]` when `K` is a key of `T`, otherwise `undefined`
-	* — matching the runtime behavior of reading a missing property.
-	*
-	* @param obj - source object (may be a union of shapes)
-	* @param prop - property name, must be a key of at least one union member
-	* @returns the property value if present, otherwise `undefined`
-	*/
-	function getField(obj, prop) {
-		return obj[prop];
-	}
 	//#endregion
 	//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.2/node_modules/@milaboratories/helpers/dist/error.js
 	function throwError(v) {
@@ -5600,22 +5562,6 @@
 	}
 	createGetIncrementalId();
 	//#endregion
-	//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.41.2/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/discovered_column.js
-	function distillDiscoveredPColumn(props) {
-		return {
-			column: props.column,
-			path: Array.isArray(props.path) && props.path.length > 0 ? props.path : void 0,
-			columnQualifications: Array.isArray(props.columnQualifications) && props.columnQualifications.length > 0 ? props.columnQualifications : void 0,
-			queriesQualifications: props.queriesQualifications && Object.keys(props.queriesQualifications).length > 0 ? props.queriesQualifications : void 0
-		};
-	}
-	function createDiscoveredPColumnId(props) {
-		return stringifyDiscoveredPColumnId(props);
-	}
-	function stringifyDiscoveredPColumnId(id) {
-		return canonicalizeJson(distillDiscoveredPColumn(id));
-	}
-	//#endregion
 	//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.41.2/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) */
@@ -5849,47 +5795,6 @@
 		} : voe;
 	}
 	//#endregion
-	//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.41.2/node_modules/@milaboratories/pl-model-common/dist/resource_types.js
-	/** Well-known resource type names used across the platform. */
-	const ResourceTypeName = {
-		StreamManager: "StreamManager",
-		StdMap: "StdMap",
-		StdMapSlash: "std/map",
-		EphStdMap: "EphStdMap",
-		PFrame: "PFrame",
-		ParquetChunk: "ParquetChunk",
-		BContext: "BContext",
-		BlockPackCustom: "BlockPackCustom",
-		BinaryMap: "BinaryMap",
-		BinaryValue: "BinaryValue",
-		BlobMap: "BlobMap",
-		BResolveSingle: "BResolveSingle",
-		BResolveSingleNoResult: "BResolveSingleNoResult",
-		BQueryResult: "BQueryResult",
-		TengoTemplate: "TengoTemplate",
-		TengoLib: "TengoLib",
-		SoftwareInfo: "SoftwareInfo",
-		Dummy: "Dummy",
-		JsonResourceError: "json/resourceError",
-		JsonObject: "json/object",
-		JsonGzObject: "json-gz/object",
-		JsonString: "json/string",
-		JsonArray: "json/array",
-		JsonNumber: "json/number",
-		BContextEnd: "BContextEnd",
-		FrontendFromUrl: "Frontend/FromUrl",
-		FrontendFromFolder: "Frontend/FromFolder",
-		BObjectSpec: "BObjectSpec",
-		Blob: "Blob",
-		Null: "Null",
-		Binary: "binary",
-		LSProvider: "LSProvider",
-		WorkingDirectory: "WorkingDirectory",
-		UserProject: "UserProject",
-		Projects: "Projects",
-		ClientRoot: "ClientRoot"
-	};
-	//#endregion
 	//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.41.2/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 } = (() => {
@@ -6286,13 +6191,9 @@
 		}
 	}
 	//#endregion
-	//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/function/flow.mjs
-	function flow(...funcs) {
-		return function(...args) {
-			let result = funcs.length ? funcs[0].apply(this, args) : args[0];
-			for (let i = 1; i < funcs.length; i++) result = funcs[i].call(this, result);
-			return result;
-		};
+	//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/function/identity.mjs
+	function identity(x) {
+		return x;
 	}
 	//#endregion
 	//#region ../node_modules/.pnpm/es-toolkit@1.42.0/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
@@ -6386,7 +6287,7 @@
 			qualifications: entry.qualifications
 		};
 	}
-	function formatQualification$1(q) {
+	function formatQualification(q) {
 		const ctx = q.contextDomain ?? {};
 		const keys = Object.keys(ctx);
 		if (keys.length === 0) return q.axis.name;
@@ -6394,7 +6295,7 @@
 		return Object.prototype.hasOwnProperty.call(ctx, q.axis.name) ? pairs : `${q.axis.name} ${pairs}`;
 	}
 	function formatQualifications(qs) {
-		return qs.map(formatQualification$1).join("; ");
+		return qs.map(formatQualification).join("; ");
 	}
 	function computeStepLabel(step, stepIndex, formatters) {
 		const base = (readAnnotation(step.spec, Annotation.LinkLabel) ?? readAnnotation(step.spec, Annotation.Label))?.trim();
@@ -6871,7 +6772,7 @@
 	/**
 	* A simple implementation of {@link ColumnProvider} backed by a pre-defined array of columns.
 	*/
-	var ArrayColumnProvider$1 = class {
+	var ArrayColumnProvider = class {
 		constructor(columns) {
 			this.columns = columns;
 		}
@@ -6922,7 +6823,7 @@
 	}
 	var PColumnCollection = class {
 		defaultProviderStore = [];
-		providers = [new ArrayColumnProvider$1(this.defaultProviderStore)];
+		providers = [new ArrayColumnProvider(this.defaultProviderStore)];
 		axisLabelProviders = [];
 		constructor() {}
 		addColumnProvider(provider) {
@@ -8170,471 +8071,196 @@
 		}
 	};
 	//#endregion
-	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/columns/column_selector.js
-	function normalizeStringMatchers(input) {
-		if (typeof input === "string") return [{
-			type: "regex",
-			value: input
-		}];
-		if (!Array.isArray(input)) return [input];
-		return input.map((v) => typeof v === "string" ? {
-			type: "regex",
-			value: v
-		} : v);
-	}
-	function normalizeRecord(input) {
-		const result = {};
-		for (const [key, value] of Object.entries(input)) result[key] = normalizeStringMatchers(value);
-		return result;
-	}
-	function normalizeTypes(input) {
-		return Array.isArray(input) ? input : [input];
-	}
-	function convertRelaxedAxisSelectorToMultiAxisSelector(input) {
-		const result = {};
-		if (input.name !== void 0) result.name = normalizeStringMatchers(input.name);
-		if (input.type !== void 0) result.type = normalizeTypes(input.type);
-		if (input.domain !== void 0) result.domain = normalizeRecord(input.domain);
-		if (input.contextDomain !== void 0) result.contextDomain = normalizeRecord(input.contextDomain);
-		if (input.annotations !== void 0) result.annotations = normalizeRecord(input.annotations);
+	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/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();
+		domains?.forEach((domain) => {
+			if (domain) for (const [k, v] of Object.entries(domain)) {
+				wid += k;
+				wid += v;
+			}
+		});
+		contextDomains?.forEach((contextDomain) => {
+			if (contextDomain) for (const [k, v] of Object.entries(contextDomain)) {
+				wid += k;
+				wid += v;
+			}
+		});
+		return wid;
+	};
+	/** All combinations with 1 key from each list */
+	function getKeysCombinations(idsLists) {
+		if (!idsLists.length) return [];
+		let result = [[]];
+		idsLists.forEach((list) => {
+			const nextResult = [];
+			list.forEach((key) => {
+				nextResult.push(...result.map((resultItem) => [...resultItem, key]));
+			});
+			result = nextResult;
+		});
 		return result;
 	}
-	function convertRelaxedColumnSelectorToMultiColumnSelector(input) {
-		const result = {};
-		if (input.name !== void 0) result.name = normalizeStringMatchers(input.name);
-		if (input.type !== void 0) result.type = normalizeTypes(input.type);
-		if (input.domain !== void 0) result.domain = normalizeRecord(input.domain);
-		if (input.contextDomain !== void 0) result.contextDomain = normalizeRecord(input.contextDomain);
-		if (input.annotations !== void 0) result.annotations = normalizeRecord(input.annotations);
-		if (input.axes !== void 0) result.axes = input.axes.map(convertRelaxedAxisSelectorToMultiAxisSelector);
-		if (input.partialAxesMatch !== void 0) result.partialAxesMatch = input.partialAxesMatch;
-		return result;
+	function getAvailableWithLinkersAxes(linkerColumns, blockAxes) {
+		const availableAxes = LinkerMap.fromColumns(linkerColumns.map(getColumnIdAndSpec)).getReachableByLinkersAxesFromAxesNormalized([...blockAxes.values()], (linkerKeyId, sourceAxisId) => matchAxisId(sourceAxisId, linkerKeyId));
+		return new Map(availableAxes.map((axisSpec) => {
+			return [canonicalizeJson(getAxisId(axisSpec)), axisSpec];
+		}));
 	}
-	function convertColumnSelectorToMultiColumnSelector(input) {
-		return (Array.isArray(input) ? input : [input]).map(convertRelaxedColumnSelectorToMultiColumnSelector);
+	/** Add columns with fully compatible axes created from partial compatible ones */
+	function enrichCompatible(blockAxes, columns) {
+		return columns.flatMap((column) => getAdditionalColumnsForColumn(blockAxes, column));
 	}
-	//#endregion
-	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/columns/column_snapshot_provider.js
-	/**
-	* Simple provider wrapping an array of PColumns.
-	* Always complete, data status always 'ready'.
-	*/
-	var ArrayColumnProvider = class {
-		columns;
-		constructor(columns) {
-			this.columns = columns.map((col) => ({
-				id: col.id,
-				spec: col.spec,
-				data: { get: () => col.data },
-				dataStatus: this.getStatus(col.data)
-			}));
-		}
-		getAllColumns() {
-			return this.columns;
-		}
-		isColumnListComplete() {
-			return true;
-		}
-		getStatus(d) {
-			if (d == null) return "absent";
-			if (typeof d === "function") return this.getStatus(d());
-			if (d instanceof TreeNodeAccessor) {
-				if (d.getIsReadyOrError()) return "ready";
-				if (d.getIsFinal()) return "absent";
-				return "computing";
-			}
-			if (isDataInfo(d)) {
-				let ready = true;
-				let final = true;
-				visitDataInfo(d, (v) => {
-					ready &&= v.getIsReadyOrError();
-					final &&= v.getIsFinal();
+	function getAdditionalColumnsForColumn(blockAxes, column) {
+		const columnAxesIds = column.spec.axesSpec.map(getAxisId);
+		if (columnAxesIds.every((id) => blockAxes.has(canonicalizeJson(id)))) return [column];
+		const secondaryIdsVariants = getKeysCombinations(columnAxesIds.map((id) => {
+			const result = [];
+			for (const [_, mainId] of blockAxes) if (matchAxisId(mainId, id) && !matchAxisId(id, mainId)) result.push(mainId);
+			return result;
+		}));
+		const allAddedDomainValues = /* @__PURE__ */ new Set();
+		const addedNotToAllVariantsDomainValues = /* @__PURE__ */ new Set();
+		const addedByVariantsDomainValues = secondaryIdsVariants.map((idsList) => {
+			const addedSet = /* @__PURE__ */ new Set();
+			idsList.map((axisId, idx) => {
+				const d1 = column.spec.axesSpec[idx].domain;
+				const d2 = axisId.domain;
+				Object.entries(d2 ?? {}).forEach(([key, value]) => {
+					if (d1?.[key] === void 0) {
+						const item = JSON.stringify([key, value]);
+						addedSet.add(item);
+						allAddedDomainValues.add(item);
+					}
+				});
+				const cd1 = column.spec.axesSpec[idx].contextDomain;
+				const cd2 = axisId.contextDomain;
+				Object.entries(cd2 ?? {}).forEach(([key, value]) => {
+					if (cd1?.[key] === void 0) {
+						const item = JSON.stringify(["ctx:" + key, value]);
+						addedSet.add(item);
+						allAddedDomainValues.add(item);
+					}
 				});
-				if (ready) return "ready";
-				if (final) return "absent";
-				return "computing";
-			}
-			return "ready";
-		}
-	};
-	/**
-	* Provider wrapping an array of ColumnSnapshots.
-	* Always complete. Data status taken from each snapshot.
-	*/
-	var SnapshotColumnProvider = class {
-		constructor(snapshots) {
-			this.snapshots = snapshots;
-		}
-		getAllColumns() {
-			return this.snapshots;
-		}
-		isColumnListComplete() {
-			return true;
-		}
-	};
-	/**
-	* Provider wrapping a TreeNodeAccessor (output/prerun resolve result).
-	* Detects data status from accessor readiness state.
-	*/
-	var OutputColumnProvider = class {
-		constructor(accessor, opts) {
-			this.accessor = accessor;
-			this.opts = opts;
-		}
-		getAllColumns() {
-			return this.getColumns();
-		}
-		isColumnListComplete() {
-			return this.accessor.getInputsLocked();
-		}
-		getColumns() {
-			const pColumns = this.accessor.getPColumns();
-			if (pColumns === void 0) return [];
-			const isFinal = this.accessor.getIsFinal();
-			const allowAbsence = this.opts?.allowPermanentAbsence === true;
-			return pColumns.map((col) => {
-				const dataAccessor = col.data;
-				const isReady = dataAccessor.getIsReadyOrError();
-				let dataStatus;
-				if (isReady) dataStatus = "ready";
-				else if (allowAbsence && isFinal) dataStatus = "absent";
-				else dataStatus = "computing";
 				return {
-					id: col.id,
-					spec: col.spec,
-					dataStatus,
-					data: { get: () => isReady ? dataAccessor : void 0 }
+					...axisId,
+					annotations: column.spec.axesSpec[idx].annotations
 				};
 			});
-		}
-	};
-	/** Checks if a value is a ColumnSnapshotProvider (duck-typing). */
-	function isColumnSnapshotProvider(source) {
-		return typeof source === "object" && source !== null && "getAllColumns" in source && "isColumnListComplete" in source && typeof source.getAllColumns === "function" && typeof source.isColumnListComplete === "function";
-	}
-	/** Checks if a value looks like a PColumn (has id, spec, data). */
-	function isPColumnArray(source) {
-		if (!Array.isArray(source)) return false;
-		if (source.length === 0) return true;
-		const first = source[0];
-		return "id" in first && "spec" in first && "data" in first && !("dataStatus" in first);
-	}
-	/** Checks if a value looks like a ColumnSnapshot array. */
-	function isColumnSnapshotArray(source) {
-		if (!Array.isArray(source)) return false;
-		if (source.length === 0) return true;
-		const first = source[0];
-		return "id" in first && "spec" in first && "dataStatus" in first;
-	}
-	/**
-	* Normalize any ColumnSource into a ColumnSnapshotProvider.
-	* - ColumnSnapshotProvider → returned as-is
-	* - ColumnSnapshot<PObjectId>[] → wrapped in SnapshotColumnProvider
-	* - PColumn[] → wrapped in ArrayColumnProvider
-	*/
-	function toColumnSnapshotProvider(source) {
-		if (isColumnSnapshotProvider(source)) return source;
-		if (isColumnSnapshotArray(source)) return new SnapshotColumnProvider(source);
-		if (isPColumnArray(source)) return new ArrayColumnProvider(source);
-		throw new Error("Unknown ColumnSource type");
+			return addedSet;
+		});
+		[...allAddedDomainValues].forEach((addedPart) => {
+			if (addedByVariantsDomainValues.some((s) => !s.has(addedPart))) addedNotToAllVariantsDomainValues.add(addedPart);
+		});
+		return [column, ...secondaryIdsVariants.map((idsList, idx) => {
+			const id = colId(column.id, idsList.map((id) => id.domain), idsList.map((id) => id.contextDomain));
+			const label = readAnnotation(column.spec, Annotation.Label) ?? "";
+			const labelDomainPart = [...addedByVariantsDomainValues[idx]].filter((str) => addedNotToAllVariantsDomainValues.has(str)).sort().map((v) => JSON.parse(v)?.[1]).join(" / ");
+			const annotations = {
+				...column.spec.annotations,
+				[Annotation.Graph.IsVirtual]: stringifyJson(true)
+			};
+			if (label || labelDomainPart) annotations[Annotation.Label] = label && labelDomainPart ? label + " / " + labelDomainPart : label + labelDomainPart;
+			return {
+				...column,
+				id,
+				spec: {
+					...column.spec,
+					axesSpec: idsList.map((axisId, idx) => ({
+						...axisId,
+						annotations: column.spec.axesSpec[idx].annotations
+					})),
+					annotations
+				}
+			};
+		})];
 	}
 	//#endregion
-	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/columns/column_collection_builder.js
-	/**
-	* Mutable builder that accumulates column sources, then produces
-	* a ColumnCollection (plain) or AnchoredColumnCollection (with anchors).
-	*
-	* Each output lambda creates its own builder — a constraint of the
-	* computable framework where each output tracks its own dependencies.
-	*/
-	var ColumnCollectionBuilder = class {
-		providers = [];
-		constructor(specDriver = getService("pframeSpec")) {
-			this.specDriver = specDriver;
-		}
-		/**
-		* Register a column source. Sources added first take precedence for dedup.
-		* Does NOT accept undefined — if a source isn't available yet,
-		* the caller should return undefined from the output lambda.
-		*/
-		addSource(source) {
-			if (source instanceof TreeNodeAccessor) {
-				const columns = source.getPColumns();
-				if (columns) this.providers.push(new ArrayColumnProvider(columns));
-			} else this.providers.push(toColumnSnapshotProvider(source));
-			return this;
-		}
-		addSources(sources) {
-			for (const source of sources) this.addSource(source);
-			return this;
-		}
-		build(options) {
-			const allowPartial = options?.allowPartialColumnList === true;
-			if (!this.providers.every((p) => p.isColumnListComplete()) && !allowPartial) return void 0;
-			const columns = collectColumns(this.providers);
-			if (options !== void 0 && "anchors" in options) return new AnchoredColumnCollectionImpl(this.specDriver, {
-				anchors: options.anchors,
-				columns
-			});
-			else return new ColumnCollectionImpl(this.specDriver, { columns });
-		}
-	};
-	var ColumnCollectionImpl = class {
-		columns;
-		specFrameEntry;
-		constructor(specDriver, options) {
-			this.specDriver = specDriver;
-			this.columns = new Map(options.columns.map((col) => [col.id, col]));
-			this.specFrameEntry = this.specDriver.createSpecFrame(Object.fromEntries(options.columns.map((col) => [col.id, col.spec])));
-		}
-		dispose() {
-			this.specFrameEntry.unref();
-		}
-		[Symbol.dispose]() {
-			this.dispose();
-		}
-		findColumns(options) {
-			const includeColumns = options?.include ? toMultiColumnSelectors(options.include) : void 0;
-			const excludeColumns = options?.exclude ? toMultiColumnSelectors(options.exclude) : void 0;
-			return this.specDriver.discoverColumns(this.specFrameEntry.key, {
-				includeColumns,
-				excludeColumns,
-				axes: [],
-				maxHops: 0,
-				constraints: matchingModeToConstraints("enrichment")
-			}).hits.map((hit) => this.columns.get(hit.hit.columnId)).filter((col) => col !== void 0);
-		}
-	};
-	var AnchoredColumnCollectionImpl = class {
-		anchorsMap;
-		columnsMap;
-		specFrameEntry;
-		constructor(specDriver, options) {
-			this.specDriver = specDriver;
-			this.specFrameEntry = this.specDriver.createSpecFrame(Object.fromEntries(options.columns.map((col) => [col.id, col.spec])));
-			this.columnsMap = new Map(options.columns.map((col) => [col.id, col]));
-			this.anchorsMap = resolveAnchorMap(options.anchors, options.columns, this.specDriver.discoverColumns.bind(this.specDriver, this.specFrameEntry.key));
-		}
-		dispose() {
-			this.specFrameEntry.unref();
-		}
-		[Symbol.dispose]() {
-			this.dispose();
-		}
-		getAnchors() {
-			return this.anchorsMap;
-		}
-		findColumns(options) {
-			const constraints = matchingModeToConstraints(options?.mode ?? "enrichment");
-			const includeColumns = options?.include ? toMultiColumnSelectors(options.include) : void 0;
-			const excludeColumns = options?.exclude ? toMultiColumnSelectors(options.exclude) : void 0;
-			const anchors = Array.from(this.anchorsMap.values());
-			const byColumn = this.specDriver.discoverColumns(this.specFrameEntry.key, {
-				includeColumns,
-				excludeColumns,
-				constraints,
-				maxHops: options?.maxHops ?? 4,
-				axes: anchors.map((anchor) => ({
-					axesSpec: anchor.spec.axesSpec,
-					qualifications: []
-				}))
-			}).hits.reduce((acc, hit) => {
-				const origId = hit.hit.columnId;
-				const col = this.columnsMap.get(origId) ?? throwError(`Column with id ${origId} not found in collection`);
-				const path = hit.path.map((step) => {
-					if (step.type !== "linker") throw new Error(`Unexpected discover-columns step type: ${step.type}`);
-					return { linker: this.columnsMap.get(step.linker.columnId) ?? throwError(`Linker column with id ${step.linker.columnId} not found in collection`) };
-				});
-				const variants = hit.mappingVariants.map((v) => ({
-					path,
-					qualifications: remapFromIdxToId(v.qualifications, anchors)
-				}));
-				const existing = acc.get(origId);
-				return acc.set(origId, existing === void 0 ? {
-					column: col,
-					variants
-				} : {
-					...existing,
-					variants: [...existing.variants, ...variants]
-				});
-			}, /* @__PURE__ */ new Map());
-			return Array.from(byColumn.values());
-		}
-		findColumnVariants(options) {
-			return this.findColumns(options).flatMap((match) => match.variants.map((variant) => ({
-				column: match.column,
-				path: variant.path,
-				qualifications: variant.qualifications
-			})));
-		}
-	};
-	/**
-	* Collect all columns from all providers, dedup by NativePObjectId.
-	* First source wins.
-	*/
-	function collectColumns(providers) {
-		const seen = /* @__PURE__ */ new Set();
-		const result = [];
-		for (const provider of providers) {
-			const columns = provider.getAllColumns();
-			for (const col of columns) {
-				const nativeId = deriveNativeId(col.spec);
-				if (seen.has(nativeId)) continue;
-				seen.add(nativeId);
-				result.push(col);
-			}
-		}
-		return result;
-	}
-	/** Normalize ColumnSelector (relaxed, single or array) to MultiColumnSelector[]. */
-	function toMultiColumnSelectors(input) {
-		return convertColumnSelectorToMultiColumnSelector(input);
-	}
-	/**
-	* Resolve each anchor entry to a ColumnSnapshot from the collected columns.
-	* - PObjectId (string): looked up by id in the collected columns
-	* - PColumnSpec: matched by deriveNativeId against collected columns
-	* - RelaxedColumnSelector: resolved via discoverColumns in "exact" mode;
-	*   must match exactly one column
-	* Throws on unresolved, ambiguous, or duplicated matches. Requires at least one
-	* anchor to resolve.
-	*/
-	function resolveAnchorMap(anchors, columns, discoverColumns) {
-		const result = /* @__PURE__ */ new Map();
-		const resovedIds = /* @__PURE__ */ new Set();
-		const getDuplicateError = (key) => `Anchor "${key}": selector matched a column that was already matched by another anchor; please refine the selector to match a different column`;
-		for (const [name, anchor] of Object.entries(anchors)) if (typeof anchor === "string") {
-			const found = columns.find((col) => col.id === anchor) ?? throwError(`Anchor "${name}": column with id "${anchor}" not found in sources`);
-			if (resovedIds.has(found.id)) throwError(getDuplicateError(name));
-			result.set(name, found);
-			resovedIds.add(found.id);
-		} else if ("kind" in anchor) {
-			if (!isPColumnSpec(anchor)) throwError(`Anchor "${name}": invalid PColumnSpec`);
-			const nativeId = deriveNativeId(anchor);
-			const found = columns.find((col) => deriveNativeId(col.spec) === nativeId) ?? throwError(`Anchor "${name}": no column matching spec found in sources`);
-			if (resovedIds.has(found.id)) throwError(getDuplicateError(name));
-			result.set(name, found);
-			resovedIds.add(found.id);
-		} else {
-			const matched = discoverColumns({
-				includeColumns: toMultiColumnSelectors(anchor),
-				excludeColumns: void 0,
-				axes: [],
-				maxHops: 0,
-				constraints: matchingModeToConstraints("related")
-			});
-			if (matched.hits.length === 0) throwError(`Anchor "${name}": no columns matched selector`);
-			if (matched.hits.length > 1) throwError(`Anchor "${name}": selector is ambiguous and matched multiple columns; please refine the selector to match exactly one column`);
-			if (resovedIds.has(matched.hits[0].hit.columnId)) throwError(getDuplicateError(name));
-			const id = matched.hits[0].hit.columnId;
-			const snap = columns.find((col) => col.id === id) ?? throwError(`Anchor "${name}": matched column with id "${id}" not found in sources`);
-			result.set(name, snap);
-			resovedIds.add(snap.id);
-		}
-		if (resovedIds.size === 0) throwError("At least one anchor must be resolved to a valid column");
-		return result;
-	}
-	function remapFromIdxToId(qualifications, anchors) {
-		const forQueries = qualifications.forQueries.reduce((acc, qs, i) => anchors[i] && qs.length > 0 ? acc.set(anchors[i].id, qs) : acc, /* @__PURE__ */ new Map());
-		return {
-			forQueries: forQueries.size > 0 ? Object.fromEntries(forQueries) : void 0,
-			forHit: qualifications.forHit.length > 0 ? qualifications.forHit : void 0
-		};
-	}
-	function matchingModeToConstraints(mode) {
-		switch (mode) {
-			case "enrichment": return {
-				allowFloatingSourceAxes: true,
-				allowFloatingHitAxes: false,
-				allowSourceQualifications: true,
-				allowHitQualifications: true
-			};
-			case "related": return {
-				allowFloatingSourceAxes: true,
-				allowFloatingHitAxes: true,
-				allowSourceQualifications: true,
-				allowHitQualifications: true
-			};
-			case "exact": return {
-				allowFloatingSourceAxes: false,
-				allowFloatingHitAxes: false,
-				allowSourceQualifications: false,
-				allowHitQualifications: false
-			};
-		}
+	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/pframe_utils/columns.js
+	function getAllRelatedColumns(ctx, predicate) {
+		const columns = new PColumnCollection();
+		columns.addColumnProvider(ctx.resultPool);
+		const allColumns = columns.getColumns(predicate, {
+			dontWaitAllData: true,
+			overrideLabelAnnotation: false
+		}) ?? [];
+		return enrichCompatible(new Map(allColumns.flatMap((column) => getNormalizedAxesList(column.spec.axesSpec)).map((axisSpec) => {
+			return [canonicalizeJson(getAxisId(axisSpec)), axisSpec];
+		})), allColumns);
+	}
+	function getRelatedColumns(ctx, { columns: rootColumns, predicate }) {
+		const columns = new PColumnCollection();
+		columns.addColumnProvider(ctx.resultPool);
+		columns.addColumns(rootColumns);
+		const blockAxes = /* @__PURE__ */ new Map();
+		const allAxes = /* @__PURE__ */ new Map();
+		for (const c of rootColumns) for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
+			const aid = getAxisId(spec);
+			blockAxes.set(canonicalizeJson(aid), spec);
+			allAxes.set(canonicalizeJson(aid), spec);
+		}
+		const availableWithLinkersAxes = getAvailableWithLinkersAxes(columns.getColumns((spec) => predicate(spec) && isLinkerColumn(spec), { dontWaitAllData: true }) ?? [], blockAxes);
+		for (const item of availableWithLinkersAxes) {
+			blockAxes.set(...item);
+			allAxes.set(...item);
+		}
+		const blockAxesArr = Array.from(blockAxes.values());
+		let compatibleWithoutLabels = (columns.getColumns((spec) => predicate(spec) && spec.axesSpec.some((axisSpec) => {
+			const axisId = getAxisId(axisSpec);
+			return blockAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+		}), {
+			dontWaitAllData: true,
+			overrideLabelAnnotation: false
+		}) ?? []).filter((column) => !isLabelColumn(column.spec));
+		for (const c of compatibleWithoutLabels) for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
+			const aid = getAxisId(spec);
+			allAxes.set(canonicalizeJson(aid), spec);
+		}
+		const allAxesArr = Array.from(allAxes.values());
+		compatibleWithoutLabels = (columns.getColumns((spec) => predicate(spec) && spec.axesSpec.every((axisSpec) => {
+			const axisId = getAxisId(axisSpec);
+			return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+		}), {
+			dontWaitAllData: true,
+			overrideLabelAnnotation: false
+		}) ?? []).filter((column) => !isLabelColumn(column.spec));
+		const compatibleLabels = (columns.getColumns((spec) => predicate(spec) && spec.axesSpec.some((axisSpec) => {
+			const axisId = getAxisId(axisSpec);
+			return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+		}), {
+			dontWaitAllData: true,
+			overrideLabelAnnotation: false
+		}) ?? []).filter((column) => isLabelColumn(column.spec));
+		return enrichCompatible(blockAxes, [...compatibleWithoutLabels, ...compatibleLabels]);
 	}
 	//#endregion
-	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/columns/ctx_column_sources.js
-	/**
-	* Collect ColumnSnapshotProviders from `outputs`, `prerun`, and
-	* `resultPool` in that order. Dedup keeps the first occurrence per
-	* `NativePObjectId`, so a block re-publishing its own columns keeps
-	* the `outputs`-rooted canonical id instead of the result-pool variant.
-	*/
-	function collectCtxColumnSnapshotProviders(ctx) {
-		const providers = [];
-		const outputs = ctx.outputs;
-		if (outputs) providers.push(...collectPFrameProviders(outputs));
-		const prerun = ctx.prerun;
-		if (prerun) providers.push(...collectPFrameProviders(prerun));
-		providers.push(new ResultPoolColumnSnapshotProvider(ctx.resultPool));
-		return providers;
+	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/components/PFrameForGraphs.js
+	function isHiddenFromGraphColumn(column) {
+		return !!readAnnotationJson(column, Annotation.HideDataFromGraphs);
 	}
-	/**
-	* Adapter wrapping ResultPool into the new ColumnSnapshotProvider interface.
-	*
-	* - `isColumnListComplete()` always returns true — the result pool
-	*   is a stable snapshot within a single render cycle.
-	* - Data status is derived from the underlying TreeNodeAccessor:
-	*   ready (getIsReadyOrError), computing, or absent (no data resource).
-	*/
-	var ResultPoolColumnSnapshotProvider = class {
-		constructor(pool) {
-			this.pool = pool;
-		}
-		getAllColumns() {
-			return this.pool.selectColumns(() => true).map((col) => toSnapshot(col.id, col.spec, col.data));
-		}
-		isColumnListComplete() {
-			return true;
-		}
-	};
-	function toSnapshot(id, spec, accessor) {
-		if (accessor === void 0) return {
-			id,
-			spec,
-			dataStatus: "absent",
-			data: void 0
-		};
-		const isReady = accessor.getIsReadyOrError();
-		return {
-			id,
-			spec,
-			dataStatus: isReady ? "ready" : "computing",
-			data: { get: () => isReady ? accessor : void 0 }
-		};
+	function isHiddenFromUIColumn(column) {
+		return !!readAnnotationJson(column, Annotation.HideDataFromUi);
 	}
 	/**
-	* Recursively walk the output tree starting from `accessor`.
-	* - If a node's resourceType is PFrame → wrap it as OutputColumnProvider.
-	* - If a node's resourceType is StdMap/std/map → recurse into its output fields.
-	* - Otherwise → skip (leaf of unknown type).
+	The aim of createPFrameForGraphs: to create pframe with block’s columns and all compatible columns from result pool
+	(including linker columns and all label columns).
+	Block’s columns are added to pframe as is.
+	Other columns are added basing on set of axes of block’s columns, considering available with linker columns.
+	Compatible columns must have at least one axis from block’s axes set. This axis of the compatible column from
+	result pool must satisfy matchAxisId (it can have less domain keys than in block’s axis, but without conflicting values
+	among existing ones).
+	In requests to pframe (calculateTableData) columns must have strictly the same axes. For compatibility in case
+	of partially matched axis we add to pframe a copy of this column with modified axis (with filled missed domains)
+	and modified label (with added domain values in case if more than one copy with different domains exist).
 	*/
-	function collectPFrameProviders(accessor) {
-		const out = [];
-		walkTree(accessor, out);
-		return out;
-	}
-	function walkTree(node, out) {
-		const typeName = node.resourceType.name;
-		if (typeName === ResourceTypeName.PFrame) {
-			out.push(new OutputColumnProvider(node));
-			return;
-		}
-		if (typeName === ResourceTypeName.StdMap || typeName === ResourceTypeName.StdMapSlash) for (const field of node.listInputFields()) {
-			const child = node.resolve(field);
-			if (child) walkTree(child, out);
-		}
+	function createPFrameForGraphs(ctx, blockColumns) {
+		const suitableSpec = (spec) => !isHiddenFromUIColumn(spec) && !isHiddenFromGraphColumn(spec);
+		if (!blockColumns) return ctx.createPFrame(getAllRelatedColumns(ctx, suitableSpec));
+		return ctx.createPFrame(getRelatedColumns(ctx, {
+			columns: blockColumns,
+			predicate: suitableSpec
+		}));
 	}
 	//#endregion
 	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/filters/traverse.js
@@ -9325,283 +8951,64 @@
 		};
 	}
 	//#endregion
-	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/labels/derive_distinct_tooltips.js
-	/** Format tooltip strings for each entry. Returns `undefined` when nothing useful. */
-	function deriveDistinctTooltips(entries) {
-		return entries.map(formatTooltip);
-	}
-	function formatTooltip(entry) {
-		const sections = [];
-		const header = formatHeader(entry);
-		if (header !== void 0) sections.push(header);
-		const origin = formatOriginPath(entry);
-		if (origin !== void 0) sections.push(origin);
-		const anchors = formatAnchors(entry.qualifications);
-		if (anchors !== void 0) sections.push(anchors);
-		const hit = formatHit(entry.qualifications);
-		if (hit !== void 0) sections.push(hit);
-		if (sections.length <= 1) return void 0;
-		return sections.join("\n\n");
-	}
-	const BULLET_1 = "  • ";
-	function formatHeader(entry) {
-		const lines = [];
-		if (entry.variantCount !== void 0 && entry.variantCount > 1) lines.push(`Variant: ${entry.variantIndex ?? "?"} of ${entry.variantCount}`);
-		return lines.join("\n");
-	}
-	function formatOriginPath(entry) {
-		const path = entry.linkerPath ?? [];
-		if (path.length === 0) return void 0;
-		const lines = ["Origin path"];
-		path.forEach((step, i) => {
-			const label = readAnnotation(step.linker.spec, Annotation.LinkLabel) ?? readAnnotation(step.linker.spec, Annotation.Label) ?? step.linker.spec.name;
-			lines.push(`${BULLET_1}linker ${i + 1}: ${label}`);
-		});
-		const hitName = readAnnotation(entry.spec, Annotation.Label) ?? entry.spec.name;
-		lines.push(`${BULLET_1}hit column: ${hitName}`);
-		return lines.join("\n");
-	}
-	function formatAnchors(q) {
-		if (isNil(q)) return void 0;
-		if (isNil(q.forQueries)) return void 0;
-		const ids = Object.keys(q.forQueries);
-		if (ids.length === 0) return void 0;
-		const lines = [];
-		for (const id of ids) {
-			const item = q.forQueries[id];
-			if (item.length === 0) continue;
-			const rendered = formatAxisQualifications(item);
-			lines.push(`${BULLET_1}${id}${rendered !== void 0 ? `   ${rendered}` : ""}`);
-		}
-		return lines.length > 0 ? ["Anchors (bound via this variant)"].concat(lines).join("\n") : void 0;
-	}
-	function formatHit(q) {
-		if (isNil(q) || isNil(q.forHit) || q.forHit.length === 0) return void 0;
-		const rendered = formatAxisQualifications(q.forHit);
-		if (rendered === void 0) return void 0;
-		return ["Hit column qualifications", `${BULLET_1}${rendered}`].join("\n");
-	}
-	function formatAxisQualifications(qs) {
-		if (qs.length === 0) return void 0;
-		return qs.map(formatQualification).join("; ");
-	}
-	function formatQualification(q) {
-		const axisName = typeof q.axis === "string" ? q.axis : q.axis.name ?? JSON.stringify(q.axis);
-		const entries = Object.entries(q.contextDomain);
-		if (entries.length === 0) return axisName;
-		return `${axisName} context: ${entries.map(([k, v]) => `${k}=${v}`).join(", ")}`;
-	}
-	//#endregion
 	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/utils.js
-	/** 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 `PFrameSpecDriver.discoverColumns`
-	* using the same engine as `ColumnCollection.findColumns` — no client-side matcher.
-	*/
-	function evaluateRules(rules, columns, pframeSpec) {
-		const result = /* @__PURE__ */ new Map();
-		if (rules.length === 0 || columns.length === 0) return result;
-		const hasSelectorRules = rules.some((rule) => typeof rule.match !== "function");
-		const selectorHitsByRule = /* @__PURE__ */ new Map();
-		if (hasSelectorRules) {
-			const pColumns = dedupeById(columns).map((c) => ({
-				id: c.id,
-				spec: c.spec,
-				data: void 0
-			}));
-			const collection = new ColumnCollectionBuilder(pframeSpec).addSource(new ArrayColumnProvider(pColumns)).build();
-			if (collection === void 0) return result;
-			try {
-				for (const rule of rules) {
-					if (typeof rule.match === "function") continue;
-					const hits = collection.findColumns({ include: rule.match });
-					selectorHitsByRule.set(rule, new Set(hits.map((h) => h.id)));
-				}
-			} finally {
-				collection.dispose();
+	//#endregion
+	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/components/PlDataTable/labels.js
+	/** Get label columns matching the provided columns from the result pool */
+	function getMatchingLabelColumns(columns, allLabelColumns) {
+		const inputLabelColumns = [];
+		const inputValueColumns = [];
+		for (const column of columns) if (isLabelColumn(column.spec)) inputLabelColumns.push(column);
+		else inputValueColumns.push(column);
+		const unlabeledAxes = [];
+		for (const column of inputValueColumns) for (const axis of column.spec.axesSpec) {
+			const axisId = getAxisId(axis);
+			if (!unlabeledAxes.some((id) => matchAxisId(id, axisId))) unlabeledAxes.push(axisId);
+		}
+		for (const labelColumn of inputLabelColumns) {
+			const labelAxisId = getAxisId(labelColumn.spec.axesSpec[0]);
+			const labelMatch = unlabeledAxes.findIndex((axisId) => matchAxisId(axisId, labelAxisId));
+			if (labelMatch !== -1) unlabeledAxes.splice(labelMatch, 1);
+		}
+		const colId = (id, domain, contextDomain) => {
+			let wid = id.toString();
+			if (domain) for (const k in domain) {
+				wid += k;
+				wid += domain[k];
+			}
+			if (contextDomain) for (const k in contextDomain) {
+				wid += k;
+				wid += contextDomain[k];
+			}
+			return wid;
+		};
+		const labelColumns = [];
+		for (const labelColumn of allLabelColumns) {
+			const labelAxis = labelColumn.spec.axesSpec[0];
+			const labelAxisId = getAxisId(labelAxis);
+			const labelMatch = unlabeledAxes.findIndex((axisId) => matchAxisId(axisId, labelAxisId));
+			if (labelMatch !== -1) {
+				const axisId = unlabeledAxes[labelMatch];
+				if (Object.keys(axisId.domain ?? {}).length + Object.keys(axisId.contextDomain ?? {}).length > Object.keys(labelAxis.domain ?? {}).length + Object.keys(labelAxis.contextDomain ?? {}).length) labelColumns.push({
+					id: colId(labelColumn.id, axisId.domain, axisId.contextDomain),
+					spec: {
+						...labelColumn.spec,
+						axesSpec: [{
+							...axisId,
+							annotations: labelAxis.annotations
+						}]
+					},
+					data: labelColumn.data
+				});
+				else labelColumns.push(labelColumn);
+				unlabeledAxes.splice(labelMatch, 1);
 			}
 		}
-		for (const col of columns) for (const rule of rules) if (typeof rule.match === "function" ? rule.match(col.spec) : selectorHitsByRule.get(rule)?.has(col.id) ?? false) {
-			result.set(col.id, rule);
-			break;
-		}
-		return result;
-	}
-	function dedupeById(columns) {
-		const seen = /* @__PURE__ */ new Set();
-		const result = [];
-		for (const col of columns) {
-			if (seen.has(col.id)) continue;
-			seen.add(col.id);
-			result.push(col);
-		}
-		return result;
-	}
-	/**
-	* Writes derived labels into column and axis annotations.
-	* Returns new column objects with modified specs — original columns are not mutated.
-	*
-	* For each column: writes derived label into Annotation.Label (if present in derivedLabels).
-	* For each axis in column specs: writes derived axis label into AxisSpec annotations.
-	*/
-	function withLabelAnnotations(derivedLabels, columns) {
-		if (derivedLabels === void 0) return columns;
-		return columns.map((col) => {
-			const colLabel = derivedLabels[col.id];
-			return {
-				...col,
-				spec: {
-					...col.spec,
-					...isNil(colLabel) ? {} : { annotations: {
-						...col.spec.annotations,
-						[Annotation.Label]: colLabel
-					} },
-					axesSpec: col.spec.axesSpec.map((axis) => {
-						const label = derivedLabels[canonicalizeAxisId(axis)];
-						return isNil(label) ? axis : {
-							...axis,
-							annotations: {
-								...axis.annotations,
-								[Annotation.Label]: label
-							}
-						};
-					})
-				}
-			};
-		});
-	}
-	function withDataStatusAnnotations(columns) {
-		return columns.map((col) => {
-			return {
-				...col,
-				spec: {
-					...col.spec,
-					annotations: {
-						...col.spec.annotations,
-						[Annotation.DataStatus]: col.dataStatus
-					}
-				}
-			};
-		});
-	}
-	/**
-	* Writes effective display properties (OrderPriority, Visibility) from precomputed rule maps
-	* into column annotations. Returns new column objects — originals are not mutated.
-	*/
-	function withTableVisualAnnotations(visibilityByColId, orderByColId, columns) {
-		if (visibilityByColId === void 0 && orderByColId === void 0) return columns;
-		return columns.map((col) => {
-			const annotations = { ...col.spec.annotations };
-			const visibility = getEffectiveVisibility(col, visibilityByColId);
-			if (!isNil(visibility)) annotations[Annotation.Table.Visibility] = visibility;
-			const orderPriority = getOrderPriority(col, orderByColId);
-			if (!isNil(orderPriority)) annotations[Annotation.Table.OrderPriority] = String(orderPriority);
-			return {
-				...col,
-				spec: {
-					...col.spec,
-					annotations
-				}
-			};
-		});
-	}
-	/**
-	* Writes derived info annotations into column annotations.
-	* Columns without an info entry are passed through unchanged.
-	*/
-	function withInfoAnnotations(infoById, columns) {
-		if (isNil(infoById)) return columns;
-		return columns.map((col) => {
-			const info = infoById[col.id];
-			if (isNil(info)) return col;
-			return {
-				...col,
-				spec: {
-					...col.spec,
-					annotations: {
-						...col.spec.annotations,
-						[Annotation.Table.Info]: info
-					}
-				}
-			};
-		});
-	}
-	function withHidenAxesAnnotations(columns) {
-		return columns.map((col) => ({
-			...col,
-			spec: {
-				...col.spec,
-				axesSpec: col.spec.axesSpec.map((axis) => ({
-					...axis,
-					annotations: {
-						...axis.annotations,
-						[Annotation.Table.Visibility]: "hidden"
-					}
-				}))
-			}
-		}));
-	}
-	/** 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), {});
-	}
-	/** Derive origin tooltips for columns whose qualifications or linker path carry info. */
-	function deriveAllTooltips(options) {
-		const { columns } = options;
-		const variantCountByOriginal = columns.reduce((acc, c) => {
-			return acc.set(getField(c, "originalId") ?? c.id, (acc.get(c.originalId ?? c.id) ?? 0) + 1);
-		}, /* @__PURE__ */ new Map());
-		const { entries } = columns.reduce(({ entries, variantSeen }, c) => {
-			const id = getField(c, "originalId") ?? c.id;
-			const variantCount = variantCountByOriginal.get(id);
-			const variantIndex = (variantSeen.set(id, (variantSeen.get(id) ?? 0) + 1), variantSeen.get(id));
-			entries.push({
-				spec: c.spec,
-				linkerPath: c.linkerPath,
-				qualifications: c.qualifications,
-				variantIndex,
-				variantCount
-			});
-			return {
-				entries,
-				variantSeen
-			};
-		}, {
-			entries: [],
-			variantSeen: /* @__PURE__ */ new Map()
-		});
-		const tooltips = deriveDistinctTooltips(entries);
-		return Object.fromEntries(tooltips.flatMap((t, i) => isNil(t) ? [] : [[columns[i].id, t]]));
+		return labelColumns;
 	}
 	//#endregion
 	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPTableDefV3.js
@@ -9675,387 +9082,126 @@
 		};
 	}
 	//#endregion
-	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/discoverColumns.js
-	/** Discover columns from sources/anchors and normalize into a flat TableColumnVariant list. */
-	function discoverTableColumnSnaphots(ctx, options) {
-		const resolvedOptions = {
-			...options,
-			anchors: resolveAnchors$1(ctx, options.anchors)
-		};
-		const providers = resolveProviders(ctx, resolvedOptions.sources);
-		if (providers.length === 0) return void 0;
-		const collection = new ColumnCollectionBuilder(ctx.getService("pframeSpec")).addSources(providers).build(resolvedOptions);
-		if (collection === void 0) return void 0;
-		try {
-			return mapToTableColumnVariants(collection.findColumnVariants(resolvedOptions.selector), collection.getAnchors());
-		} finally {
-			collection.dispose();
-		}
+	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPTableDefV2.js
+	function createPTableDefV2(params) {
+		let coreColumns = params.columns;
+		const secondaryColumns = [];
+		if (isFunction(params.coreColumnPredicate)) {
+			coreColumns = [];
+			for (const c of params.columns) if (params.coreColumnPredicate(getColumnIdAndSpec(c))) coreColumns.push(c);
+			else secondaryColumns.push(c);
+		}
+		secondaryColumns.push(...params.labelColumns);
+		return createPTableDefV3({
+			primary: coreColumns.map((column) => ({ column })),
+			secondary: secondaryColumns.map((column) => ({ entries: [{ column }] })),
+			primaryJoinType: params.coreJoinType,
+			filters: params.filters,
+			sorting: params.sorting
+		});
 	}
+	//#endregion
+	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPlDataTableV2.js
 	/**
-	* Discover label columns matching the axes of the given value columns from
-	* ctx providers. Returns label snapshots wrapped as direct TableColumnVariants
-	* (path: [], empty qualifications, isPrimary: false).
+	* Create p-table spec and handle given ui table state
+	*
+	* @deprecated This version of createPlDataTable is deprecated and will be removed in future. Please migrate to v3 by switching to the new options format and providing necessary information for column discovery and display configuration. See createPlDataTableOptionsV3 for details.
+	* @param ctx context
+	* @param columns column list
+	* @param tableState table ui state
+	* @returns PlAgDataTableV2 table source
 	*/
-	function discoverLabelColumnVariants(ctx, columns) {
-		if (columns.length === 0) return [];
-		const collection = new ColumnCollectionBuilder(ctx.getService("pframeSpec")).addSources(collectCtxColumnSnapshotProviders(ctx)).addSource(columns.map((c) => c.column)).build({
-			allowPartialColumnList: true,
-			anchors: Object.fromEntries(columns.filter((col) => (col.path?.length ?? 0) === 0 && col.isPrimary).map((col, i) => [`anchor_${i}`, col.column.spec]))
-		});
-		try {
-			const axes = columns.flatMap((col) => col.column.spec.axesSpec);
-			return collection.findColumnVariants({
-				include: axes.map((a) => ({
-					name: {
-						type: "exact",
-						value: PColumnName.Label
-					},
-					axes: [{ name: {
-						type: "exact",
-						value: a.name
-					} }]
-				})),
-				maxHops: columns.reduce((acc, c) => Math.max(acc, c.path?.length ?? 0), 0)
-			}).map((variant) => ({
-				...variant,
-				column: {
-					...variant.column,
-					id: createDiscoveredPColumnId({
-						column: variant.column.id,
-						path: variant.path?.map((p) => ({
-							type: "linker",
-							column: p.linker.id
-						})),
-						columnQualifications: variant.qualifications?.forHit,
-						queriesQualifications: variant.qualifications?.forQueries
-					}),
-					originalId: variant.column.id
-				}
-			}));
-		} finally {
-			collection.dispose();
-		}
-	}
-	/** Resolve PlRef values in anchors to PColumnSpec via the result pool. */
-	function resolveAnchors$1(ctx, anchors) {
-		const result = {};
-		for (const [key, value] of Object.entries(anchors)) if (isPlRef(value)) result[key] = ctx.resultPool.getPColumnSpecByRef(value) ?? throwError(`Anchor ${key} with ref ${JSON.stringify(value)} could not be resolved to a PColumnSpec`);
-		else result[key] = value;
-		return result;
-	}
-	/** Resolve column snapshot providers from explicit sources or context. */
-	function resolveProviders(ctx, sources) {
-		return sources !== void 0 ? sources.map(toColumnSnapshotProvider) : collectCtxColumnSnapshotProviders(ctx);
-	}
-	/** Map column variants into TableColumnVariant list with anchor-derived isPrimary flag. */
-	function mapToTableColumnVariants(variants, anchors) {
-		const columnIdToAnchorName = new Map(Array.from(anchors.entries(), ([key, { id }]) => [id, key]));
-		return variants.map((variant) => {
-			const snap = variant.column;
-			const isPrimary = columnIdToAnchorName.get(snap.id) !== void 0;
+	function createPlDataTableV2(ctx, columns, tableState, options) {
+		if (columns.length === 0) return void 0;
+		const tableStateNormalized = upgradePlDataTableStateV2(tableState);
+		const allLabelColumns = getAllLabelColumns(ctx.resultPool) ?? [];
+		let fullLabelColumns = getMatchingLabelColumns(columns, allLabelColumns);
+		fullLabelColumns = deriveLabels(fullLabelColumns, identity, { includeNativeLabel: true }).map((v) => {
 			return {
-				column: {
-					id: createDiscoveredPColumnId({
-						column: snap.id,
-						path: variant.path?.map((p) => ({
-							type: "linker",
-							column: p.linker.id
-						})),
-						columnQualifications: variant.qualifications?.forHit,
-						queriesQualifications: variant.qualifications?.forQueries
-					}),
-					spec: snap.spec,
-					data: snap.data,
-					dataStatus: snap.dataStatus
-				},
-				path: variant.path,
-				qualifications: variant.qualifications,
-				originalId: snap.id,
-				isPrimary
+				...v.value,
+				spec: {
+					...v.value.spec,
+					annotations: {
+						...v.value.spec.annotations,
+						[Annotation.Label]: v.label
+					}
+				}
 			};
 		});
-	}
-	//#endregion
-	//#region ../node_modules/.pnpm/@platforma-sdk+model@1.75.5/node_modules/@platforma-sdk/model/dist/components/PlDataTable/createPlDataTable/createPlDataTableV3.js
-	function createPlDataTableV3(ctx, options) {
-		const pframeSpec = ctx.getService("pframeSpec");
-		const state = upgradePlDataTableStateV2(options.tableState);
-		const primaryJoinType = options.primaryJoinType ?? "full";
-		const discovered = isPlainObject(options.columns) ? discoverTableColumnSnaphots(ctx, options.columns) : isNil$1(options.columns) ? options.columns : uniqueBy([...options.columns, ...discoverLabelColumnVariants(ctx, options.columns)], (c) => c.column.id);
-		if (isNil$1(discovered) || discovered.length === 0) return void 0;
-		const splited = splitDiscoveredColumns(discovered);
-		const derivedLabels = deriveAllLabels({
-			columns: discovered.map((dc) => ({
-				id: dc.column.id,
-				spec: dc.column.spec,
-				linkerPath: dc.path,
-				qualifications: dc.qualifications
-			})).filter((v) => !isColumnHidden(v.spec)),
-			deriveLabelsOptions: {
-				includeNativeLabel: true,
-				...options.labelsOptions
-			}
-		});
-		const derivedTooltips = deriveAllTooltips({ columns: discovered.map((dc) => ({
-			id: dc.column.id,
-			originalId: getField(dc, "originalId"),
-			spec: dc.column.spec,
-			linkerPath: dc.path,
-			qualifications: dc.qualifications
-		})) });
-		const annotated = annotateColumnGroups({
-			pframeSpec,
-			...splited,
-			derivedLabels,
-			derivedTooltips,
-			displayOptions: options.displayOptions
-		});
-		const primarySnapshots = annotated.direct.filter((c) => c.isPrimary);
-		const secondarySnapshots = annotated.direct.filter((c) => !c.isPrimary);
-		if (primarySnapshots.length === 0) return void 0;
-		const columnIsAvailable = createColumnValidationById([...annotated.direct.map((v) => v.column), ...annotated.linked.flatMap((lc) => [...(lc.path ?? []).map((s) => s.linker), lc.column])]);
-		const remapedDefaultFilters = remapFilterColumnIds(options.filters, discovered);
-		const filters = filterFilters(concatFilters(state.pTableParams.filters, state.pTableParams.defaultFilters ?? remapedDefaultFilters), columnIsAvailable);
-		const sorting = filterSorting(resolveSorting(state.pTableParams.sorting, remapSortingColumnIds(options.sorting, discovered)), columnIsAvailable);
-		const primaryEntries = primarySnapshots.map((v) => ({ column: resolveSnapshot(v.column) }));
-		const fullDef = createPTableDefV3({
-			primaryJoinType,
-			primary: primaryEntries,
-			secondary: buildSecondaryGroups(secondarySnapshots, annotated.linked),
+		const fullColumns = [...columns, ...fullLabelColumns];
+		const fullColumnsIds = [...uniqueBy(fullColumns.flatMap((c) => c.spec.axesSpec.map((a) => getAxisId(a))), (a) => canonicalizeJson(a)).map((a) => ({
+			type: "axis",
+			id: a
+		})), ...fullColumns.map((c) => ({
+			type: "column",
+			id: c.id
+		}))];
+		const fullColumnsIdsSet = new Set(fullColumnsIds.map((c) => canonicalizeJson(c)));
+		const isValidColumnId = (id) => fullColumnsIdsSet.has(id);
+		const filters = tableStateNormalized.pTableParams.filters;
+		const defaultFilters = options?.filters ?? void 0;
+		const firstInvalidFilterColumn = (filters !== null ? collectFilterSpecColumns(filters) : []).find((col) => !isValidColumnId(col));
+		if (firstInvalidFilterColumn) throw new Error(`Invalid filter column ${firstInvalidFilterColumn}: column reference does not match the table columns`);
+		const firstInvalidDefaultFilterColumn = (defaultFilters !== void 0 ? collectFilterSpecColumns(defaultFilters) : []).find((col) => !isValidColumnId(col));
+		if (firstInvalidDefaultFilterColumn) throw new Error(`Invalid default filter column ${firstInvalidDefaultFilterColumn}: column reference does not match the table columns`);
+		const userSorting = tableStateNormalized.pTableParams.sorting;
+		const sorting = (isEmpty(userSorting) ? options?.sorting : userSorting) ?? [];
+		const firstInvalidSortingColumn = sorting.find((s) => !isValidColumnId(canonicalizeJson(s.column)));
+		if (firstInvalidSortingColumn) throw new Error(`Invalid sorting column ${JSON.stringify(firstInvalidSortingColumn.column)}: column reference does not match the table columns`);
+		const coreJoinType = options?.coreJoinType ?? "full";
+		const fullDef = createPTableDefV2({
+			columns,
+			labelColumns: fullLabelColumns,
+			coreJoinType,
 			filters,
-			sorting
+			sorting,
+			coreColumnPredicate: options?.coreColumnPredicate
 		});
 		const fullHandle = ctx.createPTableV2(fullDef);
-		const pframeHandle = ctx.createPFrame([
-			...annotated.direct.map((v) => resolveSnapshot(v.column)),
-			...annotated.linked.map((v) => resolveSnapshot(v.column)),
-			...collectLinkerSnapshots(annotated.linked).map(resolveSnapshot)
-		]);
-		const hiddenSpecs = state.pTableParams.hiddenColIds;
-		const visible = buildVisibleColumns(annotated, computeHiddenColumns([...annotated.direct, ...annotated.linked].map((v) => v.column), sorting, filters, hiddenSpecs));
-		const visibleDef = createPTableDefV3({
-			primaryJoinType,
-			primary: primaryEntries,
-			secondary: buildSecondaryGroups(visible.direct.filter((c) => !c.isPrimary), visible.linked),
+		const pframeHandle = ctx.createPFrame(fullColumns);
+		if (!fullHandle || !pframeHandle) return void 0;
+		const hiddenColumns = new Set((() => {
+			if (coreJoinType === "inner") return [];
+			const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;
+			if (hiddenColIds !== null) return hiddenColIds.filter((s) => s.type === "column").map((s) => s.id);
+			return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);
+		})());
+		columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));
+		const coreColumnPredicate = options?.coreColumnPredicate;
+		if (coreColumnPredicate) columns.flatMap((c) => coreColumnPredicate(getColumnIdAndSpec(c)) ? [c.id] : []).forEach((c) => hiddenColumns.delete(c));
+		sorting.map((s) => s.column).filter((c) => c.type === "column").forEach((c) => hiddenColumns.delete(c.id));
+		if (filters) collectFilterSpecColumns(filters).flatMap((c) => {
+			const obj = parseJson(c);
+			return obj.type === "column" ? [obj.id] : [];
+		}).forEach((c) => hiddenColumns.delete(c));
+		const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
+		const visibleLabelColumns = getMatchingLabelColumns(visibleColumns.map(getColumnIdAndSpec), allLabelColumns);
+		if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns])) return void 0;
+		const visibleDef = createPTableDefV2({
+			columns: visibleColumns,
+			labelColumns: visibleLabelColumns,
+			coreJoinType,
 			filters,
-			sorting
+			sorting,
+			coreColumnPredicate
 		});
 		const visibleHandle = ctx.createPTableV2(visibleDef);
+		if (!visibleHandle) return void 0;
 		return {
-			sourceId: state.pTableParams.sourceId,
+			sourceId: tableStateNormalized.pTableParams.sourceId,
 			fullTableHandle: fullHandle,
 			fullPframeHandle: pframeHandle,
 			visibleTableHandle: visibleHandle,
-			defaultFilters: remapedDefaultFilters
-		};
-	}
-	/** Split discovered columns into direct (no linker path) and linked (with linker path). */
-	function splitDiscoveredColumns(columns) {
-		return {
-			direct: columns.filter((dc) => (dc.path?.length ?? 0) === 0),
-			linked: columns.filter((dc) => (dc.path?.length ?? 0) > 0)
-		};
-	}
-	/** All linker snapshots across the given linked columns, deduped by id. */
-	function collectLinkerSnapshots(linked) {
-		return uniqueBy(linked.flatMap((lc) => (lc.path ?? []).map((s) => s.linker)), (c) => c.id);
-	}
-	/**
-	* Annotate all column groups with derived labels and display-rule annotations.
-	* Evaluates `displayOptions` rules against all discovered columns (direct,
-	* linked, labels, linkers) and writes the winning visibility/priority into
-	* column annotations via `withTableVisualAnnotations`.
-	*/
-	function annotateColumnGroups(params) {
-		const { direct, linked, derivedLabels, derivedTooltips, displayOptions, pframeSpec } = params;
-		const allColumnsForRules = [
-			...direct.map((v) => v.column),
-			...linked.map((v) => v.column),
-			...collectLinkerSnapshots(linked)
-		];
-		const visibilityByColId = evaluateRules(displayOptions?.visibility ?? [], allColumnsForRules, pframeSpec);
-		const orderByColId = evaluateRules(displayOptions?.ordering ?? [], allColumnsForRules, pframeSpec);
-		return {
-			direct: liftToVariantColumns(direct, flow((cols) => withDataStatusAnnotations(cols), (cols) => withLabelAnnotations(derivedLabels, cols), (cols) => withInfoAnnotations(derivedTooltips, cols), (cols) => withTableVisualAnnotations(visibilityByColId, orderByColId, cols))),
-			linked: liftToVariantColumns(linked, flow((cols) => withDataStatusAnnotations(cols), (cols) => withHidenAxesAnnotations(cols), (cols) => withLabelAnnotations(derivedLabels, cols), (cols) => withInfoAnnotations(derivedTooltips, cols), (cols) => withTableVisualAnnotations(visibilityByColId, orderByColId, cols))).map((lc) => ({
-				...lc,
-				path: annotateLinkerPath(derivedLabels, lc.path)
-			}))
-		};
-	}
-	/** Lift a snapshot-array transform so it runs on the inner `column` of each variant. */
-	function liftToVariantColumns(variants, fn) {
-		const cols = fn(variants.map((v) => v.column));
-		if (cols.length !== variants.length) throw new Error(`liftToVariantColumns: fn must preserve array length (got ${cols.length}, expected ${variants.length})`);
-		return variants.map((v, i) => ({
-			...v,
-			column: cols[i]
-		}));
-	}
-	function annotateLinkerPath(derivedLabels, path) {
-		if (isNil$1(path) || path.length === 0) return path;
-		const annotatedLinkers = withHidenAxesAnnotations(withLabelAnnotations(derivedLabels, path.map((s) => s.linker)));
-		return path.map((s, i) => ({
-			...s,
-			linker: annotatedLinkers[i]
-		}));
-	}
-	/** Build an index of all valid column IDs (axes + columns) for filter/sorting validation. */
-	function createColumnValidationById(fullColumns) {
-		const allIds = [...uniqueBy(fullColumns.flatMap((c) => c.spec.axesSpec.map(getAxisId)), (a) => canonicalizeJson(a)).map((a) => ({
-			type: "axis",
-			id: a
-		})), ...fullColumns.map((c) => ({
-			type: "column",
-			id: c.id
-		}))];
-		const validIdSet = new Set(allIds.map((c) => canonicalizeJson(c)));
-		return (id) => {
-			return validIdSet.has(id);
-		};
-	}
-	/** Drop filter leaves whose column references are not available in the table. */
-	function filterFilters(filters, isValidColumnId) {
-		if (isNil$1(filters)) return filters;
-		const isLeafValid = (leaf) => {
-			if (leaf.type === void 0) return true;
-			if ("column" in leaf && !isValidColumnId(leaf.column)) return false;
-			if ("rhs" in leaf && !isValidColumnId(leaf.rhs)) return false;
-			return true;
-		};
-		const prune = (node) => {
-			if (node.type === "and" || node.type === "or") {
-				const kept = node.filters.map((f) => prune(f)).filter((f) => !isNil$1(f));
-				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 isLeafValid(node) ? node : void 0;
-		};
-		return prune(filters);
-	}
-	/** Merge two filter trees into one AND-combined tree. Returns the non-nil one if the other is nil. */
-	function concatFilters(a, b) {
-		if (isNil$1(a)) return b;
-		if (isNil$1(b)) return a;
-		return {
-			...a,
-			filters: [...a.filters, ...b.filters]
-		};
-	}
-	/** Pick user sorting from state if non-empty, otherwise fall back to options default. */
-	function resolveSorting(userSorting, defaultSorting) {
-		return (isEmpty(userSorting) ? defaultSorting : userSorting) ?? [];
-	}
-	/** Drop sorting entries whose column is not available in the table. */
-	function filterSorting(sorting, isValidColumnId) {
-		return sorting.filter((s) => isValidColumnId(canonicalizeJson(s.column)));
-	}
-	function buildSecondaryGroups(direct, linked) {
-		return [...direct.map((c) => ({
-			entries: [{
-				column: resolveSnapshot(c.column),
-				qualifications: c.qualifications?.forHit
-			}],
-			primaryQualifications: c.qualifications?.forQueries
-		})), ...linked.map((lc) => ({
-			entries: [{
-				column: resolveSnapshot(lc.column),
-				linkers: lc.path?.map((s) => resolveSnapshot(s.linker)),
-				qualifications: lc.qualifications?.forHit
-			}],
-			primaryQualifications: lc.qualifications?.forQueries
-		}))];
-	}
-	/** Determine which columns should be hidden based on state or optional-column defaults. */
-	function computeHiddenColumns(columns, sorting, filters, hiddenSpecs) {
-		const alwaysHidden = columns.filter((c) => isColumnHidden(c.spec)).map((c) => c.id);
-		const optionalHidden = !isNil$1(hiddenSpecs) ? hiddenSpecs.filter((s) => s.type === "column").map((s) => s.id) : columns.filter((c) => isColumnOptional(c.spec)).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) => {
-			const obj = parseJson(c);
-			return obj.type === "column" ? [obj.id] : [];
-		}) : [];
-		return new Set([...sortedIds, ...filterIds]);
-	}
-	/** Filter annotated columns to only visible ones, re-matching label columns for the visible subset. */
-	function buildVisibleColumns(annotated, hiddenColumns) {
-		return {
-			direct: annotated.direct.filter((c) => !hiddenColumns.has(c.column.id)),
-			linked: annotated.linked.filter((c) => !hiddenColumns.has(c.column.id))
-		};
-	}
-	/** Resolve a ColumnSnapshot to a PColumn with lazily-evaluated data. */
-	function resolveSnapshot(snap) {
-		return {
-			id: snap.id,
-			spec: snap.spec,
-			data: snap.data?.get()
+			defaultFilters
 		};
 	}
-	/** Remap column references in sorting entries. */
-	function remapSortingColumnIds(sorting, columns) {
-		return sorting?.flatMap((s) => {
-			if (s.column.type === "axis") return [s];
-			const id = s.column.id;
-			const column = columns.find((c) => (getField(c, "originalId") ?? c.column.id) === id);
-			if (column === void 0) return [];
-			return [{
-				...s,
-				column: {
-					type: "column",
-					id: column.column.id
-				}
-			}];
-		});
-	}
-	/** Remap column references in a filter tree. */
-	function remapFilterColumnIds(filters, columns) {
-		if (isNil$1(filters)) return filters;
-		const map = (tableColumnId) => {
-			const parsed = parseJson(tableColumnId);
-			if (parsed.type === "axis") return tableColumnId;
-			const originalId = parsed.id;
-			return canonicalizeJson({
-				type: "column",
-				id: (columns.find((c) => (getField(c, "originalId") ?? c.column.id) === originalId) ?? throwError(`Column ID "${parsed.id}" in filters does not match any discovered column`)).column.id
-			});
-		};
-		return traverseFilterSpec(filters, {
-			leaf: (leaf) => {
-				if (leaf.type === void 0) return leaf;
-				const result = { ...leaf };
-				if ("column" in result) result.column = map(result.column);
-				if ("rhs" in result) result.rhs = map(result.rhs);
-				return result;
-			},
-			and: (results) => ({
-				type: "and",
-				filters: results
-			}),
-			or: (results) => ({
-				type: "or",
-				filters: results
-			}),
-			not: (result) => ({
-				type: "not",
-				filter: result
-			})
+	function getAllLabelColumns(resultPool) {
+		return new PColumnCollection().addAxisLabelProvider(resultPool).addColumnProvider(resultPool).getColumns({
+			name: PColumnName.Label,
+			axes: [{}]
+		}, {
+			dontWaitAllData: true,
+			overrideLabelAnnotation: false
 		});
 	}
 	(/* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -10158,38 +9304,7 @@
 		if (ctx.data.inputAnchor === void 0) return void 0;
 		const ownCols = ctx.outputs?.resolve("propertiesPf")?.getPColumns();
 		if (ownCols === void 0) return void 0;
-		const info = ctx.outputs?.resolve("info")?.getDataAsJson();
-		if (info === void 0) return void 0;
-		const tier = info.coverageTier;
-		const sources = [new ArrayColumnProvider(ctx.resultPool.selectColumns((spec) => !spec.annotations?.[Annotation.Trace]?.includes("milaboratories.sequence-properties"))), new ArrayColumnProvider(ownCols)];
-		return createPlDataTableV3(ctx, {
-			tableState: ctx.data.tableState,
-			columns: {
-				sources,
-				anchors: { main: ctx.data.inputAnchor },
-				selector: { mode: "enrichment" }
-			},
-			displayOptions: { visibility: [{
-				match: (spec) => {
-					if (spec.domain?.["pl7.app/vdj/scClonotypeChain/index"] === "secondary") return false;
-					if (spec.domain?.["pl7.app/alphabet"] !== "aminoacid") return false;
-					const isVdj = spec.name === "pl7.app/vdj/sequence";
-					const isUniversal = spec.name === "pl7.app/sequence";
-					if (!isVdj && !isUniversal) return false;
-					const feature = isVdj ? spec.domain?.["pl7.app/vdj/feature"] : spec.domain?.["pl7.app/feature"];
-					if (tier === "peptide") return isUniversal && feature === "peptide";
-					const chain = spec.domain?.["pl7.app/vdj/scClonotypeChain"];
-					if (chain !== void 0 && chain !== "A") return false;
-					if (tier === "full_chain") return feature === "VDJRegion" || feature === "VDJRegionInFrame";
-					if (tier === "cdr3_only" || tier === "partial") return feature === "CDR3";
-					return false;
-				},
-				visibility: "default"
-			}, {
-				match: (spec) => !spec.annotations?.[Annotation.Trace]?.includes("milaboratories.sequence-properties") && spec.annotations?.["pl7.app/isLinkerColumn"] !== "true",
-				visibility: "optional"
-			}] }
-		});
+		return createPlDataTableV2(ctx, ownCols.filter((c) => c.spec.axesSpec.length === 1), ctx.data.tableState);
 	}).outputWithStatus("propertiesPfHandle", (ctx) => {
 		const allPCols = ctx.outputs?.resolve("propertiesPf")?.getPColumns();
 		if (allPCols === void 0) return void 0;
@@ -10202,7 +9317,7 @@
 			anchor: "main",
 			idx: 1
 		}] }]) ?? []).filter((c) => !c.spec.annotations?.[Annotation.Trace]?.includes("milaboratories.sequence-properties")) : [];
-		return ctx.createPFrame([...pCols, ...upstreamMeta]);
+		return createPFrameForGraphs(ctx, [...pCols, ...upstreamMeta]);
 	}).output("propertiesPfCols", (ctx) => {
 		const pCols = ctx.outputs?.resolve("propertiesPf")?.getPColumns();
 		if (pCols === void 0) return void 0;