@platforma-sdk/model 1.80.13 → 1.81.0

package/src/columns/{expand_by_partition.test.ts → split_by_axes.test.ts}

@@ -13,9 +13,10 @@ import {
 } from "@milaboratories/pl-model-common";
 import { describe, expect, test } from "vitest";
 import type { PColumnDataUniversal } from "../render/internal";
-import type { ColumnLazy } from "./column_lazy";
-import { ColumnLazyImpl } from "./column_lazy";
-import { expandByPartition } from "./expand_by_partition";
+import type { DataColumnRecipe } from "./data_column";
+import { DataColumnImpl } from "./data_column";
+import type { SplitByAxesOpts } from "./split_by_axes";
+import { splitByAxes } from "./split_by_axes";
 
 // --- Helpers ---
 
@@ -33,13 +34,13 @@ function createSpec(name: string, axes: AxisSpec[]): PColumnSpec {
   } as PColumnSpec;
 }
 
-/** Build a synthetic ColumnLazy whose data is a JsonPartitioned DataInfoEntries. */
+/** Build a synthetic DataColumnRecipe whose data is a JsonPartitioned DataInfoEntries. */
 function createReadyLazy(
   id: string,
   spec: PColumnSpec,
   partitionKeyLength: number,
   parts: { key: (string | number)[]; value: unknown }[],
-): ColumnLazy {
+): DataColumnRecipe {
   const dataEntries: JsonPartitionedDataInfoEntries<unknown> = {
     type: "JsonPartitioned",
     partitionKeyLength,
@@ -48,15 +49,15 @@ function createReadyLazy(
   // `data` is typed `PColumnDataUniversal` but `getUniquePartitionKeys`
   // duck-types DataInfoEntries via `isDataInfoEntries`, so the JsonPartitioned
   // payload works at runtime.
-  return ColumnLazyImpl.fromColumn({
+  return DataColumnImpl.fromColumn({
     id: id as PObjectId,
     spec,
     data: dataEntries as unknown as PColumnDataUniversal,
   });
 }
 
-function createComputingLazy(id: string, spec: PColumnSpec): ColumnLazy {
-  return ColumnLazyImpl.fromColumn({
+function createComputingLazy(id: string, spec: PColumnSpec): DataColumnRecipe {
+  return DataColumnImpl.fromColumn({
     id: id as PObjectId,
     spec,
     data: undefined,
@@ -74,14 +75,21 @@ function extractTrace(recipe: { getSpec(): PColumnSpec }): Trace[] {
   return raw ? (JSON.parse(raw) as Trace[]) : [];
 }
 
+/**
+ * `axisValuesLabels` defaults to `deriveAxisValuesLabels()`, which needs the
+ * ambient render ctx these unit tests deliberately run without. Every case
+ * below is about the split itself, so opt out of label resolution explicitly.
+ */
+const NO_LABELS: SplitByAxesOpts = { axisValuesLabels: () => undefined };
+
 // --- Tests ---
 
-describe("expandByPartition", () => {
+describe("splitByAxes", () => {
   test("no split axes returns inputs unchanged", () => {
     const s = createReadyLazy("col1", createSpec("c", [createAxis("a")]), 1, [
       { key: ["x"], value: {} },
     ]);
-    const result = expandByPartition([s], []);
+    const result = splitByAxes([s], []);
     expect(result).toBeDefined();
     expect(result).toHaveLength(1);
     expect(result![0]).toBe(s); // same reference
@@ -99,7 +107,7 @@ describe("expandByPartition", () => {
       ],
     );
 
-    const result = expandByPartition([s], [{ idx: 0 }]);
+    const result = splitByAxes([s], [{ idx: 0 }], NO_LABELS);
     expect(result).toBeDefined();
     // unique values on axis 0: s1, s2 → 2 recipes
     expect(result).toHaveLength(2);
@@ -124,7 +132,7 @@ describe("expandByPartition", () => {
       ],
     );
 
-    const result = expandByPartition([s], [{ idx: 0 }, { idx: 1 }]);
+    const result = splitByAxes([s], [{ idx: 0 }, { idx: 1 }], NO_LABELS);
     expect(result).toBeDefined();
     // a: a1, a2 (2) × b: b1, b2 (2) = 4
     expect(result).toHaveLength(4);
@@ -148,7 +156,7 @@ describe("expandByPartition", () => {
       ],
     );
 
-    const result = expandByPartition([s], [{ idx: 0 }]);
+    const result = splitByAxes([s], [{ idx: 0 }], NO_LABELS);
     expect(result).toBeDefined();
     expect(result).toHaveLength(2);
 
@@ -183,7 +191,7 @@ describe("expandByPartition", () => {
     };
     const s = createReadyLazy("col1", spec, 1, [{ key: ["s1"], value: {} }]);
 
-    const result = expandByPartition([s], [{ idx: 0 }]);
+    const result = splitByAxes([s], [{ idx: 0 }], NO_LABELS);
     expect(result).toBeDefined();
     expect(result).toHaveLength(1);
 
@@ -205,7 +213,7 @@ describe("expandByPartition", () => {
       s2: "Sample Two",
     };
 
-    const result = expandByPartition([s], [{ idx: 0 }], {
+    const result = splitByAxes([s], [{ idx: 0 }], {
       axisValuesLabels: () => labels,
     });
 
@@ -216,7 +224,7 @@ describe("expandByPartition", () => {
 
   test("computing input (data undefined) returns undefined", () => {
     const s = createComputingLazy("col1", createSpec("c", [createAxis("a")]));
-    const result = expandByPartition([s], [{ idx: 0 }]);
+    const result = splitByAxes([s], [{ idx: 0 }], NO_LABELS);
     expect(result).toBeUndefined();
   });
 
@@ -228,7 +236,7 @@ describe("expandByPartition", () => {
       [], // no parts → no unique keys
     );
 
-    const result = expandByPartition([s], [{ idx: 0 }]);
+    const result = splitByAxes([s], [{ idx: 0 }], NO_LABELS);
     expect(result).toBeDefined();
     expect(result).toHaveLength(0);
   });
@@ -244,7 +252,7 @@ describe("expandByPartition", () => {
       ],
     );
 
-    const result = expandByPartition([s], [{ idx: 0 }]);
+    const result = splitByAxes([s], [{ idx: 0 }], NO_LABELS);
     expect(result).toBeDefined();
     expect(result).toHaveLength(2);
 
@@ -274,7 +282,7 @@ describe("expandByPartition", () => {
       ],
     );
 
-    const result = expandByPartition([s], [{ idx: 0 }]);
+    const result = splitByAxes([s], [{ idx: 0 }], NO_LABELS);
     expect(result).toBeDefined();
     expect(result).toHaveLength(2);
 
@@ -306,7 +314,7 @@ describe("expandByPartition", () => {
       ],
     );
 
-    const result = expandByPartition([s1, s2], [{ idx: 0 }]);
+    const result = splitByAxes([s1, s2], [{ idx: 0 }], NO_LABELS);
     expect(result).toBeDefined();
     // s1: 2 unique + s2: 3 unique = 5 total
     expect(result).toHaveLength(5);
@@ -320,6 +328,6 @@ describe("expandByPartition", () => {
       [{ key: ["x"], value: {} }],
     );
 
-    expect(() => expandByPartition([s], [{ idx: 1 }])).toThrow(/Not enough partition keys/);
+    expect(() => splitByAxes([s], [{ idx: 1 }], NO_LABELS)).toThrow(/Not enough partition keys/);
   });
 });

package/src/columns/{expand_by_partition.ts → split_by_axes.ts}

@@ -13,11 +13,12 @@ import {
 } from "@milaboratories/pl-model-common";
 import { TreeNodeAccessor } from "../render/accessor";
 import { getUniquePartitionKeys } from "../render/util/pcolumn_data";
+import { deriveAxisValuesLabels } from "./derive_axis_values_labels";
 import type { ColumnRecipe } from "./column_recipes";
 import { ColumnFilteredRecipe } from "./column_recipes/column_filtered_recipe";
 import { ColumnOverriddenRecipe } from "./column_recipes/column_overrided_recipe";
 import { Column } from "./column";
-import { getLeafColumnData } from "./utils";
+import { hasReachableData } from "./utils";
 
 // --- Types ---
 
@@ -26,8 +27,15 @@ export interface SplitAxis {
   readonly idx: number;
 }
 
-export interface ExpandByPartitionOpts {
-  /** Resolve axis values to human-readable labels. */
+export interface SplitByAxesOpts {
+  /**
+   * Resolve axis values to human-readable labels.
+   *
+   * Defaults to {@link deriveAxisValuesLabels} over the ambient render ctx
+   * (current block outputs + result pool), resolved lazily on the first
+   * lookup. Pass an explicit callback to narrow the label source, or
+   * `() => undefined` to keep raw axis values.
+   */
   axisValuesLabels?: (axisId: AxisId) => undefined | Record<string | number, string>;
 }
 
@@ -36,8 +44,11 @@ export interface ExpandByPartitionOpts {
 const MAX_KEY_COMBINATIONS = 10_000;
 
 /**
- * Expand each input column along the requested partition axes into one
- * {@link ColumnRecipe} per Cartesian combination of unique partition values.
+ * Split each input column along the requested axes into one
+ * {@link ColumnRecipe} per Cartesian combination of the axes' distinct values.
+ *
+ * The split axes must be partition-key axes of the input's data — the distinct
+ * values are read off the partition keys.
  *
  * Each split is produced as `ColumnOverriddenRecipe.wrap(ColumnFilteredRecipe.wrap(inner, axisFilters), { domain, annotations })`:
  *   - `ColumnFilteredRecipe` pins all split axes at once (one wrap call with
@@ -55,22 +66,24 @@ const MAX_KEY_COMBINATIONS = 10_000;
  * Returns `undefined` when any input's `getData()` is not a
  * {@link TreeNodeAccessor} — partition inspection is not yet possible.
  */
-export function expandByPartition(
+export function splitByAxes(
   inputs: Column[],
   splitAxes: SplitAxis[],
-  opts?: ExpandByPartitionOpts,
+  opts?: SplitByAxesOpts,
 ): ColumnRecipe[] | undefined {
   if (splitAxes.length === 0) {
     return [...inputs];
   }
 
+  const axisValuesLabels = opts?.axisValuesLabels ?? deriveAxisValuesLabels();
+
   const splitAxisIdxs = splitAxes.map((a) => a.idx).sort((a, b) => a - b);
   const maxSplitIdx = splitAxisIdxs[splitAxisIdxs.length - 1];
 
   const result: ColumnRecipe[] = [];
 
   for (const inner of inputs) {
-    const data = getLeafColumnData(inner);
+    const data = hasReachableData(inner) ? inner.getData() : undefined;
     // Partition inspection requires either a live tree-accessor or already
     // parsed DataInfoEntries. Anything else means the input is not yet ready.
     if (!(data instanceof TreeNodeAccessor) && !isDataInfoEntries(data)) {
@@ -90,7 +103,7 @@ export function expandByPartition(
     const axesSpec = spec.axesSpec;
     const splitAxisSpecs = splitAxisIdxs.map((idx) => axesSpec[idx]);
     const splitAxisIds = splitAxisSpecs.map((axisSpec) => getAxisId(axisSpec));
-    const axesLabels = splitAxisIds.map((axisId) => opts?.axisValuesLabels?.(axisId));
+    const axesLabels = splitAxisIds.map((axisId) => axisValuesLabels(axisId));
 
     const existingTraceRaw = readAnnotation(spec, Annotation.Trace);
     const baseTrace: TraceEntry[] = existingTraceRaw

package/src/columns/utils.ts

@@ -11,10 +11,13 @@ import { throwError } from "@milaboratories/helpers";
 import type { GlobalCfgRenderCtx } from "../render/internal";
 import { TreeNodeAccessor } from "../render";
 import { deriveDistinctLabels, type DeriveLabelsOptions } from "../labels/derive_distinct_labels";
-import { ColumnLazy, ColumnLazyImpl, type ColumnLazyData } from "./column_lazy";
+import { DataColumnRecipe, DataColumnImpl, type ColumnData } from "./data_column";
 import { ColumnDiscoveredRecipe } from "./column_recipes/column_discovered_recipe";
 import { ColumnFilteredRecipe } from "./column_recipes/column_filtered_recipe";
-import { ColumnOverriddenRecipe } from "./column_recipes/column_overrided_recipe";
+import {
+  ColumnOverriddenRecipe,
+  DataColumnOverriddenRecipe,
+} from "./column_recipes/column_overrided_recipe";
 import type { ColumnRecipe } from "./column_recipes/types";
 import { ColumnsCollection, isColumnsCollection } from "./columns_collection";
 import type { ColumnsSource } from "./column_providers/types";
@@ -26,7 +29,7 @@ import type { ColumnsSource } from "./column_providers/types";
  * other engine-consumed column.
  *
  * Pure query walk — no registry access. Use {@link collectLinkerColumns} for
- * the resolved {@link ColumnLazy} variant.
+ * the resolved {@link DataColumnRecipe} variant.
  */
 export function collectLinkerIds(recipe: ColumnRecipe): PObjectId[] {
   const hit = extractPObjectId(recipe.id);
@@ -47,16 +50,16 @@ export function collectLinkerIds(recipe: ColumnRecipe): PObjectId[] {
 
 /**
  * {@link collectLinkerIds} resolved against the ambient context as
- * {@link ColumnLazy} instances. Throws if any id fails to resolve —
+ * {@link DataColumnRecipe} leaves. Throws if any id fails to resolve —
  * matches the contract of the legacy `resolveLinkers` it replaces.
  */
 export function collectLinkerColumns(
   recipe: ColumnRecipe,
   opts: { ctx?: GlobalCfgRenderCtx } = {},
-): ColumnLazy[] {
+): DataColumnRecipe<PObjectId>[] {
   return collectLinkerIds(recipe).map(
     (id) =>
-      ColumnLazyImpl.fromId(id, opts) ??
+      DataColumnImpl.fromId(id, opts) ??
       throwError(`materializeLinkers: linker ${id} not resolvable`),
   );
 }
@@ -95,7 +98,7 @@ export function queriesQualifications(
  *
  * Walks every physical leaf the recipe depends on via
  * {@link ColumnRecipe.getReferencedIds} (resolves each id back to a
- * {@link ColumnLazy} through the ambient ctx) and ANDs `hasData()` across
+ * {@link DataColumnRecipe} through the ambient ctx) and ANDs `hasData()` across
  * all of them. Inline {@link PColumnValues} payloads count as present.
  *
  * Returns `false` if any leaf cannot be re-resolved in `opts.ctx` (treat as
@@ -107,15 +110,15 @@ export function hasColumnData(
   opts: { ctx?: GlobalCfgRenderCtx } = {},
 ): boolean {
   for (const id of recipe.getReferencedIds()) {
-    const lazy = ColumnLazyImpl.fromId(id, opts);
-    if (lazy === undefined) return false;
-    if (lazy.getDataStatus() !== "present") return false;
-    if (!isLazyDataPresent(lazy.getData())) return false;
+    const leaf = DataColumnImpl.fromId(id, opts);
+    if (leaf === undefined) return false;
+    if (leaf.getDataStatus() !== "present") return false;
+    if (!isLeafDataPresent(leaf.getData())) return false;
   }
   return true;
 }
 
-function isLazyDataPresent(data: ColumnLazyData): boolean {
+function isLeafDataPresent(data: ColumnData): boolean {
   if (data === undefined) return false;
   if (Array.isArray(data)) return true;
   if (data instanceof TreeNodeAccessor) return data.hasData();
@@ -151,51 +154,53 @@ function findDiscovered(recipe: ColumnRecipe): undefined | ColumnDiscoveredRecip
 }
 
 /**
- * A recipe is a "leaf" (directly co-indexed on the anchor, reached without a
- * linker chain) iff its wrapper chain contains no {@link ColumnDiscoveredRecipe}.
+ * Whether the recipe reads exactly one data column — its own — rather than
+ * reaching through others.
+ *
+ * True for a bare leaf and for projections over one (spec overrides, axis
+ * slicing): those add layers but no new columns. False when the recipe gets at
+ * its data through further columns, which happens when discovery reached it via
+ * a linker chain.
  *
- * `Filtered` / `Overridden` over a bare leaf stay leaves; anything wrapping a
- * `Discovered` (e.g. `Overridden(Discovered(...))`) is linked. Use this — not an
- * `instanceof ColumnLazyImpl` check — to split direct vs. linker-joined columns,
- * since projections over a plain leaf are still direct.
+ * **Why callers care.** A recipe over a single data column is co-indexed by its
+ * own axes, so its spec is the whole truth about them. One that needs other
+ * columns only lines up after they are joined in, and therefore drags axes into
+ * the join that its own spec never mentions — which is why it cannot serve as a
+ * primary column, and why `createPlDataTableV3` splits on this.
+ *
+ * The count comes from {@link ColumnRecipe.getReferencedIds}, which resolves
+ * through the whole wrapper chain, so no class walk is involved and foreign
+ * `ColumnRecipe` implementations are handled too.
  */
-export function isLeafColumn(recipe: ColumnRecipe): boolean {
-  return findDiscovered(recipe) === undefined;
+export function hasSingleDataColumn(recipe: ColumnRecipe): boolean {
+  return recipe.getReferencedIds().length === 1;
 }
 
 /**
- * Data of the bare leaf a "leaf" recipe bottoms out at — reads the leaf-only
- * {@link ColumnLazy.getData} after walking the wrapper chain down via
- * {@link extractLeafColumn}. Returns `undefined` when the recipe is not a leaf (its
- * chain reaches a {@link ColumnDiscoveredRecipe}); the symmetric counterpart
- * of {@link isLeafColumn} returning `false`.
+ * @deprecated Renamed to {@link hasSingleDataColumn} — "leaf" read as "you can
+ * get data out of it", which is a different question (see
+ * {@link hasReachableData}). Same semantics.
  */
-export function getLeafColumnData(recipe: ColumnRecipe): ColumnLazyData {
-  if (!isLeafColumn(recipe)) {
-    throw new Error(`getLeafColumnData: recipe ${recipe.id} is not a leaf column`);
-  }
-  return extractLeafColumn(recipe)?.getData();
-}
+export const isLeafColumn = hasSingleDataColumn;
 
 /**
- * Walk wrapper layers (Overridden, Filtered) down to the bare {@link ColumnLazy}
- * leaf the chain bottoms out at. Returns `undefined` if the chain reaches a
- * {@link ColumnDiscoveredRecipe} instead — i.e. the recipe is not a leaf
- * ({@link isLeafColumn} would return `false`). Mirror of {@link findDiscovered}.
+ * Whether the column's data can be read here and now, consistent with its
+ * spec — narrows to {@link DataColumnRecipe}, which exposes `getData()`.
+ *
+ * True for a bare leaf and for a spec-override over a bare leaf. False for an
+ * axis-filtered recipe (its spec has dropped axes the underlying data still
+ * carries, so the two no longer line up) and for anything reached through
+ * other columns (nothing to read until the engine joins them). In both of
+ * those cases the data exists only engine-side: pass `recipe.id` to
+ * `createPFrame` / `createPTable` instead of trying to read it.
+ *
+ * The distinction is settled when the recipe is built, not here — recipes that
+ * carry data are instances of a class that declares `getData`. So a `true`
+ * result narrows to a value that really has the method, and there is no
+ * throwing path behind the guard.
  */
-function extractLeafColumn(recipe: ColumnRecipe): undefined | ColumnLazy {
-  let current: ColumnRecipe = recipe;
-  while (true) {
-    if (current instanceof ColumnLazyImpl) return current;
-    if (current instanceof ColumnOverriddenRecipe || current instanceof ColumnFilteredRecipe) {
-      current = current.getInner();
-      continue;
-    }
-    if (current instanceof ColumnDiscoveredRecipe) {
-      throw new Error(`extractLeafColumn: recipe ${recipe.id} is not a leaf column`);
-    }
-    throw new Error(`extractLeafColumn: unrecognized recipe layer for ${recipe.id}`);
-  }
+export function hasReachableData(recipe: ColumnRecipe): recipe is DataColumnRecipe {
+  return recipe instanceof DataColumnImpl || recipe instanceof DataColumnOverriddenRecipe;
 }
 
 /** Drop-down option built over a {@link ColumnsCollection} — universal-id valued. */

package/src/components/PlDataTable/columnResolver.test.ts

@@ -9,7 +9,7 @@ import {
   type PTableColumnId,
   type SUniversalPColumnId,
 } from "@milaboratories/pl-model-common";
-import { ColumnLazyImpl } from "../../columns";
+import { DataColumnImpl } from "../../columns";
 import type { ColumnRecipe } from "../../columns";
 import { createColumnResolver } from "./columnResolver";
 
@@ -20,7 +20,7 @@ function wrap(id: PObjectId | SUniversalPColumnId, tag: string): SUniversalPColu
   });
 }
 
-// ColumnLazy constructor pulls `getCfgRenderCtx()` from globalThis on some
+// DataColumnRecipe constructor pulls `getCfgRenderCtx()` from globalThis on some
 // paths — keep a minimal mock the same way p_column_lazy.test.ts does.
 const mockCtx = {
   getAccessorHandleByName: () => undefined,
@@ -36,7 +36,7 @@ afterEach(() => {
 
 function lazyOf(id: PObjectId, axes: AxisSpec[] = []) {
   const spec = { kind: "PColumn", name: "stub", axesSpec: axes } as unknown as PColumnSpec;
-  return ColumnLazyImpl.fromColumn({
+  return DataColumnImpl.fromColumn({
     id,
     spec,
     data: undefined,

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

@@ -10,7 +10,7 @@ import type { PColumnDataUniversal } from "../../../render";
 import { isFunction } from "es-toolkit";
 import type { PlDataTableFilters } from "../typesV8";
 import { createPTableDefV3 } from "./createPTableDefV3";
-import { ColumnLazyImpl } from "../../../columns";
+import { DataColumn } from "../../../columns";
 
 export function createPTableDefV2(params: {
   columns: PColumn<undefined | PColumnDataUniversal>[];
@@ -33,8 +33,8 @@ export function createPTableDefV2(params: {
   secondaryColumns.push(...params.labelColumns);
 
   return createPTableDefV3({
-    primary: coreColumns.map((column) => ColumnLazyImpl.fromColumn(column)),
-    secondary: secondaryColumns.map((column) => ColumnLazyImpl.fromColumn(column)),
+    primary: coreColumns.map((column) => DataColumn.fromColumn(column)),
+    secondary: secondaryColumns.map((column) => DataColumn.fromColumn(column)),
     primaryJoinType: params.coreJoinType,
     filters: params.filters,
     sorting: params.sorting,

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

@@ -31,7 +31,7 @@ import { getMatchingLabelColumns } from "../labels";
 import { collectFilterSpecColumns, traverseFilterSpec } from "../../../filters/traverse";
 import { createPTableDefV2 } from "./createPTableDefV2";
 import { isColumnOptional } from "./utils";
-import { ColumnLazyImpl } from "../../../columns";
+import { DataColumn } from "../../../columns";
 import { createColumnResolver, type ColumnResolver } from "../columnResolver";
 import { isNil, type Nil } from "@milaboratories/helpers";
 
@@ -83,7 +83,7 @@ export function createPlDataTableV2<A, U>(
   const fullColumns = [...columns, ...fullLabelColumns];
 
   const resolver = createColumnResolver(
-    fullColumns.map((c) => ColumnLazyImpl.fromColumn(c)),
+    fullColumns.map((c) => DataColumn.fromColumn(c)),
     { warn: ctx.logWarn.bind(ctx) },
   );
 

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

@@ -27,7 +27,7 @@ import { upgradePlDataTableStateV2 } from "../state-migration";
 import type { PlDataTableStateV2 } from "../state-migration";
 import type { MatchingMode } from "@milaboratories/pl-model-common";
 import {
-  isLeafColumn,
+  hasSingleDataColumn,
   hitQualifications,
   collectLinkerColumns,
   queriesQualifications,
@@ -261,7 +261,7 @@ function splitByTopology(columns: ColumnRecipe[]): {
   const direct: ColumnRecipe[] = [];
   const linked: ColumnRecipe[] = [];
   for (const c of columns) {
-    if (isLeafColumn(c)) direct.push(c);
+    if (hasSingleDataColumn(c)) direct.push(c);
     else linked.push(c);
   }
   return { direct, linked };

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, isLeafColumn } from "../../../columns";
+import { ColumnsCollection, hasSingleDataColumn } from "../../../columns";
 import type { ColumnsSelectorConfig } from "./createPlDataTableV3";
 
 export type DiscoverTableColumnOptions = {
@@ -38,7 +38,7 @@ export function discoverTableColumns(
   const primary: ColumnRecipe[] = [];
   const secondary: ColumnRecipe[] = [];
   for (const col of discoveredColumns) {
-    if (isLeafColumn(col)) primary.push(col);
+    if (hasSingleDataColumn(col)) primary.push(col);
     else secondary.push(col);
   }
   return { primary, secondary };

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

@@ -7,7 +7,7 @@ import {
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { deriveAllLabels, evaluateRules, type LabelableColumn } from "./utils";
 import type { ColumnOrderRule, ColumnVisibilityRule } from "./createPlDataTableV3";
-import { ColumnLazy } from "../../../columns";
+import { DataColumn, type DataColumnRecipe } from "../../../columns";
 import {
   createTestCollectionDriver,
   type TestCollectionDriverHandle,
@@ -156,11 +156,11 @@ function gid(name: string): PObjectId {
   return createGlobalPObjectId("test-block", name);
 }
 
-function makeLazyColumn(name: string, spec: Partial<PColumnSpec> = {}): ColumnLazy {
+function makeLazyColumn(name: string, spec: Partial<PColumnSpec> = {}): DataColumnRecipe {
   const s = makeSpec({ axesSpec: [{ name: "id", type: "String" }], ...spec });
   const id = gid(name);
   driverHandle.register([{ id, spec: s }]);
-  return ColumnLazy.fromColumn({ id, spec: s, data: undefined as never });
+  return DataColumn.fromColumn({ id, spec: s, data: undefined as never });
 }
 
 describe("evaluateRules", () => {

package/src/components/PlDatasetSelector/enrichment_discovery.ts

@@ -15,7 +15,7 @@ import type {
 } from "@milaboratories/pl-model-common";
 import type { ColumnRecipe, ColumnsSource } from "../../columns";
 import {
-  isLeafColumn,
+  hasSingleDataColumn,
   ColumnsCollection,
   collectLinkerIds,
   hitQualifications,
@@ -67,7 +67,7 @@ export function findEnrichmentColumns(options: FindEnrichmentColumnsOptions): Co
 
   const predicate = options.predicate;
   return columns.filter((v) => {
-    if (isLeafColumn(v)) return false;
+    if (hasSingleDataColumn(v)) return false;
     if (predicate !== undefined && !predicate(v.getSpec())) return false;
     if (!isGlobalPObjectId(extractPObjectId(v.id))) return false;
     if (collectLinkerIds(v).some((id) => !isGlobalPObjectId(id))) return false;

package/dist/columns/column_lazy.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"column_lazy.cjs","names":["ColumnOverriddenRecipe","ColumnRegistry","getCtxProviders","LRUCache"],"sources":["../../src/columns/column_lazy.ts"],"sourcesContent":["import {\n  ColumnRegistry,\n  createGlobalPObjectId,\n  isPColumn,\n  isPlRef,\n  PlRef,\n  PObjectId,\n  type ColumnUniversalId,\n  type LeafEntry,\n  type PColumn,\n  type PColumnSpec,\n  type SpecOverrides,\n  type SpecQuery,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx, PColumnDataUniversal } from \"../render/internal\";\nimport { getCtxProviders } from \"./column_providers\";\nimport { isNil } from \"es-toolkit\";\nimport { LRUCache } from \"lru-cache\";\nimport { TreeNodeAccessor } from \"../render\";\nimport type {\n  ColumnFieldStatus,\n  ColumnRecipe,\n  ColumnResolutionStatus,\n} from \"./column_recipes/types\";\nimport { ColumnOverriddenRecipe } from \"./column_recipes/column_overrided_recipe\";\n\nexport type ColumnLazyId = PObjectId;\nexport type ColumnLazyData = undefined | PColumnDataUniversal;\nexport type { ColumnFieldStatus, ColumnResolutionStatus } from \"./column_recipes/types\";\n\n/**\n * Thrown by leaf-recipe factories when the requested column is provably\n * absent in the active render ctx — i.e. every relevant accessor reports\n * `inputsLocked` and the column did not appear. Distinct from the\n * `undefined` return that the factories still use for the \"resolving\" case\n * (the column may still appear later).\n *\n * Catch at the boundary (resolver / filter+sort wiring / data-table assembly)\n * when partial absence should be surfaced to the user rather than silently\n * producing an empty result.\n */\nexport class ColumnAbsentError extends Error {\n  constructor(public readonly id: ColumnUniversalId) {\n    super(`Column is absent in the active render ctx and will not appear: ${id}`);\n    this.name = \"ColumnAbsentError\";\n  }\n}\n\n/**\n * ColumnLazy is the leaf-recipe building block: a {@link ColumnRecipe} whose\n * `id` is a bare {@link PObjectId} and whose readers are bound to a single\n * tree-accessor leaf. Layered encodings (Overridden / Discovered / Filtered)\n * are reified through their dedicated recipe classes and reference leaf\n * columns by id.\n */\nexport class ColumnLazyImpl implements ColumnRecipe<PObjectId> {\n  private specCache?: { readonly value: PColumnSpec };\n  private dataCache?: { readonly value: ColumnLazyData };\n  private dataStatusCache?: { readonly value: ColumnFieldStatus };\n\n  private constructor(\n    public readonly id: PObjectId,\n    private readonly options: {\n      getSpec: () => PColumnSpec;\n      getData: () => ColumnLazyData;\n      getDataStatus: () => ColumnFieldStatus;\n    },\n  ) {}\n\n  /** A leaf-recipe references exactly one column — its own id. */\n  getReferencedIds(): PObjectId[] {\n    return [this.id];\n  }\n\n  getSpec(): PColumnSpec {\n    if (this.specCache === undefined) {\n      this.specCache = { value: this.options.getSpec() };\n    }\n    return this.specCache.value;\n  }\n\n  /** Leaf-shaped — points straight at `this.id`. */\n  getQuery(): SpecQuery {\n    return { type: \"column\", column: this.id } as SpecQuery;\n  }\n\n  /** Leaf-only: not on the recipe interface — only the leaf can read data directly. */\n  getData(): ColumnLazyData {\n    if (this.dataCache === undefined) this.dataCache = { value: this.options.getData() };\n    return this.dataCache.value;\n  }\n\n  getDataStatus(): ColumnFieldStatus {\n    if (this.dataStatusCache === undefined) {\n      this.dataStatusCache = { value: this.options.getDataStatus() };\n    }\n    return this.dataStatusCache.value;\n  }\n\n  /**\n   * Overlay overrides → produces a {@link ColumnOverriddenRecipe} wrapping\n   * this leaf. ColumnLazy itself stays bare (id remains a plain PObjectId);\n   * layering lives entirely in the recipe wrappers.\n   */\n  withSpecs(overrides: SpecOverrides): ColumnRecipe {\n    return ColumnOverriddenRecipe.wrap(this, overrides);\n  }\n\n  /**\n   * Resolve via the ambient {@link ColumnRegistry}. Spec is resolved eagerly:\n   * returns `undefined` if the leaf isn't reachable yet (resolving). Throws\n   * {@link ColumnAbsentError} when every relevant accessor is `inputsLocked`\n   * and the column did not appear — the column will not exist in this ctx.\n   * Data and dataStatus stay lazy.\n   */\n  static fromId(id: PObjectId, { ctx }: { ctx?: GlobalCfgRenderCtx } = {}): undefined | ColumnLazy {\n    const registry = new ColumnRegistry(getCtxProviders({ ctx }));\n    const leaf = registry.resolve(id);\n    if (isNil(leaf)) {\n      if (registry.isFinal()) throw new ColumnAbsentError(id);\n      return undefined;\n    }\n    const spec = readSpecAccessor(leaf);\n    if (isNil(spec)) {\n      if (leaf.accessor.getInputsLocked()) throw new ColumnAbsentError(id);\n      return undefined;\n    }\n    if (!spec.hasData()) return undefined;\n    return new ColumnLazyImpl(id, {\n      getSpec: () => spec.getDataAsJson<PColumnSpec>(),\n      getData: () => readDataAccessor(leaf),\n      getDataStatus: () => readDataStatus(leaf),\n    });\n  }\n\n  /** {@link PlRef} wrapper over {@link fromId}. */\n  static fromPlRef(ref: PlRef): undefined | ColumnLazy {\n    return ColumnLazyImpl.fromId(createGlobalPObjectId(ref.blockId, ref.name));\n  }\n\n  /**\n   * Bind directly to an accessor-backed {@link LeafEntry} — no registry.\n   * Throws {@link ColumnAbsentError} if the leaf has no spec field and its\n   * accessor is `inputsLocked`. Returns `undefined` while still resolving.\n   */\n  static fromAccessor(entry: LeafEntry<TreeNodeAccessor>): undefined | ColumnLazy {\n    const spec = readSpecAccessor(entry);\n    if (isNil(spec)) {\n      if (entry.accessor.getInputsLocked()) throw new ColumnAbsentError(entry.id);\n      return undefined;\n    }\n    if (!spec.hasData()) return undefined;\n    return new ColumnLazyImpl(entry.id, {\n      getSpec: () => spec.getDataAsJson<PColumnSpec>(),\n      getData: () => readDataAccessor(entry),\n      getDataStatus: () => readDataStatus(entry),\n    });\n  }\n\n  /**\n   * Wrap a materialised {@link PColumn}. If the input is already a\n   * {@link ColumnLazy} it is returned as-is.\n   */\n  static fromColumn(column: PColumn<ColumnLazyData> | ColumnLazy): ColumnLazy {\n    if (column instanceof ColumnLazyImpl) return column;\n    return new ColumnLazyImpl(column.id, {\n      getSpec: () => column.spec,\n      getData: () => column.data,\n      getDataStatus: () => \"present\",\n    });\n  }\n\n  /**\n   * Distinguishes `present` / `resolving` / `absent` for a {@link PObjectId}\n   * in the active render ctx. Falls back to the registry's `isFinal()`\n   * when the id has no entry — only then we can say `absent` instead of\n   * `resolving`.\n   */\n  static getStatusById(\n    id: PObjectId,\n    { ctx }: { ctx?: GlobalCfgRenderCtx } = {},\n  ): ColumnResolutionStatus {\n    const registry = new ColumnRegistry(getCtxProviders({ ctx }));\n    const leaf = registry.resolve(id);\n    if (isNil(leaf)) return registry.isFinal() ? \"absent\" : \"resolving\";\n    return getLeafEntryStatus(leaf);\n  }\n\n  /** {@link PlRef} wrapper over {@link getStatusById}. */\n  static getStatusByPlRef(\n    ref: PlRef,\n    opts: { ctx?: GlobalCfgRenderCtx } = {},\n  ): ColumnResolutionStatus {\n    return ColumnLazyImpl.getStatusById(createGlobalPObjectId(ref.blockId, ref.name), opts);\n  }\n\n  /** No registry — reads straight off the entry's accessor. */\n  static getStatusByAccessor(entry: LeafEntry<TreeNodeAccessor>): ColumnResolutionStatus {\n    return getLeafEntryStatus(entry);\n  }\n}\n\n/**\n * Public type alias — `ColumnLazy` (the type) refers to the underlying\n * {@link ColumnLazyImpl} class instance. `ColumnLazy` (the value) is the\n * callable below with the static factories attached.\n */\nexport type ColumnLazy = ColumnLazyImpl;\n\n/**\n * Unified dispatcher — picks the right `ColumnLazyImpl.fromX` by source\n * shape. For ambiguous inputs callers can still use the explicit factories\n * (also attached as properties: `ColumnLazy.fromId`, `.fromPlRef`,\n * `.fromAccessor`, `.fromColumn`).\n */\nfunction ColumnLazyDispatch(\n  source: PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnLazyData> | ColumnLazy,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): undefined | ColumnLazy {\n  if (typeof source === \"string\") return ColumnLazyImpl.fromId(source, opts);\n  if (source instanceof ColumnLazyImpl) return source;\n  if (\"accessor\" in source) return ColumnLazyImpl.fromAccessor(source);\n  if (isPlRef(source)) return ColumnLazyImpl.fromPlRef(source);\n  if (isPColumn(source)) return ColumnLazyImpl.fromColumn(source);\n  throw new Error(\"ColumnLazy: unknown source shape\");\n}\n\n/**\n * Polymorphic counterpart to {@link ColumnLazyDispatch}: returns the\n * {@link ColumnResolutionStatus} for any factory input without constructing\n * the recipe. For already-materialised sources ({@link PColumn} value,\n * existing {@link ColumnLazy}) status is `present` by construction.\n */\nfunction ColumnLazyGetStatus(\n  source: PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnLazyData> | ColumnLazy,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): ColumnResolutionStatus {\n  if (typeof source === \"string\") return ColumnLazyImpl.getStatusById(source, opts);\n  if (source instanceof ColumnLazyImpl) return \"present\";\n  if (\"accessor\" in source) return ColumnLazyImpl.getStatusByAccessor(source);\n  if (isPlRef(source)) return ColumnLazyImpl.getStatusByPlRef(source, opts);\n  if (isPColumn(source)) return \"present\";\n  throw new Error(\"ColumnLazy.getStatus: unknown source shape\");\n}\n\nexport const ColumnLazy = Object.assign(ColumnLazyDispatch, {\n  fromId: ColumnLazyImpl.fromId,\n  fromPlRef: ColumnLazyImpl.fromPlRef,\n  fromAccessor: ColumnLazyImpl.fromAccessor,\n  fromColumn: ColumnLazyImpl.fromColumn,\n  getStatus: ColumnLazyGetStatus,\n  getStatusById: ColumnLazyImpl.getStatusById,\n  getStatusByPlRef: ColumnLazyImpl.getStatusByPlRef,\n  getStatusByAccessor: ColumnLazyImpl.getStatusByAccessor,\n});\n\n/**\n * Type-guard narrowing to the leaf recipe. Prefer this over\n * `instanceof ColumnLazyImpl` — `ColumnLazy` (the value) is the dispatcher\n * with statics, not the class, so `instanceof` requires the impl symbol.\n */\nexport function isColumnLazy(value: unknown): value is ColumnLazy {\n  return value instanceof ColumnLazyImpl;\n}\n\nconst readSpecAccessor = memoizeByEntry(\n  ({ accessor, name }: LeafEntry<TreeNodeAccessor>): undefined | TreeNodeAccessor =>\n    accessor.traverse({ field: `${name}.spec`, assertFieldType: \"Input\", ignoreError: true }),\n);\n\n/**\n * Per-entry counterpart to {@link readDataStatus}: tells whether the leaf's\n * **spec** can be read in this ctx, and — for the negative cases —\n * distinguishes `resolving` from `absent` via `getInputsLocked()`.\n *\n *  - spec field not yet on the entry's accessor + inputs locked → `absent`\n *  - spec field not yet on the entry's accessor + still resolving → `resolving`\n *  - spec resource present but bytes not yet written → `resolving`\n *    (transient — the spec resource is connected, just unfilled)\n *  - spec resource present and `hasData()` → `present`\n */\nfunction getLeafEntryStatus(entry: LeafEntry<TreeNodeAccessor>): ColumnResolutionStatus {\n  const spec = readSpecAccessor(entry);\n  if (isNil(spec)) return entry.accessor.getInputsLocked() ? \"absent\" : \"resolving\";\n  if (!spec.hasData()) return \"resolving\";\n  return \"present\";\n}\n\nconst readDataAccessor = memoizeByEntry(\n  ({ accessor, name }: LeafEntry<TreeNodeAccessor>): undefined | TreeNodeAccessor =>\n    accessor.traverse({ field: `${name}.data`, assertFieldType: \"Input\", ignoreError: true }),\n);\n\nconst readDataStatus = memoizeByEntry(\n  ({ accessor, name }: LeafEntry<TreeNodeAccessor>): ColumnFieldStatus => {\n    if (accessor.listInputFields().includes(`${name}.data`)) return \"present\";\n    return accessor.getInputsLocked() ? \"absent\" : \"resolving\";\n  },\n);\n\nfunction memoizeByEntry<R>(\n  fn: (entry: LeafEntry<TreeNodeAccessor>) => R,\n): (entry: LeafEntry<TreeNodeAccessor>) => R {\n  const cache = new LRUCache<string, { value: R }>({ max: 1000 });\n  return (entry) => {\n    const key = `${entry.accessor.handle}:${entry.name}`;\n    let hit = cache.get(key);\n    if (!hit) cache.set(key, (hit = { value: fn(entry) }));\n    return hit.value;\n  };\n}\n"],"mappings":"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"}