@platforma-sdk/model 1.65.9 → 1.66.2

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

@@ -1,57 +1,61 @@
-import type {
-  PColumnSpec,
-  PlRef,
-  PObjectId,
-  RequireServices,
-  Services,
-  SUniversalPColumnId,
-} from "@milaboratories/pl-model-common";
-import { isPlRef } from "@milaboratories/pl-model-common";
+import type { PColumnSpec, PlRef, PObjectId } from "@milaboratories/pl-model-common";
+import { createDiscoveredPColumnId, isPlRef } from "@milaboratories/pl-model-common";
 import type { RenderCtxBase } from "../../../render";
-import type { ColumnSource, ColumnMatch, RelaxedColumnSelector } from "../../../columns";
+import type {
+  ColumnSource,
+  ColumnMatch,
+  RelaxedColumnSelector,
+  ColumnSnapshotProvider,
+  ColumnSnapshot,
+} from "../../../columns";
 import { ColumnCollectionBuilder } from "../../../columns";
 import { toColumnSnapshotProvider } from "../../../columns/column_snapshot_provider";
 import { collectCtxColumnSnapshotProviders } from "../../../columns/ctx_column_sources";
 import { throwError } from "@milaboratories/helpers";
 import type { ColumnsSelectorConfig, TableColumnSnapshot } from "./createPlDataTableV3";
+import { isNil } from "es-toolkit";
 
