@platforma-sdk/model 1.80.2 → 1.80.10

package/dist/labels/linked_column_postfix.js

@@ -0,0 +1,188 @@
+import { Annotation, canonicalizeJson, getAxisId, readAnnotation } from "@milaboratories/pl-model-common";
+import { isNil } from "es-toolkit";
+//#region src/labels/linked_column_postfix.ts
+/**
+* Structural postfix derivation for linked columns (phase 2 of `deriveDistinctLabels`).
+*
+* A linked column is
+* reached by a CHAIN of linkers, and we distinguish two such columns by the same ideology the main
+* algorithm uses — "find the minimal difference, escalate until unique" — over two dimensions:
+*
+*   - root:    the single source axis of the chain, derived from `linkers[0]` (one of its axesSpec).
+*              This is "the source" — it's what we prefer to show ("difference of sources").
+*   - linkers: the linker chain itself (by `LinkLabel`), a per-step fallback used only where roots
+*              coincide.
+*
+* Nothing is stored redundantly: the caller passes the linker path (`linkers`) and the hit spec;
+* root and every token are computed on the fly. The caller also supplies the `stem` (label+trace+
+* quals from the existing single-entity machinery); this module only adds the path postfix, and
+* only where stems collide.
+*/
+function defaultLinkerFormatter(parts) {
+	const chain = parts.linkers.map((l) => l.text).join(" > ");
+	const pieces = [parts.root?.text, chain || void 0].filter((p) => !isNil(p));
+	return pieces.length === 0 ? "" : `via ${pieces.join(" ")}`;
+}
+function extractAxisIdentity(axis) {
+	const id = getAxisId(axis);
+	return {
+		label: readAnnotation(axis, Annotation.Label)?.trim() || void 0,
+		name: id.name,
+		domain: id.domain,
+		contextDomain: id.contextDomain
+	};
+}
+/**
+* A linker is named ONLY by its human label (`LinkLabel`/`Label`) — never by its technical column
+* name. Returns `undefined` for an unlabeled linker, which callers treat as "not renderable": such a
+* step is skipped, and disambiguation falls to another step or the root.
+*/
+function extractLinkerIdentity(linker) {
+	const label = (readAnnotation(linker, Annotation.LinkLabel) ?? readAnnotation(linker, Annotation.Label))?.trim();
+	return label ? {
+		label,
+		name: label
+	} : void 0;
+}
+/** Domain keys where `mine` differs from at least one competitor. */
+function differingKeys(mine, others) {
+	const my = mine ?? {};
+	const diffKeys = /* @__PURE__ */ new Set();
+	for (const o of others) {
+		const od = o ?? {};
+		for (const k of Object.keys(my)) if (my[k] !== od[k]) diffKeys.add(k);
+		for (const k of Object.keys(od)) if (my[k] !== od[k]) diffKeys.add(k);
+	}
+	return [...diffKeys];
+}
+function renderWithDomain(base, keys, domain) {
+	if (keys.length === 0) return base;
+	const d = domain ?? {};
+	return `${base}[${keys.map((k) => `${k}=${d[k] ?? "∅"}`).join(", ")}]`;
+}
+/**
+* Minimal token distinguishing `mine` from `others`: label → name → only the differing domain keys.
+* Falls back to the bare label/name when indistinguishable at this dimension (another one covers it).
+*/
+function deriveToken(mine, others) {
+	const base = mine.label ?? mine.name;
+	if (mine.label !== void 0 && others.every((o) => o.label !== mine.label)) return mine.label;
+	if (others.every((o) => o.name !== mine.name)) return base;
+	const dk = differingKeys(mine.domain, others.map((o) => o.domain));
+	if (dk.length > 0) return renderWithDomain(base, dk, mine.domain);
+	const ck = differingKeys(mine.contextDomain, others.map((o) => o.contextDomain));
+	if (ck.length > 0) return renderWithDomain(base, ck, mine.contextDomain);
+	return base;
+}
+/**
+* The chain's single root: the source-side axis of `linkers[0]`. A linker bridges two axis groups;
+* the side facing the next hop (`linkers[1]`, or the hit for a single-linker chain) is the target,
+* the other side is the source → its axis is the root. `undefined` if `linkers[0]` is not a
+* well-formed two-group linker.
+*/
+function extractRoot(hit, linkers) {
+	const first = linkers[0];
+	if (first === void 0) return void 0;
+	const axes = first.axesSpec;
+	if (axes.length !== 2) return void 0;
+	const second = linkers[1] ?? hit;
+	return axes.find((a) => !second.axesSpec.some((b) => b.name === a.name));
+}
+const ABSENT = "__ABSENT__";
+function deriveSlotKey(group, slot, row) {
+	if (slot.kind === "root") {
+		const r = group.roots[row];
+		return r === void 0 ? ABSENT : canonicalizeJson(getAxisId(r));
+	} else {
+		const l = group.entries[row].linkers?.[slot.i];
+		const id = l && extractLinkerIdentity(l);
+		return isNil(id) ? ABSENT : canonicalizeJson(id);
+	}
+}
+function deriveSlotToken(group, slot, row) {
+	if (slot.kind === "root") {
+		const r = group.roots[row];
+		if (r === void 0) return void 0;
+		const comp = group.roots.filter((o, j) => j !== row && !isNil(o)).map((o) => extractAxisIdentity(o));
+		return deriveToken(extractAxisIdentity(r), comp);
+	}
+	const l = group.entries[row].linkers?.[slot.i];
+	const id = l && extractLinkerIdentity(l);
+	if (isNil(id)) return void 0;
+	return deriveToken(id, group.entries.filter((_, j) => j !== row).map((e) => e.linkers?.[slot.i]).map((x) => x ? extractLinkerIdentity(x) : void 0).filter((x) => !isNil(x)));
+}
+function getDiscriminates(group, slot) {
+	return new Set(group.entries.map((_, r) => deriveSlotKey(group, slot, r))).size > 1;
+}
+/** Render one row against a chosen slot set: the distinguishing root + linker pieces, formatted. */
+function renderRow(group, slots, row) {
+	const rootSpec = group.roots[row];
+	const rootText = slots.some((s) => s.kind === "root") ? deriveSlotToken(group, { kind: "root" }, row) : void 0;
+	const root = rootSpec !== void 0 && rootText !== void 0 ? {
+		spec: rootSpec,
+		text: rootText
+	} : void 0;
+	const linkers = slots.filter((s) => s.kind === "linker").sort((a, b) => a.i - b.i).map((s) => {
+		const spec = group.entries[row].linkers?.[s.i];
+		const text = deriveSlotToken(group, s, row);
+		return spec !== void 0 && text !== void 0 ? {
+			spec,
+			text
+		} : void 0;
+	}).filter((l) => !isNil(l));
+	if (root === void 0 && linkers.length === 0) return "";
+	return group.format({
+		root,
+		linkers
+	}, group.entries[row].hit, group.indices[row]) || "";
+}
+function renderAll(group, slots) {
+	return group.entries.map((_, r) => renderRow(group, slots, r));
+}
+function allUnique(rendered) {
+	return new Set(rendered).size === rendered.length;
+}
+/**
+* Minimal slot set that makes the group unique. Escalate by priority (root, then linkers by step),
+* then drop any redundant slot; render every row symmetrically against the result.
+*
+* KNOWN LIMITATION (review point): symmetric render can over-decorate a row in a mixed group (e.g.
+* `via Sample MapperA` where `via Sample` alone is already unique for that row). Per-row trimming is
+* a generalized `dropRedundantLinkerSuffix`; naive greedy trimming is unstable, so it's deferred.
+*/
+function resolveGroup(entries, indices, format) {
+	const group = {
+		entries,
+		roots: entries.map((e) => e.hit && e.linkers?.length ? extractRoot(e.hit, e.linkers) : void 0),
+		indices,
+		format
+	};
+	const maxLen = Math.max(0, ...entries.map((e) => e.linkers?.length ?? 0));
+	const escalated = [{ kind: "root" }, ...Array.from({ length: maxLen }, (_, i) => ({
+		kind: "linker",
+		i
+	}))].reduce((acc, slot) => allUnique(renderAll(group, acc)) || !getDiscriminates(group, slot) ? acc : (acc.push(slot), acc), []);
+	return renderAll(group, escalated.reduce((acc, slot) => {
+		const trial = acc.filter((s) => s !== slot);
+		return allUnique(renderAll(group, trial)) ? trial : acc;
+	}, escalated));
+}
+/**
+* Full label per entry: `stem` plus, where stems collide, a minimal postfix distinguishing the
+* linked columns by the difference between their sources.
+*/
+function derivePostfixes(entries, format = defaultLinkerFormatter) {
+	const postfix = [...entries.reduce((acc, e, idx) => acc.set(e.stem, [...acc.get(e.stem) ?? [], idx]), /* @__PURE__ */ new Map()).values()].reduce((acc, idxs) => {
+		if (idxs.length < 2) return acc;
+		const resolved = resolveGroup(idxs.map((i) => entries[i]), idxs, format);
+		return idxs.reduce((m, i, k) => m.set(i, resolved[k]), acc);
+	}, /* @__PURE__ */ new Map());
+	return entries.map((e, i) => {
+		const p = postfix.get(i);
+		return p ? `${e.stem} ${p}` : e.stem;
+	});
+}
+//#endregion
+export { derivePostfixes, extractRoot };
+
+//# sourceMappingURL=linked_column_postfix.js.map

