@platforma-sdk/model 1.65.9 → 1.66.2

package/src/columns/column_collection_builder.ts

@@ -1,34 +1,24 @@
 import type {
   AxisQualification,
-  ColumnAxesWithQualifications,
   DiscoverColumnsConstraints,
   DiscoverColumnsRequest,
   DiscoverColumnsResponse,
   MultiColumnSelector,
   NativePObjectId,
-  PColumnIdAndSpec,
   PColumnSpec,
   PObjectId,
-  SUniversalPColumnId,
-} from "@milaboratories/pl-model-common";
-import {
-  AnchoredIdDeriver,
-  canonicalizeJson,
-  deriveNativeId,
-  getAxesId,
-  isPColumnSpec,
 } from "@milaboratories/pl-model-common";
+import { deriveNativeId, isPColumnSpec } from "@milaboratories/pl-model-common";
 import type { ColumnSelector, RelaxedColumnSelector } from "./column_selector";
 import { convertColumnSelectorToMultiColumnSelector } from "./column_selector";
 import { TreeNodeAccessor } from "../render/accessor";
 import type { ColumnSnapshot } from "./column_snapshot";
-import { createColumnSnapshot } from "./column_snapshot";
 import type { ColumnSnapshotProvider, ColumnSource } from "./column_snapshot_provider";
 import { ArrayColumnProvider, toColumnSnapshotProvider } from "./column_snapshot_provider";
 
 import type { PFrameSpecDriver, PoolEntry, SpecFrameHandle } from "@milaboratories/pl-model-common";
 import { throwError } from "@milaboratories/helpers";
-import { uniqBy } from "es-toolkit";
+import { getService } from "../services";
 
 // --- FindColumnsOptions ---
 