-export type DiscoveredTableColumnOptions = {
+export type DiscoverTableColumnOptions = {
   sources?: ColumnSource[];
   anchors: Record<string, PlRef | PObjectId | PColumnSpec | RelaxedColumnSelector>;
-  columnsSelector: ColumnsSelectorConfig;
+  selector: ColumnsSelectorConfig;
 };
 
 /** Discover columns from sources/anchors and normalize into a flat DiscoveredColumn list. */
-export function discoverTableColumnSnaphots<
-  A,
-  U,
-  S extends RequireServices<typeof Services.PFrameSpec>,
->(
-  ctx: RenderCtxBase<A, U, S>,
-  options: DiscoveredTableColumnOptions,
-): TableColumnSnapshot<SUniversalPColumnId>[] | undefined {
+export function discoverTableColumnSnaphots(
+  ctx: RenderCtxBase,
+  options: DiscoverTableColumnOptions,
+): TableColumnSnapshot[] | undefined {
   // Resolve PlRef anchors to PColumnSpec
-  const resolvedOptions = { ...options, anchors: resolveAnchors(ctx, options.anchors) };
+  const resolvedOptions = {
+    ...options,
+    anchors: resolveAnchors(ctx, options.anchors),
+  };
 
   // Resolve providers
   const providers = resolveProviders(ctx, resolvedOptions.sources);
   if (providers.length === 0) return undefined;
 
   // Build collection (anchored or plain)
-  const pframeSpec =
-    ctx.services.pframeSpec ?? throwError("PFrameSpec service is required for column discovery.");
-  const collection = new ColumnCollectionBuilder(pframeSpec)
+  const collection = new ColumnCollectionBuilder(ctx.getService("pframeSpec"))
     .addSources(providers)
     .build(resolvedOptions);
   if (collection === undefined) return undefined;
 
   try {
-    const matched = collection.findColumns(resolvedOptions.columnsSelector ?? undefined);
+    const columns = collection.findColumns({
+      ...(resolvedOptions.selector ?? {}),
+      exclude: [
+        ...(Array.isArray(resolvedOptions.selector?.exclude)
+          ? resolvedOptions.selector.exclude
+          : !isNil(resolvedOptions.selector.exclude)
+            ? [resolvedOptions.selector.exclude]
+            : []),
+        { name: "pl7.app/label" },
+      ],
+    });
     const anchors = collection.getAnchors();
-    return mapToDiscoveredColumns(
-      matched,
-      Array.from(Array.from(anchors.values()).map((v) => v.columnId)),
-    );
+    return mapToDiscoveredColumns(columns, anchors);
   } finally {
     collection.dispose();
   }
@@ -60,8 +64,8 @@ export function discoverTableColumnSnaphots<
 // --- Pure helper functions ---
 
 /** Resolve PlRef values in anchors to PColumnSpec via the result pool. */
-function resolveAnchors<A, U>(
-  ctx: RenderCtxBase<A, U>,
+function resolveAnchors(
+  ctx: RenderCtxBase,
   anchors: Record<string, PlRef | PObjectId | PColumnSpec | RelaxedColumnSelector>,
 ): Record<string, PObjectId | PColumnSpec | RelaxedColumnSelector> {
   const result: Record<string, PObjectId | PColumnSpec | RelaxedColumnSelector> = {};
@@ -80,7 +84,10 @@ function resolveAnchors<A, U>(
 }
 
 /** Resolve column snapshot providers from explicit sources or context. */
-function resolveProviders<A, U>(ctx: RenderCtxBase<A, U>, sources: undefined | ColumnSource[]) {
+function resolveProviders(
+  ctx: RenderCtxBase,
+  sources: undefined | ColumnSource[],
+): ColumnSnapshotProvider[] {
   return sources !== undefined
     ? sources.map(toColumnSnapshotProvider)
     : collectCtxColumnSnapshotProviders(ctx);
@@ -89,34 +96,40 @@ function resolveProviders<A, U>(ctx: RenderCtxBase<A, U>, sources: undefined | C
 /** Map matched columns into a flat DiscoveredColumn list with deduped IDs. */
 function mapToDiscoveredColumns(
   matched: readonly ColumnMatch[],
-  anchorColumnIds: readonly PObjectId[],
-): TableColumnSnapshot<SUniversalPColumnId>[] {
-  const hitCounts = matched.reduce(
-    (acc, match) => acc.set(match.originalId, (acc.get(match.originalId) ?? 0) + 1),
-    new Map<PObjectId, number>(),
+  anchors: Map<string, ColumnSnapshot<PObjectId>>,
+): TableColumnSnapshot[] {
+  const columnIdToAnchorName = new Map<PObjectId, string>(
+    Array.from(anchors.entries(), ([key, { id }]) => [id, key] as const),
   );
 
-  const hitIndices = new Map<PObjectId, number>();
-  return matched.map((match) => {
+  return matched.flatMap((match) => {
     const snap = match.column;
+    const isPrimary = columnIdToAnchorName.get(match.column.id) !== undefined;
 
-    let id = snap.id;
-    if ((hitCounts.get(match.originalId) ?? 0) > 1) {
-      const idx = hitIndices.get(match.originalId) ?? 0;
-      hitIndices.set(match.originalId, idx + 1);
-      id = `${snap.id}#q${idx}` as SUniversalPColumnId;
-    }
+    return match.variants.map((variant): TableColumnSnapshot => {
+      const discoveredId = createDiscoveredPColumnId({
+        column: snap.id,
+        path: variant.path.map((p) => ({
+          type: "linker",
+          column: p.linker.id,
+          qualifications: p.qualifications,
+        })),
+        columnQualifications: variant.qualifications.forHit,
+        queriesQualifications: variant.qualifications.forQueries,
+      });
+      return {
+        id: discoveredId,
+        isPrimary,
+
+        originalId: snap.id,
+        spec: snap.spec,
+        data: snap.data,
+        dataStatus: snap.dataStatus,
 
-    return {
-      id,
-      originalId: match.originalId,
-      spec: snap.spec,
-      data: snap.data,
-      dataStatus: snap.dataStatus,
-      isPrimary: anchorColumnIds.some(
-        (anchor) => snap.id === anchor || match.originalId === anchor,
-      ),
-      linkerPath: match.path,
-    };
+        linkerPath: variant.path,
+        qualifications: variant.qualifications,
+        distinctiveQualifications: variant.distinctiveQualifications,
+      };
+    });
   });
 }

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

@@ -1,20 +1,19 @@
-import { Services, type RequireServices } from "@milaboratories/pl-model-common";
 import type { RenderCtxBase } from "../../../render";
 import type { PlDataTableModel } from "../typesV5";
 import { createPlDataTableOptionsV2, createPlDataTableV2 } from "./createPlDataTableV2";
 import { createPlDataTableV3 } from "./createPlDataTableV3";
 import type { createPlDataTableOptionsV3 } from "./createPlDataTableV3";
 
-export function createPlDataTable<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
-  ctx: RenderCtxBase<A, U, S>,
+export function createPlDataTable<A, U>(
+  ctx: RenderCtxBase<A, U>,
   options: { version: "v2" } & createPlDataTableOptionsV2,
 ): ReturnType<typeof createPlDataTableV2>;
-export function createPlDataTable<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
-  ctx: RenderCtxBase<A, U, S>,
+export function createPlDataTable<A, U>(
+  ctx: RenderCtxBase<A, U>,
   options: { version?: "v3" } & createPlDataTableOptionsV3,
 ): ReturnType<typeof createPlDataTableV3>;
-export function createPlDataTable<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
-  ctx: RenderCtxBase<A, U, S>,
+export function createPlDataTable<A, U>(
+  ctx: RenderCtxBase<A, U>,
   options:
     | ({ version: "v2" } & createPlDataTableOptionsV2)
     | ({ version?: "v3" } & createPlDataTableOptionsV3),

package/src/components/PlDataTable/createPlDataTable/utils.test.ts

@@ -6,8 +6,10 @@ import {
   type PColumnSpec,
   type PObjectId,
 } from "@milaboratories/pl-model-common";
+import { SpecDriver } from "@milaboratories/pf-spec-driver";
 import { describe, expect, test } from "vitest";
-import { deriveAllLabels, type LabelableColumn } from "./utils";
+import { deriveAllLabels, evaluateRules, type LabelableColumn, type RuleColumn } from "./utils";
+import type { ColumnOrderRule, ColumnVisibilityRule } from "./createPlDataTableV3";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -255,3 +257,97 @@ describe("deriveAxisLabels via deriveAllLabels", () => {
     expect(result["c2"]).not.toContain("via ");
   });
 });
+
+// ---------------------------------------------------------------------------
+// evaluateRules
+// ---------------------------------------------------------------------------
+
+function makeRuleColumn(id: string, spec: Partial<PColumnSpec> = {}): RuleColumn {
+  return {
+    id: id as PObjectId,
+    spec: makeSpec({ axesSpec: [{ name: "id", type: "String" }], ...spec }),
+  };
+}
+
+describe("evaluateRules", () => {
+  test("returns empty map when rules or columns are empty", () => {
+    const driver = new SpecDriver();
+    expect(evaluateRules([], [makeRuleColumn("c1")], driver).size).toBe(0);
+    expect(
+      evaluateRules<ColumnVisibilityRule>([{ match: () => true, visibility: "hidden" }], [], driver)
+        .size,
+    ).toBe(0);
+  });
+
+  test("evaluates predicate rules without touching the driver", () => {
+    const driver = new Proxy({} as SpecDriver, {
+      get() {
+        throw new Error("driver should not be called for predicate-only rules");
+      },
+    });
+
+    const rules: ColumnOrderRule[] = [
+      { match: (spec) => spec.name === "alpha", priority: 10 },
+      { match: (spec) => spec.name === "beta", priority: 5 },
+    ];
+    const result = evaluateRules(
+      rules,
+      [
+        makeRuleColumn("a", { name: "alpha" }),
+        makeRuleColumn("b", { name: "beta" }),
+        makeRuleColumn("c", { name: "gamma" }),
+      ],
+      driver,
+    );
+
+    expect(result.get("a" as PObjectId)?.priority).toBe(10);
+    expect(result.get("b" as PObjectId)?.priority).toBe(5);
+    expect(result.has("c" as PObjectId)).toBe(false);
+  });
+
+  test("evaluates selector rules via PFrameSpec.discoverColumns", () => {
+    const driver = new SpecDriver();
+    const rules: ColumnVisibilityRule[] = [
+      { match: { name: "^note$" }, visibility: "hidden" },
+      { match: { name: "^score$" }, visibility: "optional" },
+    ];
+    const columns = [
+      makeRuleColumn("n", { name: "note" }),
+      makeRuleColumn("s", { name: "score" }),
+      makeRuleColumn("x", { name: "other" }),
+    ];
+
+    const result = evaluateRules(rules, columns, driver);
+
+    expect(result.get("n" as PObjectId)?.visibility).toBe("hidden");
+    expect(result.get("s" as PObjectId)?.visibility).toBe("optional");
+    expect(result.has("x" as PObjectId)).toBe(false);
+  });
+
+  test("preserves original rule order when predicate and selector rules are mixed", () => {
+    const driver = new SpecDriver();
+    const rules: ColumnOrderRule[] = [
+      { match: (spec) => spec.name === "alpha", priority: 100 },
+      { match: { name: "^alpha$" }, priority: 1 }, // shadowed by the predicate above
+      { match: { name: "^beta$" }, priority: 50 },
+    ];
+    const result = evaluateRules(
+      rules,
+      [makeRuleColumn("a", { name: "alpha" }), makeRuleColumn("b", { name: "beta" })],
+      driver,
+    );
+
+    expect(result.get("a" as PObjectId)?.priority).toBe(100);
+    expect(result.get("b" as PObjectId)?.priority).toBe(50);
+  });
+
+  test("dedupes columns by id before building spec frame (no duplicate-key crash)", () => {
+    const driver = new SpecDriver();
+    const rules: ColumnVisibilityRule[] = [{ match: { name: "^dup$" }, visibility: "hidden" }];
+    const dup = makeRuleColumn("d", { name: "dup" });
+
+    const result = evaluateRules(rules, [dup, dup, dup], driver);
+
+    expect(result.get("d" as PObjectId)?.visibility).toBe("hidden");
+  });
+});

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

@@ -1,10 +1,12 @@
 import {
   type PColumn,
   type PColumnSpec,
+  type PFrameSpecDriver,
   type PObjectId,
   Annotation,
   canonicalizeAxisId,
   canonicalizeJson,
+  DiscoveredPColumnId,
   getAxisId,
   readAnnotation,
   readAnnotationJson,
@@ -13,7 +15,14 @@ import {
   deriveDistinctLabels,
   type DeriveLabelsOptions,
 } from "../../../labels/derive_distinct_labels";
-import type { ColumnsDisplayOptions } from "./createPlDataTableV3";
+import {
+  deriveDistinctTooltips,
+  type TooltipEntry,
+} from "../../../labels/derive_distinct_tooltips";
+import type { MatchQualifications, MatchVariant } from "../../../columns";
+import type { ColumnMatcher, ColumnOrderRule, ColumnVisibilityRule } from "./createPlDataTableV3";
+import type { ColumnSelector } from "../../../columns";
+import { ArrayColumnProvider, ColumnCollectionBuilder } from "../../../columns";
 import { isNil } from "es-toolkit";
 
 /** Check if column should be omitted from the table */
@@ -26,36 +35,93 @@ export function isColumnOptional(spec: { annotations?: Annotation }): boolean {
   return readAnnotation(spec, Annotation.Table.Visibility) === "optional";
 }
 
-/** Get effective visibility for a column, considering display config rules first, then annotations. */
+/** Column shape consumed by rule evaluation. */
+export type RuleColumn = Pick<PColumn<PObjectId>, "id" | "spec">;
+
+/** Get effective visibility for a column. Rule map lookup first, then annotation fallback. */
 export function getEffectiveVisibility(
-  spec: PColumnSpec,
-  displayConfig?: ColumnsDisplayOptions,
+  col: RuleColumn,
+  visibilityByColId?: Map<PObjectId, ColumnVisibilityRule>,
 ): undefined | "default" | "optional" | "hidden" {
-  if (displayConfig?.visibility) {
-    for (const rule of displayConfig.visibility) {
-      if (rule.match(spec)) {
-        return rule.visibility;
-      }
-    }
-  }
-  if (isColumnHidden(spec)) return "hidden";
-  if (isColumnOptional(spec)) return "optional";
+  const rule = visibilityByColId?.get(col.id);
+  if (rule !== undefined) return rule.visibility;
+  if (isColumnHidden(col.spec)) return "hidden";
+  if (isColumnOptional(col.spec)) return "optional";
   return undefined;
 }
 
-/** Get ordering priority for a column. Display config rules first, then annotation fallback. */
+/** Get ordering priority for a column. Rule map lookup first, then annotation fallback. */
 export function getOrderPriority(
-  spec: PColumnSpec,
-  displayConfig?: ColumnsDisplayOptions,
+  col: RuleColumn,
+  orderByColId?: Map<PObjectId, ColumnOrderRule>,
 ): undefined | number {
-  if (displayConfig?.ordering) {
-    for (const rule of displayConfig.ordering) {
-      if (rule.match(spec)) {
-        return rule.priority;
+  const rule = orderByColId?.get(col.id);
+  if (rule !== undefined) return rule.priority;
+  return readAnnotationJson(col.spec, Annotation.Table.OrderPriority);
+}
+
+/**
+ * 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.
+ */
+export function evaluateRules<R extends { match: ColumnMatcher | ColumnSelector }>(
+  rules: R[],
+  columns: RuleColumn[],
+  pframeSpec: PFrameSpecDriver,
+): Map<PObjectId, R> {
+  const result = new Map<PObjectId, R>();
+  if (rules.length === 0 || columns.length === 0) return result;
+
+  const hasSelectorRules = rules.some((rule) => typeof rule.match !== "function");
+  const selectorHitsByRule = new Map<R, Set<PObjectId>>();
+
+  if (hasSelectorRules) {
+    const dedupedColumns = dedupeById(columns);
+    const pColumns = dedupedColumns.map((c) => ({ id: c.id, spec: c.spec, data: undefined }));
+    const collection = new ColumnCollectionBuilder(pframeSpec)
+      .addSource(new ArrayColumnProvider(pColumns))
+      .build();
+    if (collection === undefined) 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();
     }
   }
-  return readAnnotationJson(spec, Annotation.Table.OrderPriority);
+
+  for (const col of columns) {
+    for (const rule of rules) {
+      const matches =
+        typeof rule.match === "function"
+          ? rule.match(col.spec)
+          : (selectorHitsByRule.get(rule)?.has(col.id) ?? false);
+      if (matches) {
+        result.set(col.id, rule);
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+function dedupeById(columns: RuleColumn[]): RuleColumn[] {
+  const seen = new Set<PObjectId>();
+  const result: RuleColumn[] = [];
+  for (const col of columns) {
+    if (seen.has(col.id)) continue;
+    seen.add(col.id);
+    result.push(col);
+  }
+  return result;
 }
 
 /**
@@ -65,10 +131,9 @@ export function getOrderPriority(
  * 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.
  */
-export function withLabelAnnotations<Data>(
-  derivedLabels: undefined | Record<string, string>,
-  columns: PColumn<Data>[],
-): PColumn<Data>[] {
+export function withLabelAnnotations<
+  T extends { readonly id: PObjectId; readonly spec: PColumnSpec },
+>(derivedLabels: undefined | Record<string, string>, columns: T[]): T[] {
   if (derivedLabels === undefined) return columns;
   return columns.map((col) => {
     const colLabel = derivedLabels[col.id];
@@ -86,26 +151,29 @@ export function withLabelAnnotations<Data>(
             : { ...axis, annotations: { ...axis.annotations, [Annotation.Label]: label } };
         }),
       },
-    };
+    } as T;
   });
 }
 
 /**
- * Writes effective display properties (OrderPriority, Visibility) from ColumnDisplayOptions
+ * Writes effective display properties (OrderPriority, Visibility) from precomputed rule maps
  * into column annotations. Returns new column objects — originals are not mutated.
  */
-export function withTableVisualAnnotations<Data>(
-  displayOptions: undefined | ColumnsDisplayOptions,
-  columns: PColumn<Data>[],
-): PColumn<Data>[] {
-  if (displayOptions === undefined) return columns;
+export function withTableVisualAnnotations<
+  T extends { readonly id: PObjectId; readonly spec: PColumnSpec },
+>(
+  visibilityByColId: undefined | Map<PObjectId, ColumnVisibilityRule>,
+  orderByColId: undefined | Map<PObjectId, ColumnOrderRule>,
+  columns: T[],
+): T[] {
+  if (visibilityByColId === undefined && orderByColId === undefined) return columns;
   return columns.map((col) => {
     const annotations = { ...col.spec.annotations };
 
-    const visibility = getEffectiveVisibility(col.spec, displayOptions);
+    const visibility = getEffectiveVisibility(col, visibilityByColId);
     if (!isNil(visibility)) annotations[Annotation.Table.Visibility] = visibility;
 
-    const orderPriority = getOrderPriority(col.spec, displayOptions);
+    const orderPriority = getOrderPriority(col, orderByColId);
     if (!isNil(orderPriority)) annotations[Annotation.Table.OrderPriority] = String(orderPriority);
 
     return {
@@ -114,10 +182,49 @@ export function withTableVisualAnnotations<Data>(
         ...col.spec,
         annotations: annotations,
       },
-    };
+    } as T;
   });
 }
 
+/**
+ * Writes derived info annotations into column annotations.
+ * Columns without an info entry are passed through unchanged.
+ */
+export function withInfoAnnotations<
+  T extends { readonly id: PObjectId; readonly spec: PColumnSpec },
+>(infoById: undefined | Record<string, string>, columns: T[]): T[] {
+  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 },
+      },
+    } as T;
+  });
+}
+
+export function withHidenAxesAnnotations<T extends { readonly spec: PColumnSpec }>(
+  columns: T[],
+): T[] {
+  return columns.map(
+    (col) =>
+      ({
+        ...col,
+        spec: {
+          ...col.spec,
+          axesSpec: col.spec.axesSpec.map((axis) => ({
+            ...axis,
+            annotations: { ...axis.annotations, [Annotation.Table.Visibility]: "hidden" },
+          })),
+        },
+      }) as T,
+  );
+}
+
 /** Column shape required by label derivation. */
 export type LabelableColumn = {
   readonly id: PObjectId;
@@ -158,3 +265,51 @@ function deriveAxisLabels(
   }
   return result;
 }
+
+/** Column shape required by tooltip derivation. */
+export type TooltipableColumn = {
+  readonly id: DiscoveredPColumnId;
+  readonly spec: PColumnSpec;
+  readonly originalId: PObjectId;
+  readonly linkerPath?: MatchVariant["path"];
+  readonly qualifications?: MatchQualifications;
+  readonly distinctiveQualifications?: MatchQualifications;
+};
+
+/** Derive origin tooltips for columns whose qualifications or linker path carry info. */
+export function deriveAllTooltips(options: {
+  columns: TooltipableColumn[];
+}): Record<DiscoveredPColumnId, string> {
+  const { columns } = options;
+
+  const variantCountByOriginal = columns.reduce<Map<PObjectId, number>>((acc, c) => {
+    return acc.set(c.originalId, (acc.get(c.originalId) ?? 0) + 1);
+  }, new Map());
+
+  const { entries } = columns.reduce(
+    ({ entries, variantSeen }, c) => {
+      const variantCount = variantCountByOriginal.get(c.originalId);
+      const variantIndex =
+        (variantSeen.set(c.originalId, (variantSeen.get(c.originalId) ?? 0) + 1),
+        variantSeen.get(c.originalId));
+
+      entries.push({
+        spec: c.spec,
+        linkerPath: c.linkerPath,
+        qualifications: c.qualifications,
+        distinctiveQualifications: c.distinctiveQualifications,
+        variantIndex,
+        variantCount,
+      });
+
+      return { entries, variantSeen };
+    },
+    { entries: [] as TooltipEntry[], variantSeen: new Map<PObjectId, number>() },
+  );
+
+  const tooltips = deriveDistinctTooltips(entries);
+
+  return Object.fromEntries(
+    tooltips.flatMap((t, i) => (isNil(t) ? [] : [[columns[i].id, t] as const])),
+  );
+}

package/src/components/PlDataTable/labels.ts

@@ -4,22 +4,18 @@ import {
   isLabelColumn,
   matchAxisId,
   PColumnName,
-  Services,
-  type RequireServices,
 } from "@milaboratories/pl-model-common";
 import type { PColumnDataUniversal, RenderCtxBase } from "../../render";
 import { ColumnCollectionBuilder, collectCtxColumnSnapshotProviders } from "../../columns";
-import { throwError } from "@milaboratories/helpers";
 
 /**
  * Get all label columns visible in the current render context
  * (result pool + block outputs + prerun).
  */
-export function getAllLabelColumns<A, U, S extends RequireServices<typeof Services.PFrameSpec>>(
-  ctx: RenderCtxBase<A, U, S>,
+export function getAllLabelColumns<A, U>(
+  ctx: RenderCtxBase<A, U>,
 ): PColumn<PColumnDataUniversal>[] {
-  const pframeSpec =
-    ctx.services.pframeSpec ?? throwError("PFrameSpec service is required for label discovery.");
+  const pframeSpec = ctx.getService("pframeSpec");
   const collection = new ColumnCollectionBuilder(pframeSpec)
     .addSources(collectCtxColumnSnapshotProviders(ctx))
     .build({ allowPartialColumnList: true });