package/dist/labels/linked_column_postfix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linked_column_postfix.js","names":[],"sources":["../../src/labels/linked_column_postfix.ts"],"sourcesContent":["/**\n * Structural postfix derivation for linked columns (phase 2 of `deriveDistinctLabels`).\n *\n * A linked column is\n * reached by a CHAIN of linkers, and we distinguish two such columns by the same ideology the main\n * algorithm uses — \"find the minimal difference, escalate until unique\" — over two dimensions:\n *\n *   - root:    the single source axis of the chain, derived from `linkers[0]` (one of its axesSpec).\n *              This is \"the source\" — it's what we prefer to show (\"difference of sources\").\n *   - linkers: the linker chain itself (by `LinkLabel`), a per-step fallback used only where roots\n *              coincide.\n *\n * Nothing is stored redundantly: the caller passes the linker path (`linkers`) and the hit spec;\n * root and every token are computed on the fly. The caller also supplies the `stem` (label+trace+\n * quals from the existing single-entity machinery); this module only adds the path postfix, and\n * only where stems collide.\n */\nimport {\n  Annotation,\n  canonicalizeJson,\n  getAxisId,\n  readAnnotation,\n  type AxisSpec,\n  type PColumnSpec,\n} from \"@milaboratories/pl-model-common\";\nimport { isNil } from \"es-toolkit\";\n\n/**\n * One entry to label: its stem plus the linker path that reached it (`linkers[0]` source-most) and\n * the hit spec used to orient the chain. Plain columns pass neither.\n */\nexport type PostfixEntry = { stem: string; hit?: PColumnSpec; linkers?: PColumnSpec[] };\n\n/**\n * One distinguishing piece of the postfix: the full source spec (axis or linker column — no info\n * lost) plus `text`, the minimal text that sets it apart from the siblings (a label, or only the\n * differing domain keys). Custom formatters may use `spec` freely; `text` is the default rendering.\n */\nexport type LinkerPart<Spec> = { spec: Spec; text: string };\n\n/** The distinguishing source of one column: its root axis (when it differs) + the linker chain. */\nexport type LinkerParts = {\n  root?: LinkerPart<AxisSpec>;\n  linkers: LinkerPart<PColumnSpec>[];\n};\n\n/**\n * Renders the postfix zone from the distinguishing sources. Default:\n * `via ${[root, linkers.join(\" > \")].filter(Boolean).join(\" \")}` (using each piece's `text`).\n * Returning `undefined` — or the empty string `\"\"` — suppresses the postfix entirely (the column\n * keeps just its stem); the two are treated identically.\n */\nexport type LinkerFormatter = (\n  parts: LinkerParts,\n  hit: PColumnSpec | undefined,\n  index: number,\n) => string | undefined;\n\nfunction defaultLinkerFormatter(parts: LinkerParts): string {\n  const chain = parts.linkers.map((l) => l.text).join(\" > \");\n  const pieces = [parts.root?.text, chain || undefined].filter((p): p is string => !isNil(p));\n  return pieces.length === 0 ? \"\" : `via ${pieces.join(\" \")}`;\n}\n\ntype AxisIdentity = { label?: string } & Pick<AxisSpec, \"name\" | \"domain\" | \"contextDomain\">;\n\nfunction extractAxisIdentity(axis: AxisSpec): AxisIdentity {\n  const id = getAxisId(axis);\n  return {\n    label: readAnnotation(axis, Annotation.Label)?.trim() || undefined,\n    name: id.name,\n    domain: id.domain,\n    contextDomain: id.contextDomain,\n  };\n}\n\n/**\n * A linker is named ONLY by its human label (`LinkLabel`/`Label`) — never by its technical column\n * name. Returns `undefined` for an unlabeled linker, which callers treat as \"not renderable\": such a\n * step is skipped, and disambiguation falls to another step or the root.\n */\nfunction extractLinkerIdentity(linker: PColumnSpec): AxisIdentity | undefined {\n  const label = (\n    readAnnotation(linker, Annotation.LinkLabel) ?? readAnnotation(linker, Annotation.Label)\n  )?.trim();\n  return label ? { label, name: label } : undefined;\n}\n\n/** Domain keys where `mine` differs from at least one competitor. */\nfunction differingKeys(\n  mine: Record<string, string> | undefined,\n  others: (Record<string, string> | undefined)[],\n): string[] {\n  const my = mine ?? {};\n  const diffKeys = new Set<string>();\n  for (const o of others) {\n    const od = o ?? {};\n    for (const k of Object.keys(my)) {\n      if (my[k] !== od[k]) {\n        diffKeys.add(k);\n      }\n    }\n    for (const k of Object.keys(od)) {\n      if (my[k] !== od[k]) {\n        diffKeys.add(k);\n      }\n    }\n  }\n  return [...diffKeys];\n}\n\nfunction renderWithDomain(\n  base: string,\n  keys: string[],\n  domain: Record<string, string> | undefined,\n): string {\n  if (keys.length === 0) return base;\n  const d = domain ?? {};\n  const pairs = keys.map((k) => `${k}=${d[k] ?? \"∅\"}`).join(\", \");\n  return `${base}[${pairs}]`;\n}\n\n/**\n * Minimal token distinguishing `mine` from `others`: label → name → only the differing domain keys.\n * Falls back to the bare label/name when indistinguishable at this dimension (another one covers it).\n */\nfunction deriveToken(mine: AxisIdentity, others: AxisIdentity[]): string {\n  const base = mine.label ?? mine.name;\n  if (mine.label !== undefined && others.every((o) => o.label !== mine.label)) return mine.label;\n  if (others.every((o) => o.name !== mine.name)) return base;\n  const dk = differingKeys(\n    mine.domain,\n    others.map((o) => o.domain),\n  );\n  if (dk.length > 0) return renderWithDomain(base, dk, mine.domain);\n  const ck = differingKeys(\n    mine.contextDomain,\n    others.map((o) => o.contextDomain),\n  );\n  if (ck.length > 0) return renderWithDomain(base, ck, mine.contextDomain);\n  return base;\n}\n\n/**\n * The chain's single root: the source-side axis of `linkers[0]`. A linker bridges two axis groups;\n * the side facing the next hop (`linkers[1]`, or the hit for a single-linker chain) is the target,\n * the other side is the source → its axis is the root. `undefined` if `linkers[0]` is not a\n * well-formed two-group linker.\n */\nexport function extractRoot(hit: PColumnSpec, linkers: PColumnSpec[]): AxisSpec | undefined {\n  const first = linkers[0];\n  if (first === undefined) return undefined;\n  const axes = first.axesSpec;\n  if (axes.length !== 2) return undefined;\n  const second = linkers[1] ?? hit;\n  return axes.find((a) => !second.axesSpec.some((b) => b.name === a.name));\n}\n\ntype Slot = { kind: \"root\" } | { kind: \"linker\"; i: number };\n\nconst ABSENT = \"__ABSENT__\"; // sentinel for \"this row has no value at this slot\"\n\n/** A colliding group: entries + their derived roots + original indices + the postfix formatter. */\ntype Group = {\n  entries: PostfixEntry[];\n  roots: (AxisSpec | undefined)[];\n  indices: number[];\n  format: LinkerFormatter;\n};\n\nfunction deriveSlotKey(group: Group, slot: Slot, row: number): string {\n  if (slot.kind === \"root\") {\n    const r = group.roots[row];\n    return r === undefined ? ABSENT : canonicalizeJson(getAxisId(r));\n  } else {\n    const l = group.entries[row].linkers?.[slot.i];\n    const id = l && extractLinkerIdentity(l);\n    return isNil(id) ? ABSENT : canonicalizeJson(id);\n  }\n}\n\nfunction deriveSlotToken(group: Group, slot: Slot, row: number): string | undefined {\n  if (slot.kind === \"root\") {\n    const r = group.roots[row];\n    if (r === undefined) return undefined;\n    const comp = group.roots\n      .filter((o, j) => j !== row && !isNil(o))\n      .map((o) => extractAxisIdentity(o!));\n    return deriveToken(extractAxisIdentity(r), comp);\n  }\n  const l = group.entries[row].linkers?.[slot.i];\n  const id = l && extractLinkerIdentity(l);\n  if (isNil(id)) return undefined; // unlabeled / absent linker → not renderable, skip\n  const comp = group.entries\n    .filter((_, j) => j !== row)\n    .map((e) => e.linkers?.[slot.i])\n    .map((x) => (x ? extractLinkerIdentity(x) : undefined))\n    .filter((x): x is AxisIdentity => !isNil(x));\n  return deriveToken(id, comp);\n}\n\nfunction getDiscriminates(group: Group, slot: Slot): boolean {\n  return new Set(group.entries.map((_, r) => deriveSlotKey(group, slot, r))).size > 1;\n}\n\n/** Render one row against a chosen slot set: the distinguishing root + linker pieces, formatted. */\nfunction renderRow(group: Group, slots: Slot[], row: number): string {\n  const rootSpec = group.roots[row];\n  const rootText = slots.some((s) => s.kind === \"root\")\n    ? deriveSlotToken(group, { kind: \"root\" }, row)\n    : undefined;\n  const root: LinkerPart<AxisSpec> | undefined =\n    rootSpec !== undefined && rootText !== undefined\n      ? { spec: rootSpec, text: rootText }\n      : undefined;\n\n  const linkers = slots\n    .filter((s): s is { kind: \"linker\"; i: number } => s.kind === \"linker\")\n    .sort((a, b) => a.i - b.i)\n    .map((s) => {\n      const spec = group.entries[row].linkers?.[s.i];\n      const text = deriveSlotToken(group, s, row);\n      return spec !== undefined && text !== undefined ? { spec, text } : undefined;\n    })\n    .filter((l): l is LinkerPart<PColumnSpec> => !isNil(l));\n\n  // No distinguishing pieces for this row → no postfix (don't invoke the formatter with empties).\n  if (root === undefined && linkers.length === 0) return \"\";\n  // A formatter may suppress the postfix by returning `undefined` or `\"\"`; `|| \"\"` collapses both\n  // to the same empty value so neither counts as a distinguishing token during slot escalation.\n  return group.format({ root, linkers }, group.entries[row].hit, group.indices[row]) || \"\";\n}\n\nfunction renderAll(group: Group, slots: Slot[]): string[] {\n  return group.entries.map((_, r) => renderRow(group, slots, r));\n}\n\nfunction allUnique(rendered: string[]): boolean {\n  return new Set(rendered).size === rendered.length;\n}\n\n/**\n * Minimal slot set that makes the group unique. Escalate by priority (root, then linkers by step),\n * then drop any redundant slot; render every row symmetrically against the result.\n *\n * KNOWN LIMITATION (review point): symmetric render can over-decorate a row in a mixed group (e.g.\n * `via Sample MapperA` where `via Sample` alone is already unique for that row). Per-row trimming is\n * a generalized `dropRedundantLinkerSuffix`; naive greedy trimming is unstable, so it's deferred.\n */\nfunction resolveGroup(\n  entries: PostfixEntry[],\n  indices: number[],\n  format: LinkerFormatter,\n): string[] {\n  const group: Group = {\n    entries,\n    roots: entries.map((e) =>\n      e.hit && e.linkers?.length ? extractRoot(e.hit, e.linkers) : undefined,\n    ),\n    indices,\n    format,\n  };\n  const maxLen = Math.max(0, ...entries.map((e) => e.linkers?.length ?? 0));\n\n  const slots: Slot[] = [\n    { kind: \"root\" },\n    ...Array.from({ length: maxLen }, (_, i): Slot => ({ kind: \"linker\", i })),\n  ];\n\n  const escalated = slots.reduce<Slot[]>(\n    (acc, slot) =>\n      allUnique(renderAll(group, acc)) || !getDiscriminates(group, slot)\n        ? acc\n        : (acc.push(slot), acc),\n    [],\n  );\n  const chosen = escalated.reduce<Slot[]>((acc, slot) => {\n    const trial = acc.filter((s) => s !== slot);\n    return allUnique(renderAll(group, trial)) ? trial : acc;\n  }, escalated);\n\n  return renderAll(group, chosen);\n}\n\n/**\n * Full label per entry: `stem` plus, where stems collide, a minimal postfix distinguishing the\n * linked columns by the difference between their sources.\n */\nexport function derivePostfixes(\n  entries: PostfixEntry[],\n  format: LinkerFormatter = defaultLinkerFormatter,\n): string[] {\n  const groups = entries.reduce<Map<string, number[]>>(\n    (acc, e, idx) => acc.set(e.stem, [...(acc.get(e.stem) ?? []), idx]),\n    new Map(),\n  );\n\n  const postfix = [...groups.values()].reduce<Map<number, string>>((acc, idxs) => {\n    if (idxs.length < 2) return acc; // stem already unique — no postfix\n    const resolved = resolveGroup(\n      idxs.map((i) => entries[i]),\n      idxs,\n      format,\n    );\n    return idxs.reduce((m, i, k) => m.set(i, resolved[k]), acc);\n  }, new Map());\n\n  return entries.map((e, i) => {\n    const p = postfix.get(i);\n    return p ? `${e.stem} ${p}` : e.stem;\n  });\n}\n"],"mappings":"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"}