@@ -47,9 +37,6 @@ export interface ColumnCollection extends Disposable {
   /** Release the underlying spec frame WASM resource. */
   dispose(): void;
 
-  /** Point lookup by provider-native ID. */
-  getColumn(id: PObjectId): undefined | ColumnSnapshot<PObjectId>;
-
   /** Find columns matching selectors. Returns flat list of snapshots.
    *  No axis compatibility matching, no linker traversal.
    *  Never returns undefined — the "not ready" state was absorbed by the builder. */
@@ -64,10 +51,7 @@ export interface AnchoredColumnCollection extends Disposable {
   dispose(): void;
 
   /** List of anchors used for discovery, with their resolved specs. */
-  getAnchors(): Map<string, PColumnIdAndSpec>;
-
-  /** Point lookup by anchored ID. */
-  getColumn(id: SUniversalPColumnId): undefined | ColumnSnapshot<SUniversalPColumnId>;
+  getAnchors(): Map<string, ColumnSnapshot<PObjectId>>;
 
   /** Axis-aware column discovery. */
   findColumns(options?: AnchoredFindColumnsOptions): ColumnMatch[];
@@ -87,34 +71,32 @@ export interface AnchoredFindColumnsOptions extends FindColumnsOptions {
 /** Result of anchored discovery — column snapshot + routing info. */
 export interface ColumnMatch {
   /** Column snapshot with anchored SUniversalPColumnId. */
-  readonly column: ColumnSnapshot<SUniversalPColumnId>;
-  /** Provider-native ID — for lookups back to the source provider. */
-  readonly originalId: PObjectId;
-  /** Match variants — different paths/qualifications that reach this column. */
+  readonly column: ColumnSnapshot<PObjectId>;
+  /** Match variants — different ways (paths/qualifications) to reach this column. */
   readonly variants: MatchVariant[];
+}
+
+/** A single mapping variant describing how a hit column can be integrated. */
+export interface MatchVariant {
+  /** Full qualifications needed for integration. */
+  readonly qualifications: MatchQualifications;
+  /** Distinctive (minimal) qualifications needed for integration. */
+  readonly distinctiveQualifications: MatchQualifications;
   /** Linker steps traversed to reach this hit; empty for direct matches. */
   readonly path: {
-    linker: ColumnSnapshot<SUniversalPColumnId>;
+    linker: ColumnSnapshot<PObjectId>;
     qualifications: AxisQualification[];
   }[];
 }
 
-/** Qualifications needed for both query (already-integrated) columns and the hit column. */
+/** Qualifications needed for both already-integrated anchor columns and the hit column. */
 export interface MatchQualifications {
-  /** Qualifications for each query (already-integrated) column set. */
-  readonly forQueries: AxisQualification[][];
+  /** Qualifications for already-integrated anchor columns */
+  readonly forQueries: Record<PObjectId, AxisQualification[]>;
   /** Qualifications for the hit column. */
   readonly forHit: AxisQualification[];
 }
 
-/** A single mapping variant describing how a hit column can be integrated. */
-export interface MatchVariant {
-  /** Full qualifications needed for integration. */
-  readonly qualifications: MatchQualifications;
-  /** Distinctive (minimal) qualifications needed for integration. */
-  readonly distinctiveQualifications: MatchQualifications;
-}
-
 // --- Build options ---
 
 export interface BuildOptions {
@@ -139,7 +121,7 @@ export interface AnchoredBuildOptions extends BuildOptions {
 export class ColumnCollectionBuilder {
   private readonly providers: ColumnSnapshotProvider[] = [];
 
-  constructor(private readonly specDriver: PFrameSpecDriver) {}
+  constructor(private readonly specDriver: PFrameSpecDriver = getService("pframeSpec")) {}
 
   /**
    * Register a column source. Sources added first take precedence for dedup.
@@ -232,12 +214,6 @@ class ColumnCollectionImpl implements ColumnCollection, Disposable {
     this.dispose();
   }
 
-  getColumn(id: PObjectId): undefined | ColumnSnapshot<PObjectId> {
-    const col = this.columns.get(id);
-    if (col === undefined) return undefined;
-    return this.toSnapshot(col);
-  }
-
   findColumns(options?: FindColumnsOptions): ColumnSnapshot<PObjectId>[] {
     const includeColumns = options?.include ? toMultiColumnSelectors(options.include) : undefined;
     const excludeColumns = options?.exclude ? toMultiColumnSelectors(options.exclude) : undefined;
@@ -253,15 +229,10 @@ class ColumnCollectionImpl implements ColumnCollection, Disposable {
     // Map hits back to snapshots
     const results = response.hits
       .map((hit) => this.columns.get(hit.hit.columnId as PObjectId))
-      .filter((col): col is ColumnSnapshot<PObjectId> => col !== undefined)
-      .map((col) => this.toSnapshot(col));
+      .filter((col): col is ColumnSnapshot<PObjectId> => col !== undefined);
 
     return results;
   }
-
-  private toSnapshot(col: ColumnSnapshot<PObjectId>): ColumnSnapshot<PObjectId> {
-    return remapSnapshot(col.id, col);
-  }
 }
 
 // --- AnchoredColumnCollectionImpl ---
@@ -271,12 +242,8 @@ interface AnchoredColumnCollectionImplOptions extends ColumnCollectionImplOption
 }
 
 class AnchoredColumnCollectionImpl implements AnchoredColumnCollection, Disposable {
-  private readonly anchorsMap: Map<string, PColumnIdAndSpec>;
+  private readonly anchorsMap: Map<string, ColumnSnapshot<PObjectId>>;
   private readonly columnsMap: Map<PObjectId, ColumnSnapshot<PObjectId>>;
-
-  private readonly idDeriver: AnchoredIdDeriver;
-  private readonly uniqAnchorAxes: ColumnAxesWithQualifications[];
-  private readonly idToOriginalIdMap: Map<SUniversalPColumnId, PObjectId>;
   private readonly specFrameEntry: PoolEntry<SpecFrameHandle>;
 
   constructor(
@@ -293,21 +260,6 @@ class AnchoredColumnCollectionImpl implements AnchoredColumnCollection, Disposab
       options.columns,
       this.specDriver.discoverColumns.bind(this.specDriver, this.specFrameEntry.key),
     );
-    this.idDeriver = new AnchoredIdDeriver(
-      Object.fromEntries(
-        Array.from(this.anchorsMap.entries()).map(([k, v]) => [k, v.spec] as const),
-      ),
-    );
-    this.uniqAnchorAxes = uniqBy(
-      Array.from(this.anchorsMap.values(), ({ spec }) => ({
-        axesSpec: spec.axesSpec,
-        qualifications: [],
-      })),
-      (axis) => canonicalizeJson(getAxesId(axis.axesSpec)) + canonicalizeJson(axis.qualifications),
-    );
-    this.idToOriginalIdMap = new Map(
-      options.columns.map((col) => [this.idDeriver.deriveS(col.spec), col.id] as const),
-    );
   }
 
   dispose(): void {
@@ -318,64 +270,60 @@ class AnchoredColumnCollectionImpl implements AnchoredColumnCollection, Disposab
     this.dispose();
   }
 
-  getAnchors(): Map<string, PColumnIdAndSpec> {
+  getAnchors(): Map<string, ColumnSnapshot<PObjectId>> {
     return this.anchorsMap;
   }
 
-  getColumn(id: SUniversalPColumnId): undefined | ColumnSnapshot<SUniversalPColumnId> {
-    const origId = this.idToOriginalIdMap.get(id);
-    if (origId === undefined) return undefined;
-    const col = this.columnsMap.get(origId);
-    if (col === undefined) return undefined;
-    return remapSnapshot(id, col);
-  }
-
   findColumns(options?: AnchoredFindColumnsOptions): ColumnMatch[] {
     const mode = options?.mode ?? "enrichment";
     const constraints = matchingModeToConstraints(mode);
     const includeColumns = options?.include ? toMultiColumnSelectors(options.include) : undefined;
     const excludeColumns = options?.exclude ? toMultiColumnSelectors(options.exclude) : undefined;
-
+    const anchors = Array.from(this.anchorsMap.values());
     const response = this.specDriver.discoverColumns(this.specFrameEntry.key, {
       includeColumns,
       excludeColumns,
       constraints,
       maxHops: options?.maxHops ?? 4,
-      axes: this.uniqAnchorAxes,
+      axes: anchors.map((anchor) => ({
+        axesSpec: anchor.spec.axesSpec,
+        qualifications: [],
+      })),
     });
 
-    // Map every WASM discovery hit to a ColumnMatch.
-    // The same physical column may appear multiple times when reachable through
-    // different linker paths — each hit becomes a separate ColumnMatch so that
-    // the caller can expand them into distinct table columns.
-    const results: ColumnMatch[] = [];
-    for (const hit of response.hits) {
+    const byColumn = response.hits.reduce<Map<PObjectId, ColumnMatch>>((acc, hit) => {
       const origId = hit.hit.columnId as PObjectId;
       const col =
         this.columnsMap.get(origId) ??
         throwError(`Column with id ${origId} not found in collection`);
-      const associatedId = this.idDeriver.deriveS(col.spec);
-
-      results.push({
-        path: hit.path.map((step) => {
-          if (step.type !== "linker")
-            throw new Error(`Unexpected discover-columns step type: ${step.type}`);
-          return {
-            linker: remapSnapshot(
-              this.idDeriver.deriveS(step.linker.spec),
-              this.columnsMap.get(step.linker.columnId) ??
-                throwError(`Linker column with id ${step.linker.columnId} not found in collection`),
-            ),
-            qualifications: step.qualifications,
-          };
-        }),
-        column: remapSnapshot(associatedId, col),
-        variants: hit.mappingVariants,
-        originalId: origId,
-      });
-    }
 
-    return results;
+      const path = hit.path.map((step) => {
+        if (step.type !== "linker") {
+          throw new Error(`Unexpected discover-columns step type: ${step.type}`);
+        }
+
+        return {
+          linker:
+            this.columnsMap.get(step.linker.columnId) ??
+            throwError(`Linker column with id ${step.linker.columnId} not found in collection`),
+          qualifications: step.qualifications,
+        };
+      });
+      const variants: MatchVariant[] = hit.mappingVariants.map((v) => ({
+        path,
+        qualifications: remapFromIdxToId(v.qualifications, anchors),
+        distinctiveQualifications: remapFromIdxToId(v.distinctiveQualifications, anchors),
+      }));
+      const existing = acc.get(origId);
+      return acc.set(
+        origId,
+        existing === undefined
+          ? { column: col, variants }
+          : { ...existing, variants: [...existing.variants, ...variants] },
+      );
+    }, new Map());
+
+    return Array.from(byColumn.values());
   }
 }
 
@@ -402,15 +350,7 @@ function collectColumns(providers: ColumnSnapshotProvider[]): ColumnSnapshot<POb
 
 // --- Shared snapshot helpers ---
 
-/** Create a new snapshot with a different ID, preserving data accessors. */
-function remapSnapshot<Id extends PObjectId>(
-  id: Id,
-  col: ColumnSnapshot<PObjectId>,
-): ColumnSnapshot<Id> {
-  return createColumnSnapshot(id, col.spec, col.data, col.dataStatus);
-}
-
-/** Normalize SDK ColumnSelectorInput to MultiColumnSelector[]. */
+/** Normalize ColumnSelector (relaxed, single or array) to MultiColumnSelector[]. */
 function toMultiColumnSelectors(input: ColumnSelector): MultiColumnSelector[] {
   return convertColumnSelectorToMultiColumnSelector(input);
 }
@@ -418,40 +358,44 @@ function toMultiColumnSelectors(input: ColumnSelector): MultiColumnSelector[] {
 // --- Anchor resolution ---
 
 /**
- * Resolve each anchor value to a PColumnSpec.
- * - PColumnSpec: used directly
- * - PObjectId (string): looked up in the collected column map
+ * Resolve each anchor entry to a ColumnSnapshot from the collected columns.
+ * - PObjectId (string): looked up by id in the collected columns
+ * - PColumnSpec: matched by deriveNativeId against collected columns
+ * - RelaxedColumnSelector: resolved via discoverColumns in "exact" mode;
+ *   must match exactly one column
+ * Throws on unresolved, ambiguous, or duplicated matches. Requires at least one
+ * anchor to resolve.
  */
 function resolveAnchorMap(
   anchors: Record<string, AnchorEntry>,
   columns: ColumnSnapshot<PObjectId>[],
   discoverColumns: (request: DiscoverColumnsRequest) => DiscoverColumnsResponse,
-): Map<string, PColumnIdAndSpec> {
-  const result = new Map<string, PColumnIdAndSpec>();
+): Map<string, ColumnSnapshot<PObjectId>> {
+  const result = new Map<string, ColumnSnapshot<PObjectId>>();
   const resovedIds = new Set<PObjectId>();
   const getDuplicateError = (key: string) =>
     `Anchor "${key}": selector matched a column that was already matched by another anchor; please refine the selector to match a different column`;
 
-  for (const [key, anchor] of Object.entries(anchors)) {
+  for (const [name, anchor] of Object.entries(anchors)) {
     if (typeof anchor === "string") {
       const found =
         columns.find((col) => col.id === anchor) ??
-        throwError(`Anchor "${key}": column with id "${anchor}" not found in sources`);
+        throwError(`Anchor "${name}": column with id "${anchor}" not found in sources`);
       if (resovedIds.has(found.id)) {
-        throwError(getDuplicateError(key));
+        throwError(getDuplicateError(name));
       }
-      result.set(key, { columnId: found.id, spec: found.spec });
+      result.set(name, found);
       resovedIds.add(found.id);
     } else if ("kind" in anchor) {
-      if (!isPColumnSpec(anchor)) throwError(`Anchor "${key}": invalid PColumnSpec`);
+      if (!isPColumnSpec(anchor)) throwError(`Anchor "${name}": invalid PColumnSpec`);
       const nativeId = deriveNativeId(anchor);
       const found =
         columns.find((col) => deriveNativeId(col.spec) === nativeId) ??
-        throwError(`Anchor "${key}": no column matching spec found in sources`);
+        throwError(`Anchor "${name}": no column matching spec found in sources`);
       if (resovedIds.has(found.id)) {
-        throwError(getDuplicateError(key));
+        throwError(getDuplicateError(name));
       }
-      result.set(key, { columnId: found.id, spec: anchor });
+      result.set(name, found);
       resovedIds.add(found.id);
     } else {
       const matched = discoverColumns({
@@ -461,20 +405,25 @@ function resolveAnchorMap(
         maxHops: 0,
         constraints: matchingModeToConstraints("exact"),
       });
+
       if (matched.hits.length === 0) {
-        throwError(`Anchor "${key}": no columns matched selector`);
+        throwError(`Anchor "${name}": no columns matched selector`);
       }
       if (matched.hits.length > 1) {
         throwError(
-          `Anchor "${key}": selector is ambiguous and matched multiple columns; please refine the selector to match exactly one column`,
+          `Anchor "${name}": selector is ambiguous and matched multiple columns; please refine the selector to match exactly one column`,
         );
       }
       if (resovedIds.has(matched.hits[0].hit.columnId as PObjectId)) {
-        throwError(getDuplicateError(key));
+        throwError(getDuplicateError(name));
       }
 
-      result.set(key, matched.hits[0].hit);
-      resovedIds.add(matched.hits[0].hit.columnId);
+      const id = matched.hits[0].hit.columnId as PObjectId;
+      const snap =
+        columns.find((col) => col.id === id) ??
+        throwError(`Anchor "${name}": matched column with id "${id}" not found in sources`);
+      result.set(name, snap);
+      resovedIds.add(snap.id);
     }
   }
 
@@ -485,6 +434,20 @@ function resolveAnchorMap(
   return result;
 }
 
+function remapFromIdxToId(
+  qualifications: {
+    forQueries: AxisQualification[][];
+    forHit: AxisQualification[];
+  },
+  anchors: ColumnSnapshot<PObjectId>[],
+): MatchQualifications {
+  const forQueries = qualifications.forQueries.reduce<Record<PObjectId, AxisQualification[]>>(
+    (acc, qs, i) => (anchors[i] ? ((acc[anchors[i].id] = qs), acc) : acc),
+    {},
+  );
+  return { forQueries, forHit: qualifications.forHit };
+}
+
 // --- MatchingMode → DiscoverColumnsConstraints ---
 
 function matchingModeToConstraints(mode: MatchingMode): DiscoverColumnsConstraints {

package/src/columns/column_selector.ts

@@ -36,7 +36,7 @@ export interface RelaxedColumnSelector {
   partialAxesMatch?: boolean;
 }
 
-/** Input that normalizes to ColumnSelector[]. */
+/** One or many relaxed column selectors; normalizes to MultiColumnSelector[]. */
 export type ColumnSelector = RelaxedColumnSelector | RelaxedColumnSelector[];
 
 // --- Normalization ---

package/src/columns/column_snapshot.ts

@@ -13,7 +13,10 @@ export type ColumnDataStatus = "ready" | "computing" | "absent";
  * - `data` holds an active object when data exists (ready or computing),
  *   or `undefined` when data is permanently absent.
  */
-export interface ColumnSnapshot<Id extends PObjectId | SUniversalPColumnId> {
+export interface ColumnSnapshot<
+  Id extends PObjectId | SUniversalPColumnId,
+  Data = PColumnDataUniversal,
+> {
   readonly id: Id;
   readonly spec: PColumnSpec;
   readonly dataStatus: ColumnDataStatus;
@@ -24,7 +27,7 @@ export interface ColumnSnapshot<Id extends PObjectId | SUniversalPColumnId> {
    * - `'computing'`: `data.get()` returns `undefined`, marks context unstable.
    * - `'absent'`: `data` is `undefined` — no active object, no instability.
    */
-  readonly data: ColumnData | undefined;
+  readonly data: ColumnData<Data> | undefined;
 }
 
 // --- ColumnData ---
@@ -33,8 +36,8 @@ export interface ColumnSnapshot<Id extends PObjectId | SUniversalPColumnId> {
  * Active object wrapping lazy column data access.
  * Accessing data on a computing column marks the render context unstable.
  */
-export interface ColumnData {
-  get(): PColumnDataUniversal | undefined;
+export interface ColumnData<Data = PColumnDataUniversal> {
+  get(): Data | undefined;
 }
 
 /** Creates a ColumnData active object for a ready column. */

package/src/columns/ctx_column_sources.ts

@@ -17,9 +17,7 @@ import type { ValueOf } from "@milaboratories/helpers";
  *
  * Returns an array of providers suitable for `ColumnCollectionBuilder.addSource()`.
  */
-export function collectCtxColumnSnapshotProviders<A, U, S>(
-  ctx: RenderCtxBase<A, U, S>,
-): ColumnSnapshotProvider[] {
+export function collectCtxColumnSnapshotProviders(ctx: RenderCtxBase): ColumnSnapshotProvider[] {
   const providers: ColumnSnapshotProvider[] = [];
 
   // ResultPool — all upstream columns

package/src/components/PFrameForGraphs.test.ts

@@ -214,8 +214,8 @@ describe("PFrameForGraph", () => {
       valueType: "String",
       annotations: { [Annotation.IsLinkerColumn]: "true" },
       axesSpec: [
-        { type: "String", name: "axis1" },
         { type: "String", name: "axis3" },
+        { type: "String", name: "axis1" },
       ],
     };
 
@@ -240,8 +240,8 @@ describe("PFrameForGraph", () => {
       valueType: "String",
       annotations: { [Annotation.IsLinkerColumn]: "true" },
       axesSpec: [
-        { type: "String", name: "axis1" },
         { type: "String", name: "axis2" },
+        { type: "String", name: "axis1" },
       ],
     };
     const linkerColumn23: PColumnSpec = {
@@ -250,8 +250,8 @@ describe("PFrameForGraph", () => {
       valueType: "String",
       annotations: { [Annotation.IsLinkerColumn]: "true" },
       axesSpec: [
-        { type: "String", name: "axis2" },
         { type: "String", name: "axis3" },
+        { type: "String", name: "axis2" },
       ],
     };
     const linkerColumn34: PColumnSpec = {
@@ -260,8 +260,8 @@ describe("PFrameForGraph", () => {
       valueType: "String",
       annotations: { [Annotation.IsLinkerColumn]: "true" },
       axesSpec: [
-        { type: "String", name: "axis3" },
         { type: "String", name: "axis4" },
+        { type: "String", name: "axis3" },
       ],
     };
 

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

@@ -33,8 +33,8 @@ export function createPTableDefV2(params: {
   secondaryColumns.push(...params.labelColumns);
 
   return createPTableDefV3({
-    primaryColumns: coreColumns,
-    secondaryGroups: secondaryColumns.map((c) => [c]),
+    primary: coreColumns.map((column) => ({ column })),
+    secondary: secondaryColumns.map((column) => ({ entries: [{ column }] })),
     primaryJoinType: params.coreJoinType,
     filters: params.filters,
     sorting: params.sorting,

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

@@ -1,4 +1,5 @@
 import type {
+  AxisQualification,
   PColumn,
   PTableColumnId,
   PTableSorting,
@@ -7,6 +8,7 @@ import type {
   SpecQuery,
   SpecQueryExpression,
   SpecQueryJoinEntry,
+  PObjectId,
 } from "@milaboratories/pl-model-common";
 import { isBooleanExpression } from "@milaboratories/pl-model-common";
 import type { PColumnDataUniversal } from "../../../render";
@@ -15,31 +17,51 @@ import type { PlDataTableFilters } from "../typesV5";
 import { distillFilterSpec, filterSpecToSpecQueryExpr } from "../../../filters";
 import type { Nil } from "@milaboratories/helpers";
 
+/** Primary side — base row grid. */
+export type PrimaryEntry<Data> = {
+  column: PColumn<Data>;
+};
+
+/** Secondary side leaf — the hit column, a linker step, or a label column. */
+export type SecondaryEntry<Data> = {
+  column: PColumn<Data>;
+  /** For hit: `forHit`. For linker step k: `path[k].qualifications`. For label/direct: omit. */
+  qualifications?: AxisQualification[];
+};
+
+/** Secondary group — one join subtree outer-joined onto primary. */
+export type SecondaryGroup<Data> = {
+  entries: SecondaryEntry<Data>[];
+  /** Per-variant qualifications applied to the cloned primary anchors on this group's side.
+   *  Keyed by `PrimaryEntry.column.id`. Omit → base primary used unqualified (labels, non-variant columns). */
+  primaryQualifications?: Record<PObjectId, AxisQualification[]>;
+};
+
 export function createPTableDefV3<Data = PColumnDataUniversal>(params: {
   primaryJoinType: "inner" | "full";
-  primaryColumns: PColumn<Data>[];
-  secondaryGroups: PColumn<Data>[][];
+  primary: PrimaryEntry<Data>[];
+  secondary: SecondaryGroup<Data>[];
   filters?: Nil | PlDataTableFilters;
   sorting?: Nil | PTableSorting[];
 }): PTableDefV2<PColumn<Data>> {
-  // Build SpecQuery directly from columns
-  const coreJoinQuery: SpecQuery<PColumn<Data>> = {
+  let query: SpecQuery<PColumn<Data>> = {
     type: params.primaryJoinType === "inner" ? "innerJoin" : "fullJoin",
-    entries: params.primaryColumns.map((c) => toJoinEntry({ type: "column", column: c })),
+    entries: params.primary.map((a) => toLeaf(a.column, [])),
   };
 
-  let query: SpecQuery<PColumn<Data>> = {
-    type: "outerJoin",
-    primary: toJoinEntry(coreJoinQuery),
-    secondary: params.secondaryGroups.map((group) =>
-      toJoinEntry({
-        type: "innerJoin" as const,
-        entries: group.map((c) => toJoinEntry({ type: "column" as const, column: c })),
-      }),
-    ),
-  };
+  for (const group of params.secondary) {
+    query = {
+      type: "outerJoin",
+      primary: {
+        entry: query,
+        qualifications: params.primary.flatMap((p) => {
+          return group.primaryQualifications?.[p.column.id] ?? [];
+        }),
+      },
+      secondary: group.entries.map((e) => toLeaf(e.column, e.qualifications ?? [])),
+    };
+  }
 
-  // Apply filters
   if (!isNil(params.filters)) {
     const nonEmpty = distillFilterSpec(params.filters);
 
@@ -58,7 +80,6 @@ export function createPTableDefV3<Data = PColumnDataUniversal>(params: {
     }
   }
 
-  // Apply sorting
   if (!isNil(params.sorting) && params.sorting.length > 0) {
     query = {
       type: "sort",
@@ -74,16 +95,18 @@ export function createPTableDefV3<Data = PColumnDataUniversal>(params: {
   return { query };
 }
 
-/** Convert a PTableColumnId to a SpecQueryExpression reference. */
 function columnIdToExpr(col: PTableColumnId): SpecQueryExpression {
   return col.type === "axis"
     ? { type: "axisRef", value: col.id as SingleAxisSelector }
     : { type: "columnRef", value: col.id };
 }
 
-function toJoinEntry<C>(input: SpecQuery<C>): SpecQueryJoinEntry<C> {
+function toLeaf<Data>(
+  col: PColumn<Data>,
+  qs: AxisQualification[],
+): SpecQueryJoinEntry<PColumn<Data>> {
   return {
-    entry: input,
-    qualifications: [],
+    entry: { type: "column", column: col },
+    qualifications: qs,
   };
 }