package/dist/package.cjs

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "1.80.2";
+var version = "1.80.10";
 //#endregion
 Object.defineProperty(exports, "version", {
 	enumerable: true,

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "1.80.2";
+var version = "1.80.10";
 //#endregion
 export { version };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/model",
-  "version": "1.80.2",
+  "version": "1.80.10",
   "description": "Platforma.bio SDK / Block Model",
   "files": [
     "./dist/**/*",
@@ -31,23 +31,23 @@
     "lru-cache": "^11.2.2",
     "utility-types": "^3.11.0",
     "zod": "~3.25.76",
-    "@milaboratories/helpers": "1.14.4",
+    "@milaboratories/helpers": "1.14.5",
+    "@milaboratories/pl-model-middle-layer": "1.30.15",
     "@milaboratories/pl-error-like": "1.12.10",
-    "@milaboratories/pl-model-common": "1.47.1",
-    "@milaboratories/ptabler-expression-js": "1.2.35",
-    "@milaboratories/pl-model-middle-layer": "1.30.13"
+    "@milaboratories/ptabler-expression-js": "1.2.37",
+    "@milaboratories/pl-model-common": "1.47.3"
   },
   "devDependencies": {
     "@vitest/coverage-istanbul": "^4.1.3",
     "fast-json-patch": "^3.1.1",
     "typescript": "~5.9.3",
     "vitest": "^4.1.3",
-    "@milaboratories/columns-collection-driver": "0.2.1",
+    "@milaboratories/columns-collection-driver": "0.2.3",
     "@milaboratories/build-configs": "2.0.0",
-    "@milaboratories/ts-builder": "1.6.0",
-    "@milaboratories/pf-spec-driver": "1.4.21",
-    "@milaboratories/ts-configs": "1.3.0",
-    "@milaboratories/pf-driver": "1.8.2"
+    "@milaboratories/pf-driver": "1.8.5",
+    "@milaboratories/pf-spec-driver": "1.4.24",
+    "@milaboratories/ts-builder": "1.6.1",
+    "@milaboratories/ts-configs": "1.3.1"
   },
   "scripts": {
     "build": "ts-builder build --target node",

package/src/columns/column.ts

@@ -1,9 +1,9 @@
-import type {
-  ColumnUniversalId,
-  LeafEntry,
-  PColumn,
-  PlRef,
-  PObjectId,
+import {
+  type ColumnUniversalId,
+  type LeafEntry,
+  type PColumn,
+  type PlRef,
+  type PObjectId,
 } from "@milaboratories/pl-model-common";
 import type { GlobalCfgRenderCtx } from "../render/internal";
 import type { TreeNodeAccessor } from "../render";

package/src/components/PlDataTable/createPlDataTable/createPlDataTableV3.ts

@@ -227,11 +227,11 @@ type ResolvedColumns = {
 function resolveInputColumns<A, U>(
   ctx: RenderCtxBase<A, U>,
   options: createPlDataTableOptionsV3,
-): ResolvedColumns | undefined {
+): undefined | ResolvedColumns {
   if ("primaryColumns" in options) {
     const primary = options.primaryColumns;
     const secondary = options.columns ?? [];
-    const labels = discoverLabelColumns(ctx, primary, [...primary, ...secondary]);
+    const labels = discoverLabelColumns(ctx, primary);
     // Exclude from secondary anything already present in primary: a label
     // column the block hands in as primary can be re-discovered here as a
     // label for that same axis, landing in the table twice with the same id.

package/src/components/PlDataTable/createPlDataTable/discoverColumns.ts

@@ -7,7 +7,7 @@ import type {
 import { PColumnName } from "@milaboratories/pl-model-common";
 import type { RenderCtxBase } from "../../../render";
 import type { ColumnRecipe, ColumnsSource } from "../../../columns";
-import { ColumnsCollection, collectLinkerIds, isLeafColumn } from "../../../columns";
+import { ColumnsCollection, isLeafColumn } from "../../../columns";
 import type { ColumnsSelectorConfig } from "./createPlDataTableV3";
 
 export type DiscoverTableColumnOptions = {
@@ -30,7 +30,7 @@ export type DiscoveredTableColumns = {
 export function discoverTableColumns(
   ctx: RenderCtxBase,
   options: DiscoverTableColumnOptions,
-): undefined | DiscoveredTableColumns {
+): DiscoveredTableColumns {
   const discoveredColumns = ColumnsCollection(options.sources, { ctx: ctx.ctx })
     .discover({ ...options.selector, anchors: options.anchors })
     .getColumns();
@@ -54,22 +54,18 @@ export function discoverTableColumns(
 export function discoverLabelColumns<A, U>(
   ctx: RenderCtxBase<A, U>,
   primary: ColumnRecipe[],
-  columns: ColumnRecipe[],
 ): ColumnRecipe[] {
-  if (columns.length === 0) return [];
+  if (primary.length === 0) return [];
 
-  const axes = columns.flatMap((col) => col.getSpec().axesSpec);
-  return (
-    ColumnsCollection(undefined, { ctx: ctx.ctx })
-      // .addSource({ columns, isFinal: true })
-      .discover({
-        include: axes.map((a) => ({
-          name: { type: "exact", value: PColumnName.Label },
-          axes: [{ name: { type: "exact", value: a.name } }],
-        })),
-        anchors: Object.fromEntries(primary.map((col, i) => [`anchor_${i}`, col.getSpec()])),
-        maxHops: columns.reduce((acc, c) => Math.max(acc, collectLinkerIds(c).length), 0),
-      })
-      .getColumns()
-  );
+  const axes = primary.flatMap((col) => col.getSpec().axesSpec);
+  return ColumnsCollection(undefined, { 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();
 }

package/src/labels/derive_distinct_labels.test.ts

@@ -213,6 +213,96 @@ test.each<{ name: string; traces: Trace[]; labels: string[] }>([
   expect(deriveDistinctLabels(tracesToSpecs(traces))).toEqual(labels);
 });
 
+// Preset distilled from a real PlDataTable "all columns" dump: three columns whose native label is
+// "Cluster Id", produced by two different clustering analyses (foldseek 3D-structure clustering and
+// mmseqs2 clonotype clustering). The two foldseek columns carry a byte-identical trace, so phase 1
+// cannot tell them apart (a linker "via …" postfix does in the real pipeline); the mmseqs2 column
+// differs by its last trace step. Regression guard for "distinguish by absence": minimization used
+// to keep only ONE clustering type, leaving the other column a bare "Cluster Id" — unique only
+// because it LACKED the peer's clustering step. Each column must instead surface its OWN step.
+test("cluster-id preset: colliding columns are distinguished by a token they have, not by absence", () => {
+  const clusterId = (trace: Trace): PColumnSpec => ({
+    kind: "PColumn",
+    name: "name",
+    valueType: "String",
+    annotations: { [Annotation.Trace]: JSON.stringify(trace), [Annotation.Label]: "Cluster Id" },
+    axesSpec: [],
+  });
+
+  const provenance: Trace = [
+    { type: "milaboratories.samples-and-data", importance: 10, label: "Samples & Data" },
+    {
+      type: "milaboratories.samples-and-data/dataset",
+      importance: 100,
+      label: "MB135 + Podocytes",
+    },
+    {
+      type: "milaboratories.mixcr-amplicon-alignment",
+      importance: 20,
+      label: "MiXCR generic amplicon",
+    },
+    { type: "milaboratories.redefine-clonotypes", importance: 30, label: "Imputed VDJRegion aa" },
+  ];
+  const foldseek: Trace = [
+    ...provenance,
+    { type: "milaboratories.antibody-tcr-lead-selection", importance: 30, label: "Selected Leads" },
+    {
+      type: "milaboratories.3d-structure-prediction",
+      importance: 20,
+      label: "Camelid (VHH/nanobody) NBB2, CDRH3 ≤ 2.5 Å",
+    },
+    {
+      type: "milaboratories.3d-structure-clustering.clustering",
+      importance: 30,
+      label: "Full Structure+AA, TM≥0.95, cov≥0.95",
+    },
+  ];
+  const mmseqs2: Trace = [
+    ...provenance,
+    {
+      type: "milaboratories.clonotype-clustering.clustering",
+      importance: 30,
+      label: "Imputed VDJRegion aa, BLOSUM62, ident:0.95, cov:0.95",
+    },
+  ];
+
+  const entries: Entry[] = [clusterId(foldseek), clusterId(mmseqs2), clusterId(foldseek)];
+
+  expect(deriveDistinctLabels(entries, { includeNativeLabel: true })).toEqual([
+    "Cluster Id / Full Structure+AA, TM≥0.95, cov≥0.95",
+    "Cluster Id / Imputed VDJRegion aa, BLOSUM62, ident:0.95, cov:0.95",
+    "Cluster Id / Full Structure+AA, TM≥0.95, cov≥0.95",
+  ]);
+});
+
+// The by-presence repair must patch ONLY the bare column's own label — never the shared global type
+// set. Otherwise the token it adds for one group ("X2" needs "t") leaks onto every column that
+// carries that type, including "Y" in an unrelated group, which should stay a bare "Y".
+test("by-presence repair does not leak its token into other groups sharing that type", () => {
+  const spec = (label: string, trace: Trace): PColumnSpec => ({
+    kind: "PColumn",
+    name: "name",
+    valueType: "Int",
+    annotations: { [Annotation.Trace]: JSON.stringify(trace), [Annotation.Label]: label },
+    axesSpec: [],
+  });
+
+  const entries: Entry[] = [
+    // Group X: minimization separates the two by the higher-importance "a" (X2 ends up bare),
+    // then repair un-bares X2 with the token it actually has — "t".
+    spec("X", [{ type: "a", importance: 10, label: "A1" }]),
+    spec("X", [{ type: "t", importance: 1, label: "TX" }]),
+    // Group Y: sole "Y" column, also carries "t". Must NOT inherit X2's repair token.
+    spec("Y", [{ type: "t", importance: 1, label: "TY" }]),
+  ];
+
+  expect(deriveDistinctLabels(entries, { includeNativeLabel: true })).toEqual([
+    "X / A1",
+    "X / TX",
+    "Y",
+  ]);
+});
+
 test.each<{ name: string; traces: Trace[]; labels: string[]; forceTraceElements: string[] }>([
   {
     name: "force one element",
@@ -353,7 +443,9 @@ test("linkerPath with multiple steps joins with ' > '", () => {
     },
   ];
   const labels = deriveDistinctLabels(entries);
-  expect(labels).toEqual(["Col", "Col via L1 > L2"]);
+  // Minimal difference: the source-most hop L1 alone distinguishes the linked column from the bare
+  // one, so the redundant L2 is dropped.
+  expect(labels).toEqual(["Col", "Col via L1"]);
 });
 
 test("linkerPath skips steps without labels", () => {
@@ -377,7 +469,7 @@ test("linkerPath skips steps without labels", () => {
   expect(labels).toEqual(["Col", "Col via L2"]);
 });
 
-test("linkerPath with custom linkerLabelFormatter", () => {
+test("formatters.linker customizes the postfix zone", () => {
   const entries: Entry[] = [
     {
       spec: createSpec({
@@ -392,29 +484,32 @@ test("linkerPath with custom linkerLabelFormatter", () => {
     },
   ];
   const labels = deriveDistinctLabels(entries, {
-    formatters: { linker: (linkerLabels) => `[${linkerLabels.join(", ")}]` },
+    formatters: {
+      linker: ({ root, linkers }) =>
+        `[${[root?.text, ...linkers.map((l) => l.text)].filter(Boolean).join(", ")}]`,
+    },
   });
   expect(labels).toEqual(["Col", "Col [L1]"]);
 });
 
-test("linkerPath with linkerLabelFormatter returning undefined suppresses suffix", () => {
+test("formatters.linker returning undefined suppresses the postfix", () => {
   const entries: Entry[] = [
     {
       spec: createSpec({
-        annotations: { [Annotation.Trace]: JSON.stringify([{ type: "t1", label: "Col1" }]) },
+        annotations: { [Annotation.Trace]: JSON.stringify([{ type: "t1", label: "Col" }]) },
       }),
       linkerPath: [{ spec: createSpec({ annotations: { [Annotation.LinkLabel]: "L1" } }) }],
     },
     {
       spec: createSpec({
-        annotations: { [Annotation.Trace]: JSON.stringify([{ type: "t1", label: "Col2" }]) },
+        annotations: { [Annotation.Trace]: JSON.stringify([{ type: "t1", label: "Col" }]) },
       }),
+      linkerPath: [{ spec: createSpec({ annotations: { [Annotation.LinkLabel]: "L2" } }) }],
     },
   ];
-  const labels = deriveDistinctLabels(entries, {
-    formatters: { linker: () => undefined },
-  });
-  expect(labels).toEqual(["Col1", "Col2"]);
+  const labels = deriveDistinctLabels(entries, { formatters: { linker: () => undefined } });
+  // Suppressed → both keep the bare stem (collision left unresolved by the caller's choice).
+  expect(labels).toEqual(["Col", "Col"]);
 });
 
 test("linkerPath falls back to Label when LinkLabel is absent", () => {
@@ -522,39 +617,9 @@ test("formatters.anchorQualification receives anchorId", () => {
   expect(labels).toEqual(["Counts (A=X)", "Counts (A=Y)"]);
 });
 
-test("formatters.linkerStepQualification controls inline step quals", () => {
-  const s = {
-    kind: "PColumn",
-    name: "n",
-    valueType: "Int",
-    axesSpec: [],
-    annotations: { [Annotation.Label]: "Counts" },
-  } as PColumnSpec;
-  const entries: Entry[] = [
-    {
-      spec: s,
-      linkerPath: [
-        {
-          spec: createSpec({ annotations: { [Annotation.LinkLabel]: "Mapper" } }),
-          qualifications: [{ axis: { name: "sample" }, contextDomain: { batch: "X" } }],
-        },
-      ],
-    },
-    {
-      spec: s,
-      linkerPath: [
-        {
-          spec: createSpec({ annotations: { [Annotation.LinkLabel]: "Mapper" } }),
-          qualifications: [{ axis: { name: "sample" }, contextDomain: { batch: "Y" } }],
-        },
-      ],
-    },
-  ];
-  const labels = deriveDistinctLabels(entries, {
-    formatters: { linkerStepQualification: (qs) => `(${qs[0].contextDomain.batch})` },
-  });
-  expect(labels).toEqual(["Counts via Mapper (X)", "Counts via Mapper (Y)"]);
-});
+// Deferred: linker-step qualifications are not yet consumed by phase 2 — to be restored with
+// qualification support (see linked_column_postfix).
+test.todo("linker-step qualifications control inline step quals");
 
 test("addLabelAsSuffix places native label at the end", () => {
   const specs = tracesToSpecs([[{ type: "t1", label: "L1" }], [{ type: "t1", label: "L2" }]]);
@@ -737,16 +802,14 @@ describe("deriveDistinctLabels v2 — linker path & qualifications", () => {
     expect(deriveDistinctLabels(entries)).toEqual(["Counts via Path A", "Counts via Path B"]);
   });
 
-  test("multi-step paths joined with ' > '", () => {
+  test("multi-step paths render only the differing hop (shared hub dropped)", () => {
     const s = labeledSpec("Counts");
     const entries: Entry[] = [
       { spec: s, linkerPath: [{ spec: linkerSpec("Hub") }, { spec: linkerSpec("Tail X") }] },
       { spec: s, linkerPath: [{ spec: linkerSpec("Hub") }, { spec: linkerSpec("Tail Y") }] },
     ];
-    expect(deriveDistinctLabels(entries)).toEqual([
-      "Counts via Hub > Tail X",
-      "Counts via Hub > Tail Y",
-    ]);
+    // Minimal difference: the common "Hub" hop carries no distinction and is dropped.
+    expect(deriveDistinctLabels(entries)).toEqual(["Counts via Tail X", "Counts via Tail Y"]);
   });
 
   test("hit qualifications used when nothing else differs", () => {
@@ -779,27 +842,8 @@ describe("deriveDistinctLabels v2 — linker path & qualifications", () => {
     ]);
   });
 
-  test("linker-step qualifications used to disambiguate identical linker labels", () => {
-    const s = labeledSpec("Counts");
-    const entries: Entry[] = [
-      {
-        spec: s,
-        linkerPath: [
-          { spec: linkerSpec("Mapper"), qualifications: [qual("sample", { batch: "X" })] },
-        ],
-      },
-      {
-        spec: s,
-        linkerPath: [
-          { spec: linkerSpec("Mapper"), qualifications: [qual("sample", { batch: "Y" })] },
-        ],
-      },
-    ];
-    expect(deriveDistinctLabels(entries)).toEqual([
-      "Counts via Mapper [sample batch=X]",
-      "Counts via Mapper [sample batch=Y]",
-    ]);
-  });
+  // Deferred with qualification support in phase 2 (see linked_column_postfix).
+  test.todo("linker-step qualifications used to disambiguate identical linker labels");
 
   test("layers compose only as far as needed; no over-decoration", () => {
     const entries: Entry[] = [
@@ -898,10 +942,11 @@ describe("deriveDistinctLabels v2 — linker path & qualifications", () => {
       },
       { spec: sB, linkerPath: [{ spec: linkerSpec("Mapper") }] },
     ];
+    // Stems already differ by trace/anchor-qual, so the shared "Mapper" linker is never needed.
     expect(deriveDistinctLabels(entries)).toEqual([
-      "Counts / RNAseq via Mapper",
-      "Counts / RNAseq via Mapper [anchor-main: sample batch=X]",
-      "Counts / ATACseq via Mapper",
+      "Counts / RNAseq",
+      "Counts / RNAseq [anchor-main: sample batch=X]",
+      "Counts / ATACseq",
     ]);
   });