@platforma-open/milaboratories.sequence-embeddings 1.2.0 → 1.3.0

package/dist/AGENTS.d.ts

@@ -1,4 +1,4 @@
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/author_marker.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/author_marker.d.ts
 //#region src/author_marker.d.ts
 /** Structure to help resolve conflicts if multiple participants writes to
  * the same state */
@@ -1100,7 +1100,7 @@ declare const ErrorLike: ZodUnion<[ZodType<StandardErrorLike, ZodTypeDef, Standa
 type ErrorLike = TypeOf<typeof ErrorLike>;
 /** Converts everything into ErrorLike. */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/common_types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/common_types.d.ts
 type OutputWithStatus<T> = {
   ok: true;
   value: T;
@@ -1113,7 +1113,7 @@ type OutputWithStatus<T> = {
 /** Base type for block outputs */
 type BlockOutputsBase = Record<string, OutputWithStatus<unknown>>;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/navigation.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/navigation.d.ts
 /**
  * Part of the block state, representing current navigation information
  * (i.e. currently selected section)
@@ -1122,7 +1122,7 @@ type NavigationState<Href extends `/${string}` = `/${string}`> = {
   readonly href: Href;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/json.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/json.d.ts
 //#region src/json.d.ts
 type JsonPrimitive = string | number | boolean | null;
 type JsonValue = JsonPrimitive | JsonValue[] | {
@@ -1133,8 +1133,11 @@ type JsonCompatible<T> = unknown extends T ? unknown : [T] extends [JsonValue] ?
 type StringifiedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {
   __json_stringified: T;
 };
+type CanonicalizedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {
+  __json_canonicalized: T;
+};
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/block_state.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/block_state.d.ts
 //#region src/block_state.d.ts
 /**
  * @template Args    sets type of block arguments passed to the workflow
@@ -1160,12 +1163,12 @@ type BlockStateV3<_Data = unknown, Outputs extends BlockOutputsBase = BlockOutpu
   readonly author: AuthorMarker | undefined;
 }; //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/branding.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/branding.d.ts
 //#region src/branding.d.ts
 type Brand<B, K extends string = "__pl_model_brand__"> = { [key in K]: B };
 type Branded$1<T, B, K extends string = "__pl_model_brand__"> = T & Brand<B, K>; //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/dialog/index.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/dialog/index.d.ts
 //#region src/dialog/index.d.ts
 /**
  * File filter passed to the native save dialog. Matches Electron's
@@ -1198,7 +1201,7 @@ interface DialogService {
   showSaveDialog(options: ShowSaveDialogOptions): Promise<ShowSaveDialogResult>;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/pool_entry.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/pool_entry.d.ts
 //#region src/pool_entry.d.ts
 interface PoolEntry<K extends string = string, R extends {} = {}> extends Disposable {
   /** Resource key, calculated using provided `calculateParamsKey` function */
@@ -1217,7 +1220,7 @@ interface PoolEntry<K extends string = string, R extends {} = {}> extends Dispos
  * unless `keep()` is called to transfer ownership to the caller.
  */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.d.ts
 //#region src/drivers/pframe/table_common.d.ts
 type PTableColumnSpecAxis = {
   type: "axis";
@@ -1226,7 +1229,13 @@ type PTableColumnSpecAxis = {
 };
 type PTableColumnSpecColumn = {
   type: "column";
-  id: PObjectId;
+  /**
+   * Leaf column id as it appears in the SpecQuery — may be a rich
+   * {@link ColumnUniversalId} (Discovered / Overridden / Filtered) or a bare
+   * {@link PObjectId}. The host resolver strips to bare via `extractPObjectId`
+   * before physical lookup.
+   */
+  id: ColumnUniversalId;
   spec: PColumnSpec;
 };
 /** Unified spec object for axes and columns */
@@ -1236,13 +1245,13 @@ type PTableColumnIdAxis = {
   id: AxisId;
 };
 type PTableColumnIdColumn = {
-  type: "column";
-  id: PObjectId;
+  type: "column"; /** @see PTableColumnSpecColumn.id */
+  id: ColumnUniversalId;
 };
 /** Unified PTable column identifier */
 type PTableColumnId = PTableColumnIdAxis | PTableColumnIdColumn;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_types.d.ts
 //#region src/drivers/pframe/data_types.d.ts
 type PVectorDataInt = Int32Array;
 type PVectorDataLong = BigInt64Array;
@@ -1313,7 +1322,7 @@ interface ExportPTableOptions {
   columnIndices: number[];
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.d.ts
 //#region src/drivers/pframe/data_info.d.ts
 /**
  * Represents a JavaScript representation of a value in a PColumn. Can be null, a number, or a string.
@@ -1406,7 +1415,46 @@ type PColumnValues = PColumnValuesEntry[];
  * Entry-based representation of JsonDataInfo
  */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_common.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.4/node_modules/@milaboratories/helpers/dist/types/brand.d.ts
+//#region src/types/brand.d.ts
+/**
+ * Phantom-property brand. The key is a plain string literal rather than a
+ * `unique symbol` so the resulting type stays fully nameable across packages.
+ *
+ * A `unique symbol` key forces TS, when forced to expand `Branded<T, B>` into
+ * its structural form (e.g. inside `Record<BrandedUnion, V>` index signatures
+ * during dts emit), to write out `typeof __brand` — a value-level reference
+ * to the symbol. If the symbol's declaring module isn't reachable from the
+ * compilation root, dts emit fails with TS4023 ("cannot be named"). Using a
+ * string key sidesteps this entirely: `{ __brand: B }` is a plain structural
+ * type, nameable from anywhere.
+ *
+ * Phantom keys provide compile-time discrimination only — two different brand
+ * tags `B1 ≠ B2` make `Branded<T, B1>` and `Branded<T, B2>` mutually
+ * incompatible regardless of whether the key is a symbol or a string.
+ */
+type Branded<T, B> = T & {
+  readonly __brand: B;
+};
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/overridden.d.ts
+//#region src/drivers/pframe/spec/overridden.d.ts
+type SpecOverrides = Pick<PColumnSpec, "domain" | "contextDomain" | "annotations"> & {
+  axesSpec?: AxisPatches;
+};
+/**
+ * `source` can reference a leaf or a Filtered/Discovered id, but never another
+ * Overridden id — there is no `Overridden<Overridden<...>>`. Repeated overrides
+ * merge at the outer wrapper via {@link mergeSpecOverrides}.
+ */
+interface ColumnOverriddenKey {
+  __isOverridden: true;
+  source: Exclude<ColumnUniversalId, ColumnOverriddenId>;
+  specOverrides: SpecOverrides;
+}
+type ColumnOverriddenId = Branded<CanonicalizedJson<ColumnOverriddenKey>, "ColumnOverriddenId">;
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_common.d.ts
 //#region src/drivers/pframe/query/query_common.d.ts
 /**
  * Structural type information for a single column: the axis value types (in
@@ -2428,895 +2476,970 @@ interface QueryTransformColumns<Q, E, SO> {
   mode: TransformColumnsMode;
   /** Derived columns to compute (at least one). */
   columns: [TransformColumnEntry<E, SO>, ...TransformColumnEntry<E, SO>[]];
+}
+/**
+ * Spec-override query operation — client-side-only structural node.
+ *
+ * Overlays a {@link SpecOverrides} patch on top of the inner query's spec.
+ * Carries no topological change — it is collapsed at the host boundary
+ * (`resolvePColumn`) before the query reaches pframe-engine. The engine
+ * never sees this node.
+ *
+ * Emitted by `ColumnOverriddenRecipe.getQuery()`; the only currently
+ * supported shape is `specOverride{ input: <plain column ref>, override }`
+ * (i.e. `Overridden<Lazy>`). More complex projections under Overridden are
+ * a future engine work item.
+ *
+ * @template Q - Input query type
+ * @template SO - Spec override type
+ */
+interface QuerySpecOverride<Q, SO> {
+  type: "specOverride";
+  /** Input query whose spec is to be overridden. */
+  input: Q;
+  /** Spec override patch to overlay on the inner spec. */
+  override: SO;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_spec.d.ts
-//#region src/drivers/pframe/query/query_spec.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_data.d.ts
+//#region src/drivers/pframe/query/query_data.d.ts
 /**
- * Join entry for spec-layer queries — the base join entry extended with
- * per-axis domain constraints. Absent `qualifications` is equivalent to `[]`.
+ * Column identifier with type specification.
  *
- * @example
- * {
- *   entry: querySpec,
- *   qualifications: [{ axis: { name: 'sample' }, contextDomain: { ... } }]
- * }
+ * Pairs a column ID with its full type specification (axes and column types).
+ * Used in data layer to carry type information alongside column references.
  */
-type SpecQueryJoinEntry<C = PObjectId> = QueryJoinEntry<SpecQuery<C>> & {
-  qualifications?: {
-    /** Axis to qualify. */axis: SingleAxisSelector; /** Additional domain constraints for this axis. */
-    contextDomain: Domain;
-  }[];
+type ColumnIdAndTypeSpec = {
+  /** Unique identifier of the column */id: PObjectId; /** Type specification defining the axes and the single column value type */
+  spec: ColumnTypeSpec;
 };
+/**
+ * Join entry for data layer queries.
+ *
+ * Extends the base join entry with axes mapping information.
+ * The mapping specifies how axes from this entry align with the joined result.
+ *
+ * @example
+ * // Join entry with axes mapping [0, 2] means:
+ * // - This entry's axis 0 maps to result axis 0
+ * // - This entry's axis 1 maps to result axis 2
+ * { entry: queryData, axesMapping: [0, 2] }
+ */
+interface DataQueryJoinEntry extends QueryJoinEntry<DataQuery> {
+  /** Maps this entry's axes to the result axes by index */
+  axesMapping: number[];
+}
 /** @see QueryColumn */
-type SpecQueryColumn<C = PObjectId> = QueryColumn<C>;
+type DataQueryColumn = QueryColumn;
 /** @see QueryInlineColumn */
-type SpecQueryInlineColumn = QueryInlineColumn<PColumnIdAndSpec>;
+type DataQueryInlineColumn = QueryInlineColumn<ColumnIdAndTypeSpec>;
 /** @see QuerySparseToDenseColumn */
-type SpecQuerySparseToDenseColumn<C = PObjectId> = QuerySparseToDenseColumn<C, SingleAxisSelector, PColumnIdAndSpec>;
+type DataQuerySparseToDenseColumn = QuerySparseToDenseColumn<PObjectId, number, ColumnIdAndTypeSpec>;
 /** @see QuerySymmetricJoin */
-type SpecQuerySymmetricJoin<C = PObjectId> = QuerySymmetricJoin<SpecQueryJoinEntry<C>>;
+type DataQuerySymmetricJoin = QuerySymmetricJoin<DataQueryJoinEntry>;
 /** @see QueryOuterJoin */
-type SpecQueryOuterJoin<C = PObjectId> = QueryOuterJoin<SpecQueryJoinEntry<C>>;
+type DataQueryOuterJoin = QueryOuterJoin<DataQueryJoinEntry>;
 /**
- * Linker side of a spec-layer linker-join.
+ * Linker side of a data-layer linker-join.
  *
- * At the spec layer the linker is just a column reference — integration artifacts
- * (axes mapping, one-side indices) are derived during spec→data conversion.
+ * Carries the linker column id along with integration-derived artifacts needed
+ * for execution:
+ * - `axesMapping` — how the linker's axes map into the joined result
+ * - `oneSideAxesIndices` — which axis indices in the joined result to project out
  */
-type SpecQueryLinkerJoinLinker<C = PObjectId> = {
-  /** Linker column reference. */column: C;
+type DataQueryLinkerJoinLinker = {
+  /** Linker column reference. */column: PObjectId; /** Linker's axes mapped into the joined result. */
+  axesMapping: number[]; /** Axis indices (in the joined result) to project out — the linker's one-side axes. */
+  oneSideAxesIndices: number[];
 };
 /** @see QueryLinkerJoin */
-type SpecQueryLinkerJoin<C = PObjectId> = QueryLinkerJoin<SpecQueryLinkerJoinLinker<C>, SpecQueryJoinEntry<C>>;
+type DataQueryLinkerJoin = QueryLinkerJoin<DataQueryLinkerJoinLinker, DataQueryJoinEntry>;
 /** @see QuerySliceAxes */
-type SpecQuerySliceAxes<C = PObjectId> = QuerySliceAxes<SpecQuery<C>, SingleAxisSelector>;
+type DataQuerySliceAxes = QuerySliceAxes<DataQuery, number>;
 /** @see QuerySort */
-type SpecQuerySort<C = PObjectId> = QuerySort<SpecQuery<C>, SpecQueryExpression>;
+type DataQuerySort = QuerySort<DataQuery, DataQueryExpression>;
 /** @see QueryFilter */
-type SpecQueryFilter<C = PObjectId> = QueryFilter<SpecQuery<C>, SpecQueryBooleanExpression>;
+type DataQueryFilter = QueryFilter<DataQuery, DataQueryBooleanExpression>;
 /** @see QueryTransformColumns */
-type SpecQueryTransformColumns<C = PObjectId> = QueryTransformColumns<SpecQuery<C>, SpecQueryExpression, PColumnIdAndSpec>;
+type DataQueryTransformColumns = QueryTransformColumns<DataQuery, DataQueryExpression, ColumnIdAndTypeSpec>;
 /**
- * Union of all spec layer query types.
- *
- * The spec layer operates with named selectors and column IDs,
- * making it suitable for user-facing query construction and validation.
+ * Union of all data layer query types.
  *
- * @template C - Column reference type. Defaults to PObjectId (ID-only).
- *   Can be parameterized with richer types (e.g., PColumn<Data>) to carry
- *   full column data directly in the query tree.
+ * The data layer operates with numeric indices for axes and columns,
+ * making it suitable for runtime query execution and optimization.
  *
  * Includes:
  * - Leaf nodes: column, inlineColumn, sparseToDenseColumn
  * - Join operations: innerJoin, fullJoin, outerJoin, linkerJoin
  * - Transformations: sliceAxes, sort, filter, transformColumns
  */
-type SpecQuery<C = PObjectId> = SpecQueryColumn<C> | SpecQueryInlineColumn | SpecQuerySparseToDenseColumn<C> | SpecQuerySymmetricJoin<C> | SpecQueryOuterJoin<C> | SpecQueryLinkerJoin<C> | SpecQuerySliceAxes<C> | SpecQuerySort<C> | SpecQueryFilter<C> | SpecQueryTransformColumns<C>;
+type DataQuery = DataQueryColumn | DataQueryInlineColumn | DataQuerySparseToDenseColumn | DataQuerySymmetricJoin | DataQueryOuterJoin | DataQueryLinkerJoin | DataQuerySliceAxes | DataQuerySort | DataQueryFilter | DataQueryTransformColumns;
 /** @see ExprAxisRef */
-type SpecExprAxisRef = ExprAxisRef<SingleAxisSelector>;
+type DataExprAxisRef = ExprAxisRef<number>;
 /** @see ExprColumnRef */
-type SpecExprColumnRef = ExprColumnRef<PObjectId>;
-type SpecQueryExpression = SpecExprColumnRef | SpecExprAxisRef | ExprConstant | ExprNumericBinary<SpecQueryExpression> | ExprNumericComparison<SpecQueryExpression> | ExprNumericUnary<SpecQueryExpression> | ExprStringEquals<SpecQueryExpression> | ExprStringContains<SpecQueryExpression> | ExprStringRegex<SpecQueryExpression> | ExprStringContainsFuzzy<SpecQueryExpression> | ExprIsNull<SpecQueryExpression> | ExprFillNull<SpecQueryExpression> | ExprLogicalUnary<SpecQueryExpression> | ExprLogicalVariadic<SpecQueryExpression> | ExprIsIn<SpecQueryExpression, string> | ExprIsIn<SpecQueryExpression, number> | ExprCast<SpecQueryExpression> | ExprConditional<SpecQueryExpression> | ExprRanking<SpecQueryExpression, SingleAxisSelector, PObjectId>;
-type SpecQueryBooleanExpression = InferBooleanExpressionUnion<SpecQueryExpression>; //#endregion
+type DataExprColumnRef = ExprColumnRef<number>;
+type DataQueryExpression = DataExprColumnRef | DataExprAxisRef | ExprConstant | ExprNumericBinary<DataQueryExpression> | ExprNumericComparison<DataQueryExpression> | ExprNumericUnary<DataQueryExpression> | ExprStringEquals<DataQueryExpression> | ExprStringContains<DataQueryExpression> | ExprStringRegex<DataQueryExpression> | ExprStringContainsFuzzy<DataQueryExpression> | ExprIsNull<DataQueryExpression> | ExprFillNull<DataQueryExpression> | ExprLogicalUnary<DataQueryExpression> | ExprLogicalVariadic<DataQueryExpression> | ExprIsIn<DataQueryExpression, string> | ExprIsIn<DataQueryExpression, number> | ExprCast<DataQueryExpression> | ExprConditional<DataQueryExpression> | ExprRanking<DataQueryExpression, number, number>;
+type DataQueryBooleanExpression = InferBooleanExpressionUnion<DataQueryExpression>; //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.d.ts
-//#region src/drivers/pframe/table_calculate.d.ts
-/** Defines a terminal column node in the join request tree */
-interface ColumnJoinEntry<Col> {
-  /** Node type discriminator */
-  readonly type: "column";
-  /** Local column */
-  readonly column: Col;
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec_driver.d.ts
+//#region src/drivers/pframe/spec_driver.d.ts
+/** Matches a string value either exactly or by regex pattern */
+type StringMatcher = {
+  type: "exact";
+  value: string;
+} | {
+  type: "regex";
+  value: string;
+};
+/** Map of key to array of string matchers (OR-ed per key, AND-ed across keys) */
+type MatcherMap = Record<string, StringMatcher[]>;
+/** Selector for matching axes by various criteria */
+interface MultiAxisSelector {
+  /** Match any of the axis types listed here */
+  readonly type?: AxisValueType[];
+  /** Match any of the axis names listed here */
+  readonly name?: StringMatcher[];
+  /** Match requires all the domains listed here */
+  readonly domain?: MatcherMap;
+  /** Match requires all the context domains listed here */
+  readonly contextDomain?: MatcherMap;
+  /** Match requires all the annotations listed here */
+  readonly annotations?: MatcherMap;
 }
-/**
- * Axis filter slicing target axis from column axes.
- * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).
- * */
-interface ConstantAxisFilter {
-  /** Filter type discriminator */
-  readonly type: "constant";
-  /** Index of axis to slice (zero-based) */
-  readonly axisIndex: number;
-  /** Equality filter reference value, see {@link SingleValueEqualPredicate} */
-  readonly constant: string | number;
+/** Column selector for discover columns request, matching columns by various criteria.
+ * Multiple selectors are OR-ed: a column matches if it satisfies any selector. */
+interface MultiColumnSelector {
+  /** Match any of the value types listed here */
+  readonly type?: ColumnValueType[];
+  /** Match any of the names listed here */
+  readonly name?: StringMatcher[];
+  /** Match requires all the domains listed here */
+  readonly domain?: MatcherMap;
+  /** Match requires all the context domains listed here */
+  readonly contextDomain?: MatcherMap;
+  /** Match requires all the annotations listed here */
+  readonly annotations?: MatcherMap;
+  /** Match any of the axis selectors listed here */
+  readonly axes?: MultiAxisSelector[];
+  /** When true (default), allows matching if only a subset of axes match */
+  readonly partialAxesMatch?: boolean;
 }
-/** Defines a terminal column node in the join request tree */
-interface SlicedColumnJoinEntry<Col> {
-  /** Node type discriminator */
-  readonly type: "slicedColumn";
-  /** Local column */
-  readonly column: Col;
-  /** New column id */
-  readonly newId: PObjectId;
-  /** Non-empty list of axis filters */
-  readonly axisFilters: ConstantAxisFilter[];
+/** Qualifications needed for both query (already-integrated) columns and the hit column. */
+interface ColumnAxesWithQualifications {
+  /** Already integrated (query) columns with their qualifications. */
+  axesSpec: AxisSpec[];
+  /** Qualifications for each already integrated (query) column. */
+  qualifications: AxisQualification[];
 }
-interface ArtificialColumnJoinEntry<Col> {
-  /** Node type discriminator */
-  readonly type: "artificialColumn";
-  /** Column definition */
-  readonly column: Col;
-  /** New column id */
-  readonly newId: PObjectId;
-  /** Indices of axes to pick from the column (zero-based) */
-  readonly axesIndices: number[];
+/** Fine-grained constraints controlling axes matching and qualification behavior */
+interface DiscoverColumnsConstraints {
+  /** Allow source (query) axes that have no match in the hit column */
+  allowFloatingSourceAxes: boolean;
+  /** Allow hit column axes that have no match in the source (query) */
+  allowFloatingHitAxes: boolean;
+  /** Allow source (query) axes to be qualified (contextDomain extended) */
+  allowSourceQualifications: boolean;
+  /** Allow hit column axes to be qualified (contextDomain extended) */
+  allowHitQualifications: boolean;
 }
-/** Defines a terminal column node in the join request tree */
-interface InlineColumnJoinEntry {
-  /** Node type discriminator */
-  readonly type: "inlineColumn";
-  /** Column definition */
-  readonly column: PColumn<PColumnValues>;
+/** Request for discovering columns compatible with a given axes integration */
+interface DiscoverColumnsRequest {
+  /** Include columns matching these selectors (OR-ed); empty or omitted matches all columns */
+  includeColumns?: MultiColumnSelector[];
+  /** Exclude columns matching these selectors (OR-ed); applied after include filter */
+  excludeColumns?: MultiColumnSelector[];
+  /** Already integrated axes with qualifications */
+  axes: ColumnAxesWithQualifications[];
+  /** Maximum number of hops allowed between provided axes integration and returned hits (0 = direct only) */
+  maxHops?: number;
+  /** Constraints controlling axes matching and qualification behavior */
+  constraints: DiscoverColumnsConstraints;
 }
-/**
- * Defines a join request tree node that will output only records present in
- * all child nodes ({@link entries}).
- * */
-interface InnerJoin<Col> {
-  /** Node type discriminator */
-  readonly type: "inner";
-  /** Child nodes to be inner joined */
-  readonly entries: JoinEntry<Col>[];
+/** Linker step: traversal through a linker column */
+interface DiscoverColumnsLinkerStep {
+  type: "linker";
+  /** The linker column traversed in this step */
+  linker: PColumnIdAndSpec;
 }
 /**
- * Defines a join request tree node that will output all records present at
- * least in one of the child nodes ({@link entries}), values for those PColumns
- * that lack corresponding combinations of axis values will be null.
- * */
-interface FullJoin<Col> {
-  /** Node type discriminator */
-  readonly type: "full";
-  /** Child nodes to be fully outer joined */
-  readonly entries: JoinEntry<Col>[];
+ * Filter step: intersects the current subquery with a filter column on shared
+ * axes. Filter columns carry `pl7.app/isSubset: "true"` with axes ⊆ dataset
+ * axes, so the inner-join narrows the key space to rows where the filter is
+ * present.
+ */
+interface DiscoverColumnsFilterStep {
+  type: "filter";
+  /** The filter column applied in this step */
+  filter: PColumnIdAndSpec;
 }
+/** A step traversed during path-based column discovery. Discriminated by `type`. */
+type DiscoverColumnsStepInfo = DiscoverColumnsLinkerStep | DiscoverColumnsFilterStep;
 /**
- * Defines a join request tree node that will output all records present in
- * {@link primary} child node, and records from the {@link secondary} nodes will
- * be added to the output only if present, values for those PColumns from the
- * {@link secondary} list, that lack corresponding combinations of axis values
- * will be null.
+ * Input to `buildQuery`: a terminal column plus an ordered
+ * path of wrapping steps (linker hops, filter joins). Produces a
+ * {@link SpecQueryJoinEntry} ready to be plugged into an
+ * `innerJoin`/`fullJoin`/`outerJoin` entry list.
  *
- * This node can be thought as a chain of SQL LEFT JOIN operations starting from
- * the {@link primary} node and adding {@link secondary} nodes one by one.
- * */
-interface OuterJoin<Col> {
-  /** Node type discriminator */
-  readonly type: "outer";
-  /** Primes the join operation. Left part of LEFT JOIN. */
-  readonly primary: JoinEntry<Col>;
-  /** Driven nodes, giving their values only if primary node have corresponding
-   * nodes. Right parts of LEFT JOIN chain. */
-  readonly secondary: JoinEntry<Col>[];
-}
-/**
- * Base type of all join request tree nodes. Join request tree allows to combine
- * information from multiple PColumns into a PTable. Correlation between records
- * is performed by looking for records with the same values in common axis between
- * the PColumns. Common axis are those axis which have equal {@link AxisId} derived
- * from the columns axes spec.
- * */
-type JoinEntry<Col> = ColumnJoinEntry<Col> | SlicedColumnJoinEntry<Col> | ArtificialColumnJoinEntry<Col> | InlineColumnJoinEntry | InnerJoin<Col> | FullJoin<Col> | OuterJoin<Col>;
-/** Container representing whole data stored in specific PTable column. */
-interface FullPTableColumnData {
-  /** Unified spec */
-  readonly spec: PTableColumnSpec;
-  /** Data */
-  readonly data: PTableVector;
-}
-interface SingleValueIsNAPredicate {
-  /** Comparison operator */
-  readonly operator: "IsNA";
-}
-interface SingleValueEqualPredicate {
-  /** Comparison operator */
-  readonly operator: "Equal";
-  /** Reference value, NA values will not match */
-  readonly reference: string | number;
-}
-interface SingleValueInSetPredicate {
-  /** Comparison operator */
-  readonly operator: "InSet";
-  /** Reference values, NA values will not match */
-  readonly references: (string | number)[];
-}
-interface SingleValueIEqualPredicate {
-  /** Comparison operator (case insensitive) */
-  readonly operator: "IEqual";
-  /** Reference value, NA values will not match */
-  readonly reference: string;
-}
-interface SingleValueLessPredicate {
-  /** Comparison operator */
-  readonly operator: "Less";
-  /** Reference value, NA values will not match */
-  readonly reference: string | number;
-}
-interface SingleValueLessOrEqualPredicate {
-  /** Comparison operator */
-  readonly operator: "LessOrEqual";
-  /** Reference value, NA values will not match */
-  readonly reference: string | number;
+ * Path ordering: `path[0]` is outermost (first applied), `path[N-1]` is
+ * closest to `column`. Omit or pass `[]` for a direct column with no
+ * wrapping.
+ *
+ * Columns are referenced by id — specs are resolved later at
+ * `evaluateQuery` against the registered specs of the PFrame, so the
+ * caller cannot disagree with the frame about spec content.
+ *
+ * Qualifications annotate the resulting outermost entry; they do not
+ * propagate into the inner query.
+ */
+type BuildQueryInput = {
+  /** Shape version marker — bumped only on breaking structural changes. */readonly version: "v1"; /** Terminal column id — the column actually returning data. */
+  readonly column: PObjectId; /** Ordered path from source integration to `column`. Outermost first. */
+  readonly path?: DiscoverColumnsStepInfo[]; /** Axis qualifications attached to the resulting join entry. */
+  readonly qualifications?: AxisQualification[];
+};
+/** Qualifications info for a discover columns response mapping variant */
+interface DiscoverColumnsResponseQualifications {
+  /** Qualifications for each query (already-integrated) column set */
+  forQueries: AxisQualification[][];
+  /** Qualifications for the hit column */
+  forHit: AxisQualification[];
 }
-interface SingleValueGreaterPredicate {
-  /** Comparison operator */
-  readonly operator: "Greater";
-  /** Reference value, NA values will not match */
-  readonly reference: string | number;
+/** A single mapping variant describing how a hit column can be integrated */
+interface DiscoverColumnsMappingVariant {
+  /** Full qualifications needed for integration */
+  qualifications: DiscoverColumnsResponseQualifications;
+  /** Distinctive (minimal) qualifications needed for integration */
+  distinctiveQualifications: DiscoverColumnsResponseQualifications;
 }
-interface SingleValueGreaterOrEqualPredicate {
-  /** Comparison operator */
-  readonly operator: "GreaterOrEqual";
-  /** Reference value, NA values will not match */
-  readonly reference: string | number;
+/** A single hit in the discover columns response */
+interface DiscoverColumnsResponseHit {
+  /** The column that was found compatible */
+  hit: PColumnIdAndSpec;
+  /** Linker steps traversed to reach this hit; empty for direct matches */
+  path: DiscoverColumnsStepInfo[];
+  /** Possible ways to integrate this column with the existing set */
+  mappingVariants: DiscoverColumnsMappingVariant[];
 }
-interface SingleValueStringContainsPredicate {
-  /** Comparison operator */
-  readonly operator: "StringContains";
-  /** Reference substring, NA values are skipped */
-  readonly substring: string;
+/** Response from discover columns */
+interface DiscoverColumnsResponse {
+  /** Columns that could be integrated and possible ways to integrate them */
+  hits: DiscoverColumnsResponseHit[];
 }
-interface SingleValueStringIContainsPredicate {
-  /** Comparison operator (case insensitive) */
-  readonly operator: "StringIContains";
-  /** Reference substring, NA values are skipped */
-  readonly substring: string;
+/** Request for deleting an entry from a given axes integration */
+interface DeleteColumnRequest {
+  /** Already integrated axes with qualifications */
+  axes: ColumnAxesWithQualifications[];
+  /** Zero based index of the entry to be deleted */
+  delete: number;
 }
-interface SingleValueMatchesPredicate {
-  /** Comparison operator */
-  readonly operator: "Matches";
-  /** Regular expression, NA values are skipped */
-  readonly regex: string;
+/** Response from delete column */
+interface DeleteColumnResponse {
+  axes: ColumnAxesWithQualifications[];
 }
-interface SingleValueStringContainsFuzzyPredicate {
-  /** Comparison operator */
-  readonly operator: "StringContainsFuzzy";
-  /** Reference value, NA values are skipped */
-  readonly reference: string;
+/** Response from evaluating a query against a PFrame. */
+type EvaluateQueryResponse = {
   /**
-   * Integer specifying the upper bound of edit distance between
-   * reference and actual value.
-   * When {@link substitutionsOnly} is not defined or set to false
-   * Levenshtein distance is used (substitutions and indels)
-   * @see https://en.wikipedia.org/wiki/Levenshtein_distance
-   * When {@link substitutionsOnly} is set to true
-   * Hamming distance is used (substitutions only)
-   * @see https://en.wikipedia.org/wiki/Hamming_distance
+   * The table specification describing the structure of the query result,
+   * including all axes and columns that will be present in the output.
    */
-  readonly maxEdits: number;
-  /** Changes the type of edit distance in {@link maxEdits} */
-  readonly substitutionsOnly?: boolean;
+  tableSpec: PTableColumnSpec[];
   /**
-   * Some character in {@link reference} that will match any
-   * single character in searched text.
+   * The data layer query representation with numeric indices,
+   * suitable for execution by the data processing engine.
    */
-  readonly wildcard?: string;
-}
-interface SingleValueStringIContainsFuzzyPredicate {
-  /** Comparison operator (case insensitive) */
-  readonly operator: "StringIContainsFuzzy";
-  /** Reference value, NA values are skipped */
-  readonly reference: string;
+  dataQuery: DataQuery;
+};
+/** Handle to a spec-only PFrame (no data, synchronous operations). */
+type SpecFrameHandle = Branded<string, "SpecFrameHandle">;
+/**
+ * Synchronous driver for spec-level PFrame operations.
+ *
+ * Unlike the async PFrameDriver (which works with data), this driver
+ * operates on column specifications only. All methods are synchronous
+ * because the underlying WASM PFrame computes results immediately.
+ */
+interface PFrameSpecDriver {
+  /** Create a spec-only PFrame from column specs. Returns a pool entry with handle and unref. */
+  createSpecFrame(specs: Record<string, PColumnSpec>): PoolEntry<SpecFrameHandle>;
+  /** List all columns currently registered in the frame. */
+  listColumns(handle: SpecFrameHandle): PColumnIdAndSpec[];
+  /** Discover columns compatible with given axes integration. */
+  discoverColumns(handle: SpecFrameHandle, request: DiscoverColumnsRequest): DiscoverColumnsResponse;
+  /** Delete an entry from a given axes integration */
+  deleteColumn(handle: SpecFrameHandle, request: DeleteColumnRequest): DeleteColumnResponse;
+  /** Evaluates a query specification against this PFrame */
+  evaluateQuery(handle: SpecFrameHandle, request: SpecQuery): EvaluateQueryResponse;
   /**
-   * Integer specifying the upper bound of edit distance between
-   * reference and actual value.
-   * When {@link substitutionsOnly} is not defined or set to false
-   * Levenshtein distance is used (substitutions and indels)
-   * @see https://en.wikipedia.org/wiki/Levenshtein_distance
-   * When {@link substitutionsOnly} is set to true
-   * Hamming distance is used (substitutions only)
-   * @see https://en.wikipedia.org/wiki/Hamming_distance
+   * Assembles a {@link SpecQueryJoinEntry} from a terminal column plus an
+   * ordered path of wrapping steps (linker hops, filter joins).
+   *
+   * Pure over its input — no frame handle is needed. Column ids are resolved
+   * later at {@link evaluateQuery} against the registered specs.
    */
-  readonly maxEdits: number;
-  /** Changes the type of edit distance in {@link maxEdits} */
-  readonly substitutionsOnly?: boolean;
+  buildQuery(input: BuildQueryInput): SpecQueryJoinEntry;
+  /** Expand index-based parentAxes in AxesSpec to resolved AxisId parents in AxesId. */
+  expandAxes(spec: AxesSpec): AxesId;
+  /** Collapse resolved AxisId parents back to index-based parentAxes in AxesSpec. */
+  collapseAxes(ids: AxesId): AxesSpec;
+  /** Find the index of an axis matching the given selector. Returns -1 if not found. */
+  findAxis(spec: AxesSpec, selector: SingleAxisSelector): number;
+  /** Find the flat index of a table column matching the given selector. Returns -1 if not found. */
+  findTableColumn(tableSpec: PTableColumnSpec[], selector: PTableColumnId): number;
   /**
-   * Some character in {@link reference} that will match any
-   * single character in searched text.
+   * Upgrades selector-based legacy record filters into index-based data-layer
+   * boolean expressions, resolved against the provided unified table spec
+   * (axes first, then columns).
    */
-  readonly wildcard?: string;
-}
-interface SingleValueNotPredicateV2 {
-  /** Comparison operator */
-  readonly operator: "Not";
-  /** Operand to negate */
-  readonly operand: SingleValuePredicateV2;
-}
-interface SingleValueAndPredicateV2 {
-  /** Comparison operator */
-  readonly operator: "And";
-  /** Operands to combine */
-  readonly operands: SingleValuePredicateV2[];
+  rewriteLegacyFilters(request: {
+    tableSpec: PTableColumnSpec[];
+    filters: PTableRecordFilter[];
+  }): DataQueryBooleanExpression[];
+} //#endregion
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.d.ts
+/** Single axis selector */
+interface SingleAxisSelector {
+  /** Axis name (required) */
+  name: string;
+  /** Axis type (optional) */
+  type?: AxisValueType;
+  /** Domain requirements (optional) */
+  domain?: Domain;
+  /** Context-domain requirements (optional) */
+  contextDomain?: Domain;
+  /** Parent axes requirements (optional) */
+  parentAxes?: SingleAxisSelector[];
 }
-interface SingleValueOrPredicateV2 {
-  /** Comparison operator */
-  readonly operator: "Or";
-  /** Operands to combine */
-  readonly operands: SingleValuePredicateV2[];
+/** Qualification applied to a single axis to make it compatible during integration. */
+interface AxisQualification {
+  /** Axis selector identifying which axis is qualified. */
+  readonly axis: SingleAxisSelector;
+  /** Additional context domain entries applied to the axis. */
+  readonly contextDomain: Record<string, string>;
 }
-/** Filtering predicate for a single axis or column value */
-type SingleValuePredicateV2 = SingleValueIsNAPredicate | SingleValueEqualPredicate | SingleValueInSetPredicate | SingleValueLessPredicate | SingleValueLessOrEqualPredicate | SingleValueGreaterPredicate | SingleValueGreaterOrEqualPredicate | SingleValueStringContainsPredicate | SingleValueMatchesPredicate | SingleValueStringContainsFuzzyPredicate | SingleValueNotPredicateV2 | SingleValueAndPredicateV2 | SingleValueOrPredicateV2 | SingleValueIEqualPredicate | SingleValueStringIContainsPredicate | SingleValueStringIContainsFuzzyPredicate;
 /**
- * Filter PTable records based on specific axis or column value. If this is an
- * axis value filter and the axis is part of a partitioning key in some of the
- * source PColumns, the filter will be pushed down to those columns, so only
- * specific partitions will be retrieved from the remote storage.
- * */
-interface PTableRecordSingleValueFilterV2 {
-  /** Filter type discriminator */
-  readonly type: "bySingleColumnV2";
-  /** Target axis selector to examine values from */
-  readonly column: PTableColumnId;
-  /** Value predicate */
-  readonly predicate: SingleValuePredicateV2;
-}
-/** Generic PTable records filter */
-type PTableRecordFilter = PTableRecordSingleValueFilterV2;
-/** Sorting parameters for a PTable.  */
-type PTableSorting = {
-  /** Unified column identifier */readonly column: PTableColumnId; /** Sorting order */
-  readonly ascending: boolean; /** Sorting in respect to NA and absent values */
-  readonly naAndAbsentAreLeastValues: boolean;
-};
-/** Information required to instantiate a PTable. */
-interface PTableDef<Col> {
-  /** Join tree to populate the PTable */
-  readonly src: JoinEntry<Col>;
-  /** Partition filters */
-  readonly partitionFilters: PTableRecordFilter[];
-  /** Record filters */
-  readonly filters: PTableRecordFilter[];
-  /** Table sorting */
-  readonly sorting: PTableSorting[];
-}
-/** Information required to instantiate a PTable (V2, query-based). */
-interface PTableDefV2<Col> {
-  /** Pre-built query spec describing joins, filters and sorting */
-  readonly query: SpecQuery<Col>;
-}
-/** Request to create and retrieve entirety of data of PTable. */
-type CalculateTableDataRequest<Col> = {
-  /** Join tree to populate the PTable */readonly src: JoinEntry<Col>; /** Record filters */
-  readonly filters: PTableRecordFilter[]; /** Table sorting */
-  readonly sorting: PTableSorting[];
-};
-/** Response for {@link CalculateTableDataRequest} */
-type CalculateTableDataResponse = FullPTableColumnData[];
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/ref.d.ts
-//#region src/ref.d.ts
-declare const PlRef: ZodReadonly<ZodObject<{
-  __isRef: ZodLiteral<true>;
-  blockId: ZodString;
-  name: ZodString;
-  requireEnrichments: ZodOptional<ZodLiteral<true>>;
-}, "strip", ZodTypeAny, {
-  __isRef: true;
-  blockId: string;
-  name: string;
-  requireEnrichments?: true | undefined;
-}, {
-  __isRef: true;
-  blockId: string;
-  name: string;
-  requireEnrichments?: true | undefined;
-}>>;
-type PlRef = TypeOf<typeof PlRef>;
-/** @deprecated use {@link PlRef} */
+ * Reference to an axis by its numerical index within the anchor column's axes array
+ * Format: [anchorId, axisIndex]
+ */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/pool/spec.d.ts
-//#region src/pool/spec.d.ts
-/** Any object exported into the result pool by the block always have spec attached to it */
-type PObjectSpec = {
-  /** PObject kind discriminator */readonly kind: string; /** Name is common part of PObject identity */
-  readonly name: string; /** Domain is a set of key-value pairs that can be used to identify the object */
-  readonly domain?: Record<string, string>;
-  /** Context domain provides additional axis/column identity that is matched
-   * by kinship rules (subset/superset/overlap) rather than exact equality */
-  readonly contextDomain?: Record<string, string>; /** Additional information attached to the object */
-  readonly annotations?: Record<string, string>;
-};
-/** Stable PObject id */
-type PObjectId = Branded$1<string, "PColumnId">;
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_spec.d.ts
+//#region src/drivers/pframe/query/query_spec.d.ts
 /**
- * Full PObject representation.
+ * Join entry for spec-layer queries — the base join entry extended with
+ * per-axis domain constraints. Absent `qualifications` is equivalent to `[]`.
  *
- * @template Data type of the object referencing or describing the "data" part of the PObject
- * */
-interface PObject<Data> {
-  /** Fully rendered PObjects are assigned a stable identifier. */
-  readonly id: PObjectId;
-  /** PObject spec, allowing it to be found among other PObjects */
-  readonly spec: PObjectSpec;
-  /** A handle to data object */
-  readonly data: Data;
-}
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.d.ts
-//#region src/drivers/pframe/spec/spec.d.ts
-declare const ValueType: {
-  readonly Int: "Int";
-  readonly Long: "Long";
-  readonly Float: "Float";
-  readonly Double: "Double";
-  readonly String: "String";
-  readonly Bytes: "Bytes";
-};
-type AxisValueType = Extract<ValueType, "Int" | "Long" | "String">;
-type ColumnValueType = ValueType;
-/** PFrame columns and axes within them may store one of these types. */
-type ValueType = (typeof ValueType)[keyof typeof ValueType];
-type Metadata = Record<string, string>;
-declare const Domain: {
-  readonly Alphabet: "pl7.app/alphabet";
-  readonly BlockId: "pl7.app/blockId";
-  readonly VDJ: {
-    readonly Clustering: {
-      readonly BlockId: "pl7.app/vdj/clustering/blockId";
-    };
-    readonly ScClonotypeChain: {
-      readonly Index: "pl7.app/vdj/scClonotypeChain/index";
-    };
-  };
+ * @example
+ * {
+ *   entry: querySpec,
+ *   qualifications: [{ axis: { name: 'sample' }, contextDomain: { ... } }]
+ * }
+ */
+type SpecQueryJoinEntry<C = ColumnUniversalId> = QueryJoinEntry<SpecQuery<C>> & {
+  qualifications?: readonly {
+    /** Axis to qualify. */axis: SingleAxisSelector; /** Additional domain constraints for this axis. */
+    contextDomain: Domain;
+  }[];
 };
-type Domain = Metadata & Partial<{
-  [Domain.Alphabet]: "nucleotide" | "aminoacid" | (string & {});
-  [Domain.BlockId]: string;
-  [Domain.VDJ.ScClonotypeChain.Index]: "primary" | "secondary" | (string & {});
-}>;
+/** @see QueryColumn */
+type SpecQueryColumn<C = ColumnUniversalId> = QueryColumn<C>;
+/** @see QueryInlineColumn */
+type SpecQueryInlineColumn = QueryInlineColumn<PColumnIdAndSpec>;
+/** @see QuerySparseToDenseColumn */
+type SpecQuerySparseToDenseColumn<C = ColumnUniversalId> = QuerySparseToDenseColumn<C, SingleAxisSelector, PColumnIdAndSpec>;
+/** @see QuerySymmetricJoin */
+type SpecQuerySymmetricJoin<C = ColumnUniversalId> = QuerySymmetricJoin<SpecQueryJoinEntry<C>>;
+/** @see QueryOuterJoin */
+type SpecQueryOuterJoin<C = ColumnUniversalId> = QueryOuterJoin<SpecQueryJoinEntry<C>>;
+/** @see QueryLinkerJoin */
+type SpecQueryLinkerJoin<C = ColumnUniversalId> = QueryLinkerJoin<SpecQuery<C>, SpecQueryJoinEntry<C>>;
+/** @see QuerySliceAxes */
+type SpecQuerySliceAxes<C = ColumnUniversalId> = QuerySliceAxes<SpecQuery<C>, SingleAxisSelector>;
+/** @see QuerySort */
+type SpecQuerySort<C = ColumnUniversalId> = QuerySort<SpecQuery<C>, SpecQueryExpression>;
+/** @see QueryFilter */
+type SpecQueryFilter<C = ColumnUniversalId> = QueryFilter<SpecQuery<C>, SpecQueryBooleanExpression>;
+/** @see QueryTransformColumns */
+type SpecQueryTransformColumns<C = ColumnUniversalId> = QueryTransformColumns<SpecQuery<C>, SpecQueryExpression, PColumnIdAndSpec>;
 /**
- * Specification of an individual axis.
- *
- * Each axis is a part of a composite key that addresses data inside the PColumn.
+ * Client-side spec-override node — collapsed at the host boundary, never
+ * sent to pframe-engine.
  *
- * Each record inside a PColumn is addressed by a unique tuple of values set for
- * all the axes specified in the column spec.
+ * @see QuerySpecOverride
  */
-type AxisSpec = {
-  /** Type of the axis value. Should not use non-key types like float or double. */readonly type: AxisValueType; /** Name of the axis */
-  readonly name: string;
-  /** Adds auxiliary information to the axis name, type and parents to form a
-   * unique identifier */
-  readonly domain?: Record<string, string>;
-  /** Context domain provides additional axis identity that is matched
-   * by kinship rules (subset/superset/overlap) rather than exact equality */
-  readonly contextDomain?: Record<string, string>;
-  /** Any additional information attached to the axis that does not affect its
-   * identifier */
-  readonly annotations?: Record<string, string>;
-  /**
-   * Parent axes provide contextual grouping for the axis in question, establishing
-   * a hierarchy where the current axis is dependent on one or more axes for its
-   * full definition and meaning. For instance, in a data structure where each
-   * "container" axis may contain multiple "item" axes, the `item` axis would
-   * list the index of the `container` axis in this field to denote its dependency.
-   *
-   * This means that the identity or significance of the `item` axis is only
-   * interpretable when combined with its parent `container` axis. An `item` axis
-   * index by itself may be non-unique and only gains uniqueness within the context
-   * of its parent `container`. Therefore, the `parentAxes` field is essential for
-   * mapping these relationships and ensuring data coherence across nested or
-   * multi-level data models.
-   *
-   * A list of zero-based indices of parent axes in the overall axes specification
-   * from the column spec. Each index corresponds to the position of a parent axis
-   * in the list that defines the structure of the data model.
-   */
-  readonly parentAxes?: number[];
-};
-/** Parents are specs, not indexes; normalized axis can be used considering its parents independently from column */
-/** Common type representing spec for all the axes in a column */
-type AxesSpec = AxisSpec[];
+type SpecQuerySpecOverride<C = ColumnUniversalId> = QuerySpecOverride<SpecQuery<C>, SpecOverrides>;
 /**
- * Full column specification including all axes specs and specs of the column
- * itself.
- *
- * A PColumn in its essence represents a mapping from a fixed size, explicitly
- * typed tuple to an explicitly typed value.
+ * Union of all spec layer query types.
  *
- * (axis1Value1, axis2Value1, ...) -> columnValue
+ * The spec layer operates with named selectors and column IDs,
+ * making it suitable for user-facing query construction and validation.
  *
- * Each element in tuple correspond to the axis having the same index in axesSpec.
- */
-type PUniversalColumnSpec = PObjectSpec & {
-  /** Defines specific type of BObject, the most generic type of unit of
-   * information in Platforma Project. */
-  readonly kind: "PColumn"; /** Type of column values */
-  readonly valueType: string; /** Column name */
-  readonly name: string;
-  /** Adds auxiliary information to the axis name, type and parents to form a
-   * unique identifier */
-  readonly domain?: Record<string, string>;
-  /** Context domain provides additional column identity that is matched
-   * by kinship rules (subset/superset/overlap) rather than exact equality */
-  readonly contextDomain?: Record<string, string>;
-  /** Any additional information attached to the column that does not affect its
-   * identifier */
-  readonly annotations?: Record<string, string>; /** A list of zero-based indices of parent axes from the {@link axesSpec} array. */
-  readonly parentAxes?: number[]; /** Axes specifications */
-  readonly axesSpec: AxesSpec;
-};
-/**
- * Specification of a data column.
+ * @template C - Column reference type. Defaults to PObjectId (ID-only).
+ *   Can be parameterized with richer types (e.g., PColumn<Data>) to carry
+ *   full column data directly in the query tree.
  *
- * Data column is a specialized type of PColumn that stores only simple values (strings and numbers)
- * addressed by multiple keys. This is in contrast to other PColumn variants that can store more complex
- * values like files or other abstract data types. Data columns are optimized for storing and processing
- * basic tabular data.
+ * Includes:
+ * - Leaf nodes: column, inlineColumn, sparseToDenseColumn
+ * - Join operations: innerJoin, fullJoin, outerJoin, linkerJoin
+ * - Transformations: sliceAxes, sort, filter, transformColumns
+ * - Client-side overlays: specOverride (collapsed before reaching the engine)
  */
-type PDataColumnSpec = PUniversalColumnSpec & {
-  /** Type of column values */readonly valueType: ValueType;
-};
-type PColumnSpec = PDataColumnSpec;
-/** Unique PColumnSpec identifier */
-interface PColumn<Data> extends PObject<Data> {
-  /** PColumn spec, allowing it to be found among other PObjects */
-  readonly spec: PColumnSpec;
-}
-/** Columns in a PFrame also have internal identifier, this object represents
- * combination of specs and such id */
-interface PColumnIdAndSpec {
-  /** Internal column id within the PFrame */
-  readonly columnId: PObjectId;
-  /** Column spec */
-  readonly spec: PColumnSpec;
+type SpecQuery<C = ColumnUniversalId> = SpecQueryColumn<C> | SpecQueryInlineColumn | SpecQuerySparseToDenseColumn<C> | SpecQuerySymmetricJoin<C> | SpecQueryOuterJoin<C> | SpecQueryLinkerJoin<C> | SpecQuerySliceAxes<C> | SpecQuerySort<C> | SpecQueryFilter<C> | SpecQueryTransformColumns<C> | SpecQuerySpecOverride<C>;
+/** @see ExprAxisRef */
+type SpecExprAxisRef = ExprAxisRef<SingleAxisSelector>;
+/** @see ExprColumnRef */
+type SpecExprColumnRef = ExprColumnRef<ColumnUniversalId>;
+type SpecQueryExpression = SpecExprColumnRef | SpecExprAxisRef | ExprConstant | ExprNumericBinary<SpecQueryExpression> | ExprNumericComparison<SpecQueryExpression> | ExprNumericUnary<SpecQueryExpression> | ExprStringEquals<SpecQueryExpression> | ExprStringContains<SpecQueryExpression> | ExprStringRegex<SpecQueryExpression> | ExprStringContainsFuzzy<SpecQueryExpression> | ExprIsNull<SpecQueryExpression> | ExprFillNull<SpecQueryExpression> | ExprLogicalUnary<SpecQueryExpression> | ExprLogicalVariadic<SpecQueryExpression> | ExprIsIn<SpecQueryExpression, string> | ExprIsIn<SpecQueryExpression, number> | ExprCast<SpecQueryExpression> | ExprConditional<SpecQueryExpression> | ExprRanking<SpecQueryExpression, SingleAxisSelector, PObjectId>;
+type SpecQueryBooleanExpression = InferBooleanExpressionUnion<SpecQueryExpression>; //#endregion
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.d.ts
+//#region src/drivers/pframe/table_calculate.d.ts
+/** Defines a terminal column node in the join request tree */
+interface ColumnJoinEntry<Col> {
+  /** Node type discriminator */
+  readonly type: "column";
+  /** Local column */
+  readonly column: Col;
 }
-/** Get column id and spec from a column */
-interface AxisId {
-  /** Type of the axis or column value. For an axis should not use non-key
-   * types like float or double. */
-  readonly type: AxisValueType;
-  /** Name of the axis or column */
-  readonly name: string;
-  /** Adds auxiliary information to the axis or column name and type to form a
-   * unique identifier */
-  readonly domain?: Record<string, string>;
-  /** Context domain provides additional axis identity that is matched
-   * by kinship rules (subset/superset/overlap) rather than exact equality */
-  readonly contextDomain?: Record<string, string>;
+/**
+ * Axis filter slicing target axis from column axes.
+ * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).
+ * */
+interface ConstantAxisFilter {
+  /** Filter type discriminator */
+  readonly type: "constant";
+  /** Index of axis to slice (zero-based) */
+  readonly axisIndex: number;
+  /** Equality filter reference value, see {@link SingleValueEqualPredicate} */
+  readonly constant: string | number;
+}
+/** Defines a terminal column node in the join request tree */
+interface SlicedColumnJoinEntry<Col> {
+  /** Node type discriminator */
+  readonly type: "slicedColumn";
+  /** Local column */
+  readonly column: Col;
+  /** New column id */
+  readonly newId: PObjectId;
+  /** Non-empty list of axis filters */
+  readonly axisFilters: ConstantAxisFilter[];
+}
+interface ArtificialColumnJoinEntry<Col> {
+  /** Node type discriminator */
+  readonly type: "artificialColumn";
+  /** Column definition */
+  readonly column: Col;
+  /** New column id */
+  readonly newId: PObjectId;
+  /** Indices of axes to pick from the column (zero-based) */
+  readonly axesIndices: number[];
+}
+/** Defines a terminal column node in the join request tree */
+interface InlineColumnJoinEntry {
+  /** Node type discriminator */
+  readonly type: "inlineColumn";
+  /** Column definition */
+  readonly column: PColumn<PColumnValues>;
 }
-/** Array of axis ids */
-type AxesId = AxisId[];
-/** Extracts axis ids from axis spec */
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_data.d.ts
-//#region src/drivers/pframe/query/query_data.d.ts
 /**
- * Column identifier with type specification.
- *
- * Pairs a column ID with its full type specification (axes and column types).
- * Used in data layer to carry type information alongside column references.
- */
-type ColumnIdAndTypeSpec = {
-  /** Unique identifier of the column */id: PObjectId; /** Type specification defining the axes and the single column value type */
-  spec: ColumnTypeSpec;
-};
+ * Defines a join request tree node that will output only records present in
+ * all child nodes ({@link entries}).
+ * */
+interface InnerJoin<Col> {
+  /** Node type discriminator */
+  readonly type: "inner";
+  /** Child nodes to be inner joined */
+  readonly entries: JoinEntry<Col>[];
+}
 /**
- * Join entry for data layer queries.
- *
- * Extends the base join entry with axes mapping information.
- * The mapping specifies how axes from this entry align with the joined result.
- *
- * @example
- * // Join entry with axes mapping [0, 2] means:
- * // - This entry's axis 0 maps to result axis 0
- * // - This entry's axis 1 maps to result axis 2
- * { entry: queryData, axesMapping: [0, 2] }
- */
-interface DataQueryJoinEntry extends QueryJoinEntry<DataQuery> {
-  /** Maps this entry's axes to the result axes by index */
-  axesMapping: number[];
+ * Defines a join request tree node that will output all records present at
+ * least in one of the child nodes ({@link entries}), values for those PColumns
+ * that lack corresponding combinations of axis values will be null.
+ * */
+interface FullJoin<Col> {
+  /** Node type discriminator */
+  readonly type: "full";
+  /** Child nodes to be fully outer joined */
+  readonly entries: JoinEntry<Col>[];
 }
-/** @see QueryColumn */
-type DataQueryColumn = QueryColumn;
-/** @see QueryInlineColumn */
-type DataQueryInlineColumn = QueryInlineColumn<ColumnIdAndTypeSpec>;
-/** @see QuerySparseToDenseColumn */
-type DataQuerySparseToDenseColumn = QuerySparseToDenseColumn<PObjectId, number, ColumnIdAndTypeSpec>;
-/** @see QuerySymmetricJoin */
-type DataQuerySymmetricJoin = QuerySymmetricJoin<DataQueryJoinEntry>;
-/** @see QueryOuterJoin */
-type DataQueryOuterJoin = QueryOuterJoin<DataQueryJoinEntry>;
 /**
- * Linker side of a data-layer linker-join.
+ * Defines a join request tree node that will output all records present in
+ * {@link primary} child node, and records from the {@link secondary} nodes will
+ * be added to the output only if present, values for those PColumns from the
+ * {@link secondary} list, that lack corresponding combinations of axis values
+ * will be null.
  *
- * Carries the linker column id along with integration-derived artifacts needed
- * for execution:
- * - `axesMapping` — how the linker's axes map into the joined result
- * - `oneSideAxesIndices` — which axis indices in the joined result to project out
- */
-type DataQueryLinkerJoinLinker = {
-  /** Linker column reference. */column: PObjectId; /** Linker's axes mapped into the joined result. */
-  axesMapping: number[]; /** Axis indices (in the joined result) to project out — the linker's one-side axes. */
-  oneSideAxesIndices: number[];
-};
-/** @see QueryLinkerJoin */
-type DataQueryLinkerJoin = QueryLinkerJoin<DataQueryLinkerJoinLinker, DataQueryJoinEntry>;
-/** @see QuerySliceAxes */
-type DataQuerySliceAxes = QuerySliceAxes<DataQuery, number>;
-/** @see QuerySort */
-type DataQuerySort = QuerySort<DataQuery, DataQueryExpression>;
-/** @see QueryFilter */
-type DataQueryFilter = QueryFilter<DataQuery, DataQueryBooleanExpression>;
-/** @see QueryTransformColumns */
-type DataQueryTransformColumns = QueryTransformColumns<DataQuery, DataQueryExpression, ColumnIdAndTypeSpec>;
+ * This node can be thought as a chain of SQL LEFT JOIN operations starting from
+ * the {@link primary} node and adding {@link secondary} nodes one by one.
+ * */
+interface OuterJoin<Col> {
+  /** Node type discriminator */
+  readonly type: "outer";
+  /** Primes the join operation. Left part of LEFT JOIN. */
+  readonly primary: JoinEntry<Col>;
+  /** Driven nodes, giving their values only if primary node have corresponding
+   * nodes. Right parts of LEFT JOIN chain. */
+  readonly secondary: JoinEntry<Col>[];
+}
 /**
- * Union of all data layer query types.
- *
- * The data layer operates with numeric indices for axes and columns,
- * making it suitable for runtime query execution and optimization.
- *
- * Includes:
- * - Leaf nodes: column, inlineColumn, sparseToDenseColumn
- * - Join operations: innerJoin, fullJoin, outerJoin, linkerJoin
- * - Transformations: sliceAxes, sort, filter, transformColumns
- */
-type DataQuery = DataQueryColumn | DataQueryInlineColumn | DataQuerySparseToDenseColumn | DataQuerySymmetricJoin | DataQueryOuterJoin | DataQueryLinkerJoin | DataQuerySliceAxes | DataQuerySort | DataQueryFilter | DataQueryTransformColumns;
-/** @see ExprAxisRef */
-type DataExprAxisRef = ExprAxisRef<number>;
-/** @see ExprColumnRef */
-type DataExprColumnRef = ExprColumnRef<number>;
-type DataQueryExpression = DataExprColumnRef | DataExprAxisRef | ExprConstant | ExprNumericBinary<DataQueryExpression> | ExprNumericComparison<DataQueryExpression> | ExprNumericUnary<DataQueryExpression> | ExprStringEquals<DataQueryExpression> | ExprStringContains<DataQueryExpression> | ExprStringRegex<DataQueryExpression> | ExprStringContainsFuzzy<DataQueryExpression> | ExprIsNull<DataQueryExpression> | ExprFillNull<DataQueryExpression> | ExprLogicalUnary<DataQueryExpression> | ExprLogicalVariadic<DataQueryExpression> | ExprIsIn<DataQueryExpression, string> | ExprIsIn<DataQueryExpression, number> | ExprCast<DataQueryExpression> | ExprConditional<DataQueryExpression> | ExprRanking<DataQueryExpression, number, number>;
-type DataQueryBooleanExpression = InferBooleanExpressionUnion<DataQueryExpression>; //#endregion
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.2/node_modules/@milaboratories/helpers/dist/types/brand.d.ts
-//#region src/types/brand.d.ts
-declare const __brand: unique symbol;
-type Branded<T, B> = T & {
-  readonly [__brand]: B;
-};
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec_driver.d.ts
-//#region src/drivers/pframe/spec_driver.d.ts
-/** Matches a string value either exactly or by regex pattern */
-type StringMatcher = {
-  type: "exact";
-  value: string;
-} | {
-  type: "regex";
-  value: string;
-};
-/** Map of key to array of string matchers (OR-ed per key, AND-ed across keys) */
-type MatcherMap = Record<string, StringMatcher[]>;
-/** Selector for matching axes by various criteria */
-interface MultiAxisSelector {
-  /** Match any of the axis types listed here */
-  readonly type?: AxisValueType[];
-  /** Match any of the axis names listed here */
-  readonly name?: StringMatcher[];
-  /** Match requires all the domains listed here */
-  readonly domain?: MatcherMap;
-  /** Match requires all the context domains listed here */
-  readonly contextDomain?: MatcherMap;
-  /** Match requires all the annotations listed here */
-  readonly annotations?: MatcherMap;
+ * Base type of all join request tree nodes. Join request tree allows to combine
+ * information from multiple PColumns into a PTable. Correlation between records
+ * is performed by looking for records with the same values in common axis between
+ * the PColumns. Common axis are those axis which have equal {@link AxisId} derived
+ * from the columns axes spec.
+ * */
+type JoinEntry<Col> = ColumnJoinEntry<Col> | SlicedColumnJoinEntry<Col> | ArtificialColumnJoinEntry<Col> | InlineColumnJoinEntry | InnerJoin<Col> | FullJoin<Col> | OuterJoin<Col>;
+/** Container representing whole data stored in specific PTable column. */
+interface FullPTableColumnData {
+  /** Unified spec */
+  readonly spec: PTableColumnSpec;
+  /** Data */
+  readonly data: PTableVector;
 }
-/** Column selector for discover columns request, matching columns by various criteria.
- * Multiple selectors are OR-ed: a column matches if it satisfies any selector. */
-interface MultiColumnSelector {
-  /** Match any of the value types listed here */
-  readonly type?: ColumnValueType[];
-  /** Match any of the names listed here */
-  readonly name?: StringMatcher[];
-  /** Match requires all the domains listed here */
-  readonly domain?: MatcherMap;
-  /** Match requires all the context domains listed here */
-  readonly contextDomain?: MatcherMap;
-  /** Match requires all the annotations listed here */
-  readonly annotations?: MatcherMap;
-  /** Match any of the axis selectors listed here */
-  readonly axes?: MultiAxisSelector[];
-  /** When true (default), allows matching if only a subset of axes match */
-  readonly partialAxesMatch?: boolean;
+interface SingleValueIsNAPredicate {
+  /** Comparison operator */
+  readonly operator: "IsNA";
 }
-/** Qualifications needed for both query (already-integrated) columns and the hit column. */
-interface ColumnAxesWithQualifications {
-  /** Already integrated (query) columns with their qualifications. */
-  axesSpec: AxisSpec[];
-  /** Qualifications for each already integrated (query) column. */
-  qualifications: AxisQualification[];
+interface SingleValueEqualPredicate {
+  /** Comparison operator */
+  readonly operator: "Equal";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
 }
-/** Fine-grained constraints controlling axes matching and qualification behavior */
-interface DiscoverColumnsConstraints {
-  /** Allow source (query) axes that have no match in the hit column */
-  allowFloatingSourceAxes: boolean;
-  /** Allow hit column axes that have no match in the source (query) */
-  allowFloatingHitAxes: boolean;
-  /** Allow source (query) axes to be qualified (contextDomain extended) */
-  allowSourceQualifications: boolean;
-  /** Allow hit column axes to be qualified (contextDomain extended) */
-  allowHitQualifications: boolean;
+interface SingleValueInSetPredicate {
+  /** Comparison operator */
+  readonly operator: "InSet";
+  /** Reference values, NA values will not match */
+  readonly references: (string | number)[];
 }
-/** Request for discovering columns compatible with a given axes integration */
-interface DiscoverColumnsRequest {
-  /** Include columns matching these selectors (OR-ed); empty or omitted matches all columns */
-  includeColumns?: MultiColumnSelector[];
-  /** Exclude columns matching these selectors (OR-ed); applied after include filter */
-  excludeColumns?: MultiColumnSelector[];
-  /** Already integrated axes with qualifications */
-  axes: ColumnAxesWithQualifications[];
-  /** Maximum number of hops allowed between provided axes integration and returned hits (0 = direct only) */
-  maxHops?: number;
-  /** Constraints controlling axes matching and qualification behavior */
-  constraints: DiscoverColumnsConstraints;
+interface SingleValueIEqualPredicate {
+  /** Comparison operator (case insensitive) */
+  readonly operator: "IEqual";
+  /** Reference value, NA values will not match */
+  readonly reference: string;
 }
-/** Linker step: traversal through a linker column */
-interface DiscoverColumnsLinkerStep {
-  type: "linker";
-  /** The linker column traversed in this step */
-  linker: PColumnIdAndSpec;
+interface SingleValueLessPredicate {
+  /** Comparison operator */
+  readonly operator: "Less";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
+}
+interface SingleValueLessOrEqualPredicate {
+  /** Comparison operator */
+  readonly operator: "LessOrEqual";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
+}
+interface SingleValueGreaterPredicate {
+  /** Comparison operator */
+  readonly operator: "Greater";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
 }
+interface SingleValueGreaterOrEqualPredicate {
+  /** Comparison operator */
+  readonly operator: "GreaterOrEqual";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
+}
+interface SingleValueStringContainsPredicate {
+  /** Comparison operator */
+  readonly operator: "StringContains";
+  /** Reference substring, NA values are skipped */
+  readonly substring: string;
+}
+interface SingleValueStringIContainsPredicate {
+  /** Comparison operator (case insensitive) */
+  readonly operator: "StringIContains";
+  /** Reference substring, NA values are skipped */
+  readonly substring: string;
+}
+interface SingleValueMatchesPredicate {
+  /** Comparison operator */
+  readonly operator: "Matches";
+  /** Regular expression, NA values are skipped */
+  readonly regex: string;
+}
+interface SingleValueStringContainsFuzzyPredicate {
+  /** Comparison operator */
+  readonly operator: "StringContainsFuzzy";
+  /** Reference value, NA values are skipped */
+  readonly reference: string;
+  /**
+   * Integer specifying the upper bound of edit distance between
+   * reference and actual value.
+   * When {@link substitutionsOnly} is not defined or set to false
+   * Levenshtein distance is used (substitutions and indels)
+   * @see https://en.wikipedia.org/wiki/Levenshtein_distance
+   * When {@link substitutionsOnly} is set to true
+   * Hamming distance is used (substitutions only)
+   * @see https://en.wikipedia.org/wiki/Hamming_distance
+   */
+  readonly maxEdits: number;
+  /** Changes the type of edit distance in {@link maxEdits} */
+  readonly substitutionsOnly?: boolean;
+  /**
+   * Some character in {@link reference} that will match any
+   * single character in searched text.
+   */
+  readonly wildcard?: string;
+}
+interface SingleValueStringIContainsFuzzyPredicate {
+  /** Comparison operator (case insensitive) */
+  readonly operator: "StringIContainsFuzzy";
+  /** Reference value, NA values are skipped */
+  readonly reference: string;
+  /**
+   * Integer specifying the upper bound of edit distance between
+   * reference and actual value.
+   * When {@link substitutionsOnly} is not defined or set to false
+   * Levenshtein distance is used (substitutions and indels)
+   * @see https://en.wikipedia.org/wiki/Levenshtein_distance
+   * When {@link substitutionsOnly} is set to true
+   * Hamming distance is used (substitutions only)
+   * @see https://en.wikipedia.org/wiki/Hamming_distance
+   */
+  readonly maxEdits: number;
+  /** Changes the type of edit distance in {@link maxEdits} */
+  readonly substitutionsOnly?: boolean;
+  /**
+   * Some character in {@link reference} that will match any
+   * single character in searched text.
+   */
+  readonly wildcard?: string;
+}
+interface SingleValueNotPredicateV2 {
+  /** Comparison operator */
+  readonly operator: "Not";
+  /** Operand to negate */
+  readonly operand: SingleValuePredicateV2;
+}
+interface SingleValueAndPredicateV2 {
+  /** Comparison operator */
+  readonly operator: "And";
+  /** Operands to combine */
+  readonly operands: SingleValuePredicateV2[];
+}
+interface SingleValueOrPredicateV2 {
+  /** Comparison operator */
+  readonly operator: "Or";
+  /** Operands to combine */
+  readonly operands: SingleValuePredicateV2[];
+}
+/** Filtering predicate for a single axis or column value */
+type SingleValuePredicateV2 = SingleValueIsNAPredicate | SingleValueEqualPredicate | SingleValueInSetPredicate | SingleValueLessPredicate | SingleValueLessOrEqualPredicate | SingleValueGreaterPredicate | SingleValueGreaterOrEqualPredicate | SingleValueStringContainsPredicate | SingleValueMatchesPredicate | SingleValueStringContainsFuzzyPredicate | SingleValueNotPredicateV2 | SingleValueAndPredicateV2 | SingleValueOrPredicateV2 | SingleValueIEqualPredicate | SingleValueStringIContainsPredicate | SingleValueStringIContainsFuzzyPredicate;
+/**
+ * Filter PTable records based on specific axis or column value. If this is an
+ * axis value filter and the axis is part of a partitioning key in some of the
+ * source PColumns, the filter will be pushed down to those columns, so only
+ * specific partitions will be retrieved from the remote storage.
+ * */
+interface PTableRecordSingleValueFilterV2 {
+  /** Filter type discriminator */
+  readonly type: "bySingleColumnV2";
+  /** Target axis selector to examine values from */
+  readonly column: PTableColumnId;
+  /** Value predicate */
+  readonly predicate: SingleValuePredicateV2;
+}
+/** Generic PTable records filter */
+type PTableRecordFilter = PTableRecordSingleValueFilterV2;
+/** Sorting parameters for a PTable.  */
+type PTableSorting = {
+  /** Unified column identifier */readonly column: PTableColumnId; /** Sorting order */
+  readonly ascending: boolean; /** Sorting in respect to NA and absent values */
+  readonly naAndAbsentAreLeastValues: boolean;
+};
+/** Information required to instantiate a PTable. */
+interface PTableDef<Col> {
+  /** Join tree to populate the PTable */
+  readonly src: JoinEntry<Col>;
+  /** Partition filters */
+  readonly partitionFilters: PTableRecordFilter[];
+  /** Record filters */
+  readonly filters: PTableRecordFilter[];
+  /** Table sorting */
+  readonly sorting: PTableSorting[];
+}
+/** Information required to instantiate a PTable (V2, query-based). */
+interface PTableDefV2<Col> {
+  /** Pre-built query spec describing joins, filters and sorting */
+  readonly query: SpecQuery<Col>;
+}
+/** Request to create and retrieve entirety of data of PTable. */
+type CalculateTableDataRequest<Col> = {
+  /** Join tree to populate the PTable */readonly src: JoinEntry<Col>; /** Record filters */
+  readonly filters: PTableRecordFilter[]; /** Table sorting */
+  readonly sorting: PTableSorting[];
+};
+/** Response for {@link CalculateTableDataRequest} */
+type CalculateTableDataResponse = FullPTableColumnData[];
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/ref.d.ts
+//#region src/ref.d.ts
+declare const PlRef: ZodReadonly<ZodObject<{
+  __isRef: ZodLiteral<true>;
+  blockId: ZodString;
+  name: ZodString;
+  requireEnrichments: ZodOptional<ZodLiteral<true>>;
+}, "strip", ZodTypeAny, {
+  __isRef: true;
+  blockId: string;
+  name: string;
+  requireEnrichments?: true | undefined;
+}, {
+  __isRef: true;
+  blockId: string;
+  name: string;
+  requireEnrichments?: true | undefined;
+}>>;
+type PlRef = TypeOf<typeof PlRef>;
+/** @deprecated use {@link PlRef} */
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/pool/spec.d.ts
+//#region src/pool/spec.d.ts
+/** Any object exported into the result pool by the block always have spec attached to it */
+type PObjectSpec = {
+  /** PObject kind discriminator */readonly kind: string; /** Name is common part of PObject identity */
+  readonly name: string; /** Domain is a set of key-value pairs that can be used to identify the object */
+  readonly domain?: Record<string, string>;
+  /** Context domain provides additional axis/column identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>; /** Additional information attached to the object */
+  readonly annotations?: Record<string, string>;
+};
+type LocalPObjectKey = {
+  resolvePath: string[];
+  name: string;
+};
+type LocalPObjectId = Branded<CanonicalizedJson<LocalPObjectKey>, "LocalPObjectId">;
+type GlobalPObjectKey = PlRef;
+type GlobalPObjectId = Branded<CanonicalizedJson<GlobalPObjectKey>, "GlobalPObjectId">;
+/** Stable PObject id */
+type PObjectId = LocalPObjectId | GlobalPObjectId;
 /**
- * Filter step: intersects the current subquery with a filter column on shared
- * axes. Filter columns carry `pl7.app/isSubset: "true"` with axes ⊆ dataset
- * axes, so the inner-join narrows the key space to rows where the filter is
- * present.
- */
-interface DiscoverColumnsFilterStep {
-  type: "filter";
-  /** The filter column applied in this step */
-  filter: PColumnIdAndSpec;
+ * Full PObject representation.
+ *
+ * @template Data type of the object referencing or describing the "data" part of the PObject
+ * */
+interface PObject<Data> {
+  /** Fully rendered PObjects are assigned a stable identifier. */
+  readonly id: PObjectId;
+  /** PObject spec, allowing it to be found among other PObjects */
+  readonly spec: PObjectSpec;
+  /** A handle to data object */
+  readonly data: Data;
 }
-/** A step traversed during path-based column discovery. Discriminated by `type`. */
-type DiscoverColumnsStepInfo = DiscoverColumnsLinkerStep | DiscoverColumnsFilterStep;
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/spec.d.ts
+//#region src/drivers/pframe/spec/spec.d.ts
+declare const ValueType: {
+  readonly Int: "Int";
+  readonly Long: "Long";
+  readonly Float: "Float";
+  readonly Double: "Double";
+  readonly String: "String";
+  readonly Bytes: "Bytes";
+};
+type AxisValueType = Extract<ValueType, "Int" | "Long" | "String">;
+type ColumnValueType = ValueType;
+/** PFrame columns and axes within them may store one of these types. */
+type ValueType = (typeof ValueType)[keyof typeof ValueType];
+type Metadata = Record<string, string>;
+declare const Domain: {
+  readonly Alphabet: "pl7.app/alphabet";
+  readonly BlockId: "pl7.app/blockId";
+  readonly VDJ: {
+    readonly Clustering: {
+      readonly BlockId: "pl7.app/vdj/clustering/blockId";
+    };
+    readonly ScClonotypeChain: {
+      readonly Index: "pl7.app/vdj/scClonotypeChain/index";
+    };
+  };
+};
+type Domain = Metadata & Partial<{
+  [Domain.Alphabet]: "nucleotide" | "aminoacid" | (string & {});
+  [Domain.BlockId]: string;
+  [Domain.VDJ.ScClonotypeChain.Index]: "primary" | "secondary" | (string & {});
+}>;
 /**
- * Input to `buildQuery`: a terminal column plus an ordered
- * path of wrapping steps (linker hops, filter joins). Produces a
- * {@link SpecQueryJoinEntry} ready to be plugged into an
- * `innerJoin`/`fullJoin`/`outerJoin` entry list.
- *
- * Path ordering: `path[0]` is outermost (first applied), `path[N-1]` is
- * closest to `column`. Omit or pass `[]` for a direct column with no
- * wrapping.
+ * Specification of an individual axis.
  *
- * Columns are referenced by id — specs are resolved later at
- * `evaluateQuery` against the registered specs of the PFrame, so the
- * caller cannot disagree with the frame about spec content.
+ * Each axis is a part of a composite key that addresses data inside the PColumn.
  *
- * Qualifications annotate the resulting outermost entry; they do not
- * propagate into the inner query.
+ * Each record inside a PColumn is addressed by a unique tuple of values set for
+ * all the axes specified in the column spec.
  */
-type BuildQueryInput = {
-  /** Shape version marker — bumped only on breaking structural changes. */readonly version: "v1"; /** Terminal column id — the column actually returning data. */
-  readonly column: PObjectId; /** Ordered path from source integration to `column`. Outermost first. */
-  readonly path?: DiscoverColumnsStepInfo[]; /** Axis qualifications attached to the resulting join entry. */
-  readonly qualifications?: AxisQualification[];
-};
-/** Qualifications info for a discover columns response mapping variant */
-interface DiscoverColumnsResponseQualifications {
-  /** Qualifications for each query (already-integrated) column set */
-  forQueries: AxisQualification[][];
-  /** Qualifications for the hit column */
-  forHit: AxisQualification[];
-}
-/** A single mapping variant describing how a hit column can be integrated */
-interface DiscoverColumnsMappingVariant {
-  /** Full qualifications needed for integration */
-  qualifications: DiscoverColumnsResponseQualifications;
-  /** Distinctive (minimal) qualifications needed for integration */
-  distinctiveQualifications: DiscoverColumnsResponseQualifications;
-}
-/** A single hit in the discover columns response */
-interface DiscoverColumnsResponseHit {
-  /** The column that was found compatible */
-  hit: PColumnIdAndSpec;
-  /** Possible ways to integrate this column with the existing set */
-  mappingVariants: DiscoverColumnsMappingVariant[];
-  /** Linker steps traversed to reach this hit; empty for direct matches */
-  path: DiscoverColumnsStepInfo[];
-}
-/** Response from discover columns */
-interface DiscoverColumnsResponse {
-  /** Columns that could be integrated and possible ways to integrate them */
-  hits: DiscoverColumnsResponseHit[];
-}
-/** Request for deleting an entry from a given axes integration */
-interface DeleteColumnRequest {
-  /** Already integrated axes with qualifications */
-  axes: ColumnAxesWithQualifications[];
-  /** Zero based index of the entry to be deleted */
-  delete: number;
-}
-/** Response from delete column */
-interface DeleteColumnResponse {
-  axes: ColumnAxesWithQualifications[];
-}
-/** Response from evaluating a query against a PFrame. */
-type EvaluateQueryResponse = {
-  /**
-   * The table specification describing the structure of the query result,
-   * including all axes and columns that will be present in the output.
-   */
-  tableSpec: PTableColumnSpec[];
+type AxisSpec = {
+  /** Type of the axis value. Should not use non-key types like float or double. */readonly type: AxisValueType; /** Name of the axis */
+  readonly name: string;
+  /** Adds auxiliary information to the axis name, type and parents to form a
+   * unique identifier */
+  readonly domain?: Record<string, string>;
+  /** Context domain provides additional axis identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
+  /** Any additional information attached to the axis that does not affect its
+   * identifier */
+  readonly annotations?: Record<string, string>;
   /**
-   * The data layer query representation with numeric indices,
-   * suitable for execution by the data processing engine.
+   * Parent axes provide contextual grouping for the axis in question, establishing
+   * a hierarchy where the current axis is dependent on one or more axes for its
+   * full definition and meaning. For instance, in a data structure where each
+   * "container" axis may contain multiple "item" axes, the `item` axis would
+   * list the index of the `container` axis in this field to denote its dependency.
+   *
+   * This means that the identity or significance of the `item` axis is only
+   * interpretable when combined with its parent `container` axis. An `item` axis
+   * index by itself may be non-unique and only gains uniqueness within the context
+   * of its parent `container`. Therefore, the `parentAxes` field is essential for
+   * mapping these relationships and ensuring data coherence across nested or
+   * multi-level data models.
+   *
+   * A list of zero-based indices of parent axes in the overall axes specification
+   * from the column spec. Each index corresponds to the position of a parent axis
+   * in the list that defines the structure of the data model.
    */
-  dataQuery: DataQuery;
+  readonly parentAxes?: number[];
 };
-/** Handle to a spec-only PFrame (no data, synchronous operations). */
-type SpecFrameHandle = Branded<string, "SpecFrameHandle">;
+/** Parents are specs, not indexes; normalized axis can be used considering its parents independently from column */
+/** Common type representing spec for all the axes in a column */
+type AxesSpec = AxisSpec[];
 /**
- * Synchronous driver for spec-level PFrame operations.
+ * Full column specification including all axes specs and specs of the column
+ * itself.
  *
- * Unlike the async PFrameDriver (which works with data), this driver
- * operates on column specifications only. All methods are synchronous
- * because the underlying WASM PFrame computes results immediately.
+ * A PColumn in its essence represents a mapping from a fixed size, explicitly
+ * typed tuple to an explicitly typed value.
+ *
+ * (axis1Value1, axis2Value1, ...) -> columnValue
+ *
+ * Each element in tuple correspond to the axis having the same index in axesSpec.
  */
-interface PFrameSpecDriver {
-  /** Create a spec-only PFrame from column specs. Returns a pool entry with handle and unref. */
-  createSpecFrame(specs: Record<string, PColumnSpec>): PoolEntry<SpecFrameHandle>;
-  /** List all columns currently registered in the frame. */
-  listColumns(handle: SpecFrameHandle): PColumnIdAndSpec[];
-  /** Discover columns compatible with given axes integration. */
-  discoverColumns(handle: SpecFrameHandle, request: DiscoverColumnsRequest): DiscoverColumnsResponse;
-  /** Delete an entry from a given axes integration */
-  deleteColumn(handle: SpecFrameHandle, request: DeleteColumnRequest): DeleteColumnResponse;
-  /** Evaluates a query specification against this PFrame */
-  evaluateQuery(handle: SpecFrameHandle, request: SpecQuery): EvaluateQueryResponse;
-  /**
-   * Assembles a {@link SpecQueryJoinEntry} from a terminal column plus an
-   * ordered path of wrapping steps (linker hops, filter joins).
-   *
-   * Pure over its input — no frame handle is needed. Column ids are resolved
-   * later at {@link evaluateQuery} against the registered specs.
-   */
-  buildQuery(input: BuildQueryInput): SpecQueryJoinEntry;
-  /** Expand index-based parentAxes in AxesSpec to resolved AxisId parents in AxesId. */
-  expandAxes(spec: AxesSpec): AxesId;
-  /** Collapse resolved AxisId parents back to index-based parentAxes in AxesSpec. */
-  collapseAxes(ids: AxesId): AxesSpec;
-  /** Find the index of an axis matching the given selector. Returns -1 if not found. */
-  findAxis(spec: AxesSpec, selector: SingleAxisSelector): number;
-  /** Find the flat index of a table column matching the given selector. Returns -1 if not found. */
-  findTableColumn(tableSpec: PTableColumnSpec[], selector: PTableColumnId): number;
-  /**
-   * Upgrades selector-based legacy record filters into index-based data-layer
-   * boolean expressions, resolved against the provided unified table spec
-   * (axes first, then columns).
-   */
-  rewriteLegacyFilters(request: {
-    tableSpec: PTableColumnSpec[];
-    filters: PTableRecordFilter[];
-  }): DataQueryBooleanExpression[];
-} //#endregion
-//#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.d.ts
-/** Single axis selector */
-interface SingleAxisSelector {
-  /** Axis name (required) */
-  name: string;
-  /** Axis type (optional) */
-  type?: AxisValueType;
-  /** Domain requirements (optional) */
-  domain?: Domain;
-  /** Parent axes requirements (optional) */
-  parentAxes?: SingleAxisSelector[];
+type PUniversalColumnSpec = PObjectSpec & {
+  /** Defines specific type of BObject, the most generic type of unit of
+   * information in Platforma Project. */
+  readonly kind: "PColumn"; /** Type of column values */
+  readonly valueType: string; /** Column name */
+  readonly name: string;
+  /** Adds auxiliary information to the axis name, type and parents to form a
+   * unique identifier */
+  readonly domain?: Record<string, string>;
+  /** Context domain provides additional column identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
+  /** Any additional information attached to the column that does not affect its
+   * identifier */
+  readonly annotations?: Record<string, string>; /** A list of zero-based indices of parent axes from the {@link axesSpec} array. */
+  readonly parentAxes?: number[]; /** Axes specifications */
+  readonly axesSpec: AxesSpec;
+};
+/**
+ * Specification of a data column.
+ *
+ * Data column is a specialized type of PColumn that stores only simple values (strings and numbers)
+ * addressed by multiple keys. This is in contrast to other PColumn variants that can store more complex
+ * values like files or other abstract data types. Data columns are optimized for storing and processing
+ * basic tabular data.
+ */
+type PDataColumnSpec = PUniversalColumnSpec & {
+  /** Type of column values */readonly valueType: ValueType;
+};
+type PColumnSpec = PDataColumnSpec;
+/** Unique PColumnSpec identifier */
+interface PColumn<Data> extends PObject<Data> {
+  /** PColumn spec, allowing it to be found among other PObjects */
+  readonly spec: PColumnSpec;
 }
-/** Qualification applied to a single axis to make it compatible during integration. */
-interface AxisQualification {
-  /** Axis selector identifying which axis is qualified. */
-  readonly axis: SingleAxisSelector;
-  /** Additional context domain entries applied to the axis. */
-  readonly contextDomain: Record<string, string>;
+/** Columns in a PFrame also have internal identifier, this object represents
+ * combination of specs and such id */
+interface PColumnIdAndSpec {
+  /** Internal column id within the PFrame */
+  readonly columnId: PObjectId;
+  /** Column spec */
+  readonly spec: PColumnSpec;
+}
+/** Get column id and spec from a column */
+interface AxisId {
+  /** Type of the axis or column value. For an axis should not use non-key
+   * types like float or double. */
+  readonly type: AxisValueType;
+  /** Name of the axis or column */
+  readonly name: string;
+  /** Adds auxiliary information to the axis or column name and type to form a
+   * unique identifier */
+  readonly domain?: Record<string, string>;
+  /** Context domain provides additional axis identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
 }
+/** Array of axis ids */
+type AxesId = AxisId[];
+/** Extracts axis ids from axis spec */
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/filtered_column.d.ts
+//#region src/drivers/pframe/spec/filtered_column.d.ts
+/** Value of an axis filter */
+type AxisFilterValue = number | string;
+/** Axis filter by index */
+type AxisFilterByIdx = [number, AxisFilterValue];
+/** Axis filter by name */
 /**
- * Reference to an axis by its numerical index within the anchor column's axes array
- * Format: [anchorId, axisIndex]
+ * `source` is either a leaf {@link PObjectId} or a {@link ColumnDiscoveredId}.
+ * Filtered never nests inside Filtered (flat-merge invariant), and Filtered is
+ * never the outer wrapper around Overridden — Overridden is always outermost.
  */
+interface ColumnFilteredKey {
+  __isFiltered: true;
+  source: ColumnUniversalId;
+  axisFilters: AxisFilterByIdx[];
+}
+type ColumnFilteredId = Branded<CanonicalizedJson<ColumnFilteredKey>, "ColumnFilteredId">;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/ids.d.ts
+//#region src/drivers/pframe/spec/ids.d.ts
+/**
+ * Per-axis patches keyed by positional index in the base spec's `axesSpec`.
+ *
+ * Using position rather than `name` lets us disambiguate linker-style specs
+ * that carry multiple axes with the same `name` differentiated by `domain` /
+ * `contextDomain` (e.g. a `group`, `group/primary`, `group/secondary` triple).
+ *
+ * A patch at index `>= base.axesSpec.length` appends a new axis at that slot.
+ */
+type AxisPatches = Record<number, Partial<AxisSpec>>;
+/**
+ * Universal column identifier optionally anchored and optionally filtered.
+ * @deprecated use {@link ColumnUniversalKey}
+ */
 /**
  * Canonically serialized {@link UniversalPColumnId}.
+ * @deprecated use {@link ColumnUniversalId}
  */
-type SUniversalPColumnId = Branded$1<PObjectId, "SUniversalPColumnId", "__pl_model_brand_2__">;
+type SUniversalPColumnId = ColumnUniversalId;
+type ColumnUniversalId = LocalPObjectId | GlobalPObjectId | ColumnFilteredId | ColumnDiscoveredId | ColumnOverriddenId;
 /**
- * Canonically serializes a {@link UniversalPColumnId} to a string.
- * @param id - The column identifier to serialize
- * @returns The canonically serialized string
+ * Canonically serializes a column key to a branded string id. Accepts both
+ * the new {@link ColumnUniversalKey} and the deprecated {@link UniversalPColumnId}
+ * (anchored / old filtered object form).
  */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/interfaces.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/discovered_column.d.ts
+//#region src/drivers/pframe/spec/discovered_column.d.ts
+interface ColumnDiscoveredKey {
+  __isDiscovered: true;
+  column: ColumnUniversalId;
+  path?: PathItem[];
+  columnQualifications?: AxisQualification[];
+  queriesQualifications?: Record<PObjectId, AxisQualification[]>;
+}
+type ColumnDiscoveredId = Branded<CanonicalizedJson<ColumnDiscoveredKey>, "ColumnDiscoveredId">;
+type PathItem = {
+  type: "linker";
+  column: ColumnUniversalId;
+};
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/interfaces.d.ts
 //#region src/drivers/interfaces.d.ts
 /**
  * Intended to match web.Blob, node.Blob, node-fetch.Blob, etc.
@@ -3341,7 +3464,7 @@ interface FileLike extends BlobLike {
   readonly name: string;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/blob.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/blob.d.ts
 //#region src/drivers/blob.d.ts
 /** Handle of locally downloaded blob. This handle is issued only after the
  * blob's content is downloaded locally, and ready for quick access. */
@@ -3376,7 +3499,7 @@ interface BlobDriver {
  * Operational metrics of the blob download driver.
  */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/log.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/log.d.ts
 //#region src/drivers/log.d.ts
 /** Prefix constants — single source of truth for handle format. */
 declare const LIVE_LOG_PREFIX = "log+live://log/";
@@ -3443,7 +3566,7 @@ type StreamingApiResponseHandleOutdated = {
   shouldUpdateHandle: true;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/column_filter.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/column_filter.d.ts
 //#region src/drivers/pframe/column_filter.d.ts
 /** Allows to search multiple columns in different contexts. */
 interface ColumnFilter {
@@ -3462,7 +3585,7 @@ interface ColumnFilter {
   readonly annotationPattern?: Record<string, string>;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/find_columns.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/find_columns.d.ts
 //#region src/drivers/pframe/find_columns.d.ts
 /**
  * Request to search among existing columns in the PFrame. Two filtering
@@ -3489,7 +3612,7 @@ interface FindColumnsResponse {
   readonly hits: PColumnIdAndSpec[];
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/unique_values.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/unique_values.d.ts
 //#region src/drivers/pframe/unique_values.d.ts
 /** Calculate set of unique values for a specific axis for the filtered set of records */
 interface UniqueValuesRequest {
@@ -3509,7 +3632,79 @@ interface UniqueValuesResponse {
   readonly overflow: boolean;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/ls.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/pframe.d.ts
+/** Information required to instantiate a PFrame. */
+type PFrameDef<Col> = Col[]; //#endregion
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/driver.d.ts
+//#region src/drivers/pframe/driver.d.ts
+/** PFrame handle */
+type PFrameHandle = Branded$1<string, "PFrame">;
+/** PFrame handle */
+type PTableHandle = Branded$1<string, "PTable">;
+/** Model-side PFrame service — creates frames/tables from column definitions. */
+interface PFrameModelDriver<Col = PColumn<string | PColumnValues | DataInfo<string>>> {
+  createPFrame(def: PFrameDef<Col>): PFrameHandle;
+  createPTable(def: PTableDef<Col>): PTableHandle;
+  createPTableV2(def: PTableDefV2<Col>): PTableHandle;
+}
+/** Allows to access main data layer features of platforma */
+interface PFrameDriver {
+  /**
+   * Finds columns given filtering criteria on column name, annotations etc.
+   * and a set of axes ids to find only columns with compatible specs.
+   * */
+  findColumns(handle: PFrameHandle, request: FindColumnsRequest): Promise<FindColumnsResponse>;
+  /** Retrieve single column spec */
+  getColumnSpec(handle: PFrameHandle, columnId: PObjectId): Promise<PColumnSpec | null>;
+  /** Retrieve information about all columns currently added to the PFrame */
+  listColumns(handle: PFrameHandle): Promise<PColumnIdAndSpec[]>;
+  /** Calculates data for the table and returns complete data representation of it */
+  calculateTableData(handle: PFrameHandle, request: CalculateTableDataRequest<PObjectId>, range?: TableRange): Promise<CalculateTableDataResponse>;
+  /** Calculate set of unique values for a specific axis for the filtered set of records */
+  getUniqueValues(handle: PFrameHandle, request: UniqueValuesRequest): Promise<UniqueValuesResponse>;
+  /** Unified table shape */
+  getShape(handle: PTableHandle): Promise<PTableShape>;
+  /**
+   * Returns ordered array of table axes specs (primary key "columns" in SQL
+   * terms) and data column specs (regular "columns" in SQL terms).
+   *
+   * Data for a specific table column can be retrieved using unified indexing
+   * corresponding to elements in this array.
+   *
+   * Axes are always listed first.
+   * */
+  getSpec(handle: PTableHandle): Promise<PTableColumnSpec[]>;
+  /**
+   * Retrieve the data from the table. To retrieve only data required, it can be
+   * sliced both horizontally ({@link columnIndices}) and vertically
+   * ({@link range}).
+   *
+   * @param columnIndices unified indices of columns to be retrieved
+   * @param range optionally limit the range of records to retrieve
+   * */
+  getData(handle: PTableHandle, columnIndices: number[], range?: TableRange): Promise<PTableVector[]>;
+  /**
+   * Stream the table to a file at the given path. Caller is responsible
+   * for producing the destination path (e.g. via the `Dialog` service).
+   */
+  writePTableToFs(handle: PTableHandle, options: WritePTableToFsOptions): Promise<WritePTableToFsResult>;
+  /**
+   * Export the table to a file. The output format is selected from the file
+   * extension of `options.path` (`csv`, `tsv`, `parquet`, or `xlsx`).
+   *
+   * `options.columnIndices` selects the columns to export (output order). Column
+   * headers are derived on the driver side from each field's label annotation
+   * (falling back to its spec name), so the caller supplies only the path and
+   * the columns.
+   *
+   * For `xlsx` the driver rejects tables whose row count would exceed the
+   * 1,000,000-row per-sheet limit (below Excel's hard cap of 1,048,576).
+   */
+  exportPTable(handle: PTableHandle, options: ExportPTableOptions): Promise<void>;
+} //#endregion
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/ls.d.ts
 //#region src/drivers/ls.d.ts
 type ImportFileHandleUpload = `upload://upload/${string}`;
 type ImportFileHandleIndex = `index://index/${string}`;
@@ -3584,88 +3779,297 @@ interface LsDriver {
 }
 /** Gets a file path from an import handle. */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/pframe.d.ts
-/** Information required to instantiate a PFrame. */
-type PFrameDef<Col> = Col[]; //#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/columns/column_selector.d.ts
+//#region src/columns/column_selector.d.ts
+/** Relaxed string matcher input: plain string, single matcher, or array of mixed. */
+type RelaxedStringMatchers = string | StringMatcher | (string | StringMatcher)[];
+/** Relaxed record matcher: values can be plain strings or relaxed matchers. */
+type RelaxedRecord = Record<string, RelaxedStringMatchers>;
+/** Relaxed axis selector — accepts plain strings where strict requires StringMatcher[]. */
+interface RelaxedAxisSelector {
+  name?: RelaxedStringMatchers;
+  type?: AxisValueType | AxisValueType[];
+  domain?: RelaxedRecord;
+  contextDomain?: RelaxedRecord;
+  annotations?: RelaxedRecord;
+}
+/** Relaxed column selector — convenient hand-written form. */
+interface RelaxedColumnSelector {
+  name?: RelaxedStringMatchers;
+  type?: ColumnValueType | ColumnValueType[];
+  domain?: RelaxedRecord;
+  contextDomain?: RelaxedRecord;
+  annotations?: RelaxedRecord;
+  axes?: RelaxedAxisSelector[];
+  partialAxesMatch?: boolean;
+}
+/** One or many relaxed column selectors; normalizes to MultiColumnSelector[]. */
+type ColumnSelector = RelaxedColumnSelector | RelaxedColumnSelector[];
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/driver.d.ts
-//#region src/drivers/pframe/driver.d.ts
-/** PFrame handle */
-type PFrameHandle = Branded$1<string, "PFrame">;
-/** PFrame handle */
-type PTableHandle = Branded$1<string, "PTable">;
-/** Model-side PFrame service — creates frames/tables from column definitions. */
-interface PFrameModelDriver<Col = PColumn<string | PColumnValues | DataInfo<string>>> {
-  createPFrame(def: PFrameDef<Col>): PFrameHandle;
-  createPTable(def: PTableDef<Col>): PTableHandle;
-  createPTableV2(def: PTableDefV2<Col>): PTableHandle;
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/columns/discover_columns_options.d.ts
+//#region src/drivers/columns/discover_columns_options.d.ts
+/**
+ * Axis matching behaviour applied to `discover` requests.
+ *
+ * - `enrichment` (default) — anchor axes may float over un-mapped hit axes;
+ *   used by tooling that "extends" a query.
+ * - `related` — both source and hit axes may float; widest match.
+ * - `exact` — no floating, no qualifications; strict equality.
+ */
+type MatchingMode = "enrichment" | "related" | "exact";
+/**
+ * Single entry accepted by `DiscoverColumnsOptions.anchors`. All variants are
+ * trivially JSON-serialisable so the option carrier crosses the
+ * sandbox/host VM bridge unchanged.
+ */
+type AnchorEntry = PlRef | PObjectId | PColumnSpec | RelaxedColumnSelector;
+/** Qualifications needed for both already-integrated anchor columns and the hit column. */
+/**
+ * Options object accepted by sandbox `discoverColumns()` and by the host
+ * `ColumnsCollectionDriver.discover` / `.filter` methods. Pure JSON shape —
+ * no class instances, no closures.
+ */
+interface DiscoverColumnsOptions {
+  /** Include columns matching these selectors. If omitted, includes all. */
+  include?: ColumnSelector;
+  /** Exclude columns matching these selectors. */
+  exclude?: ColumnSelector;
+  /** Axis matching behavior. Default: 'enrichment'. Ignored if no anchors. */
+  mode?: MatchingMode;
+  /** Anchors enable axis-aware discovery + linker traversal. */
+  anchors?: Record<string, AnchorEntry>;
+  /** Maximum linker hops. Default: 4 when anchors present, 0 otherwise. */
+  maxHops?: number;
 }
-/** Allows to access main data layer features of platforma */
-interface PFrameDriver {
-  /**
-   * Finds columns given filtering criteria on column name, annotations etc.
-   * and a set of axes ids to find only columns with compatible specs.
-   * */
-  findColumns(handle: PFrameHandle, request: FindColumnsRequest): Promise<FindColumnsResponse>;
-  /** Retrieve single column spec */
-  getColumnSpec(handle: PFrameHandle, columnId: PObjectId): Promise<PColumnSpec | null>;
-  /** Retrieve information about all columns currently added to the PFrame */
-  listColumns(handle: PFrameHandle): Promise<PColumnIdAndSpec[]>;
-  /** Calculates data for the table and returns complete data representation of it */
-  calculateTableData(handle: PFrameHandle, request: CalculateTableDataRequest<PObjectId>, range?: TableRange): Promise<CalculateTableDataResponse>;
-  /** Calculate set of unique values for a specific axis for the filtered set of records */
-  getUniqueValues(handle: PFrameHandle, request: UniqueValuesRequest): Promise<UniqueValuesResponse>;
-  /** Unified table shape */
-  getShape(handle: PTableHandle): Promise<PTableShape>;
-  /**
-   * Returns ordered array of table axes specs (primary key "columns" in SQL
-   * terms) and data column specs (regular "columns" in SQL terms).
-   *
-   * Data for a specific table column can be retrieved using unified indexing
-   * corresponding to elements in this array.
-   *
-   * Axes are always listed first.
-   * */
-  getSpec(handle: PTableHandle): Promise<PTableColumnSpec[]>;
+/**
+ * Options accepted by `ColumnsCollection.discover` / driver `.discover`.
+ * Traversal scope (`mode`, `maxHops`) must be specified explicitly — the
+ * defaults from {@link DiscoverColumnsOptions} are intentionally surfaced as
+ * required choices at the discovery entrypoint.
+ */
+type ColumnsDiscoverOptions = DiscoverColumnsOptions;
+/**
+ * Options accepted by `ColumnsCollection.filter` / driver `.filter`. Traversal
+ * scope is fixed by the source collection, so `mode` / `maxHops` are not part
+ * of the filter surface — only `include` / `exclude` / `anchors`.
+ */
+type ColumnsFilterOptions = Omit<DiscoverColumnsOptions, "mode" | "maxHops">;
+/** Translate a {@link MatchingMode} into the boolean-flag form the spec driver consumes. */
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/columns/types.d.ts
+//#region src/columns/types.d.ts
+/**
+ * Opaque sandbox/host accessor handle.
+ *
+ * Both the sandbox `TreeNodeAccessor.handle` and the host-issued accessor
+ * keys alias this brand — `sdk/model` re-exports the same type so the two
+ * sides stay structurally identical.
+ */
+type AccessorHandle = Branded$1<string, "AccessorHandle">;
+/**
+ * Structural subset of {@link FieldTraversalStep} (from `@platforma-sdk/model`)
+ * needed by the host/sandbox column-providers traversal.
+ *
+ * Defined locally so this module does not depend on the sandbox `render`
+ * subtree. Both `TreeNodeAccessor.traverse` (sandbox) and
+ * `PlTreeNodeAccessor.traverse` (host) accept a superset of these fields, so
+ * structural compatibility is preserved.
+ */
+interface FieldTraversalStepLike {
+  /** Field name */
+  readonly field: string;
+  /** Asserted field type — used by `accessor.traverse` to validate. */
+  readonly assertFieldType?: "Input" | "Output" | "Service" | "OTW" | "Dynamic" | "MTW";
+  /** Don't terminate chain if current resource or field has an error associated. */
+  readonly ignoreError?: true;
+}
+/**
+ * Raw entry returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx}
+ * on the sandbox side, or by `collectUpstreamBlockCtx` on the host side.
+ * Carries handle ids only — providers wrap them into accessor instances as
+ * needed.
+ *
+ * Generic over the handle type so the same shape backs both:
+ * - sandbox (`AHandle = AccessorHandle`, a `Branded<string, "AccessorHandle">`)
+ * - host (`AHandle = PlTreeNodeAccessor`, the resolved accessor instance)
+ *
+ * Default `AHandle = string` since `AccessorHandle` is a brand on `string` —
+ * the default is safe for the sandbox case.
+ */
+interface UpstreamBlockCtx<AHandle = string> {
+  blockId: string;
+  prodCtx?: AHandle;
+  stagingCtx?: AHandle;
+  /** True when the `prodCtx` ctx-holder exists but `prodUiCtx` is still rendering. */
+  prodIncomplete?: boolean;
+  /** True when the `stagingCtx` ctx-holder exists but `stagingUiCtx` is still rendering. */
+  stagingIncomplete?: boolean;
+}
+/**
+ * Minimal accessor surface used by column-providers / column-registry
+ * traversal.
+ *
+ * Both sandbox `TreeNodeAccessor` and host `PlTreeNodeAccessor` satisfy this
+ * contract directly — `traverse(step)` is defined on both, and the other
+ * members already match by shape. No `resolvePath` member: when canonical
+ * `PObjectId`s are required (local-id construction inside the
+ * outputs/prerun branch), the traversal helpers thread the path explicitly.
+ */
+interface AccessorLike<Self extends AccessorLike<Self>> {
+  /** Resource type carried by the underlying node (only `.name` is used). */
+  readonly resourceType: {
+    readonly name: string;
+  };
   /**
-   * Retrieve the data from the table. To retrieve only data required, it can be
-   * sliced both horizontally ({@link columnIndices}) and vertically
-   * ({@link range}).
-   *
-   * @param columnIndices unified indices of columns to be retrieved
-   * @param range optionally limit the range of records to retrieve
-   * */
-  getData(handle: PTableHandle, columnIndices: number[], range?: TableRange): Promise<PTableVector[]>;
+   * Single-step field traversal. Returns `undefined` when the field is
+   * absent / unresolved (with `ignoreError`). Same shape on sandbox and host —
+   * sandbox `TreeNodeAccessor.traverse` is an alias for `resolveAny` and host
+   * `PlTreeNodeAccessor.traverse` is the canonical method.
+   */
+  traverse(step: FieldTraversalStepLike): Self | undefined;
+  /** List input-field names on this node. */
+  listInputFields(): string[];
+  /** Whether the input-field collection on this node is finalized. */
+  getInputsLocked(): boolean;
+  /** Whether this node has a data payload attached. */
+  hasData(): boolean;
+  /** Decode the data payload as JSON. Returns `undefined` if no data. */
+  getDataAsJson<T = unknown>(): T | undefined;
+}
+/**
+ * One indexed column — the canonical record produced by every traversal.
+ * Carries everything needed to read spec/data/status under a stable id.
+ *
+ * Generic over the accessor flavour so the same record shape works for both
+ * the sandbox `TreeNodeAccessor` and the host `PlTreeNodeAccessor`.
+ */
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/drivers/columns/columns_collection_driver.d.ts
+//#region src/drivers/columns/columns_collection_driver.d.ts
+/**
+ * Opaque host-owned handle for a `ColumnsCollection` instance. Issued by
+ * {@link ColumnsCollectionDriver.create}, refcounted by the driver, and
+ * pinned to the active render ctx via the VM injector — sandbox never
+ * sees raw refcounting.
+ */
+type CollectionHandle = Branded$1<string, "CollectionHandle">;
+/**
+ * JSON descriptor crossing the VM bridge in place of a sandbox
+ * `ColumnsSource`. Always plain data — no closures, no class instances.
+ *
+ * - `"collection"`  – reference another driver-managed collection by handle
+ *   (chaining, splicing).
+ * - `"result_pool"` – fan-out into the host's current render ctx upstream
+ *   block ctxes. Carries no payload — the host always uses its own pool.
+ * - `"accessor"`    – walk the host tree starting at the given accessor
+ *   handle from a `path` prefix.
+ * - `"ids"`         – pre-resolved id list (sandbox-materialised provider).
+ */
+type SerializedColumnsSource = {
+  readonly kind: "collection";
+  readonly handle: CollectionHandle;
+} | {
+  readonly kind: "result_pool";
+} | {
+  readonly kind: "accessor";
+  readonly accessor: AccessorHandle;
+  readonly path: string[];
+} | {
+  readonly kind: "ids";
+  readonly ids: ColumnUniversalId[];
+  readonly isFinal: boolean;
+};
+/**
+ * Per-call host bindings the driver needs to resolve sources whose
+ * shape references render-ctx state (`"accessor"`, `"result_pool"`).
+ *
+ * The VM injector inside `pl-middle-layer` supplies these on every call;
+ * UI-side direct callers that only build collections out of `"ids"` /
+ * `"collection"` sources may omit the bindings entirely.
+ *
+ * Parameterised on the concrete accessor flavour so host implementations
+ * keep their static types (e.g. `PlTreeNodeAccessor`) without leaking that
+ * dependency into `@milaboratories/pl-model-common`.
+ */
+interface ColumnsCollectionDriverHost<A extends AccessorLike<A> = AccessorLike<any>> {
+  /** Resolve an {@link AccessorHandle} to the host's concrete accessor. */
+  resolveAccessor(handle: AccessorHandle): A;
+  /** Snapshot of upstream-block ctx pairs from the current render ctx. */
+  getUpstreamBlockCtxes(): ReadonlyArray<UpstreamBlockCtx<A>>;
   /**
-   * Stream the table to a file at the given path. Caller is responsible
-   * for producing the destination path (e.g. via the `Dialog` service).
+   * Per-call spec driver. The injector supplies the active render ctx's
+   * `PFrameSpec` service; `discover` / `filter` use it to build a spec
+   * frame and run a single discovery query.
    */
-  writePTableToFs(handle: PTableHandle, options: WritePTableToFsOptions): Promise<WritePTableToFsResult>;
+  getSpecDriver(): PFrameSpecDriver;
   /**
-   * Export the table to a file. The output format is selected from the file
-   * extension of `options.path` (`csv`, `tsv`, `parquet`, or `xlsx`).
-   *
-   * `options.columnIndices` selects the columns to export (output order). Column
-   * headers are derived on the driver side from each field's label annotation
-   * (falling back to its spec name), so the caller supplies only the path and
-   * the columns.
-   *
-   * For `xlsx` the driver rejects tables whose row count would exceed the
-   * 1,000,000-row per-sheet limit (below Excel's hard cap of 1,048,576).
+   * Resolve the canonical {@link PColumnSpec} for a leaf {@link PObjectId}.
+   * Returns `undefined` when the id is not present in the active registry
+   * (e.g. handed to the driver via a `{kind:"ids"}` source whose underlying
+   * column has since left the visible scope). Override-wrapped ids are
+   * unwrapped by the caller — this method only resolves the underlying leaf.
    */
-  exportPTable(handle: PTableHandle, options: ExportPTableOptions): Promise<void>;
+  resolveSpec(id: PObjectId): PColumnSpec | undefined;
+}
+/**
+ * Sandbox / UI view of the `ColumnsCollection` driver. Same methods as
+ * {@link ColumnsCollectionDriver}, but the `host` parameters are dropped —
+ * the VM bridge / UI wrapper supplies them on every call so callers only
+ * pass plain data (handles + source descriptors + option objects).
+ *
+ * `getService("columnsCollection")` returns a value of this shape on both
+ * sandbox and UI sides.
+ */
+interface ColumnsCollectionDriverModel {
+  /** Build a fresh collection from the supplied source descriptors. */
+  create(sources: ReadonlyArray<SerializedColumnsSource>): CollectionHandle;
+  /** Whether the collection currently exposes zero columns. */
+  isEmpty(handle: CollectionHandle): boolean;
+  /** Whether enumeration is finalised across every contributing source. */
+  isFinal(handle: CollectionHandle): boolean;
+  /** Canonical id list for the columns visible through this collection. */
+  getColumns(handle: CollectionHandle): ColumnUniversalId[];
+  /** Append one or more sources and return a fresh collection handle. */
+  addSource(handle: CollectionHandle, sources: ReadonlyArray<SerializedColumnsSource>): CollectionHandle;
+  /** Anchored/selector-driven discovery. Returns a fresh handle. */
+  discover(handle: CollectionHandle, options: ColumnsDiscoverOptions): CollectionHandle;
+  /** Selector-only filter (no anchor traversal). Returns a fresh handle. */
+  filter(handle: CollectionHandle, options: ColumnsFilterOptions): CollectionHandle;
+}
+/**
+ * Synchronous host-side driver for `ColumnsCollection` operations. All
+ * collection state lives on the host side, addressable through opaque
+ * {@link CollectionHandle}s. Every handle-minting method returns a
+ * {@link PoolEntry} so callers can wire the refcount into their own
+ * lifecycle; the VM bridge pins each entry to the active render ctx and
+ * forwards only the handle string to sandbox.
+ *
+ * Sandbox / UI callers consume {@link ColumnsCollectionDriverModel}
+ * instead; the bridge maps that surface onto this one by injecting
+ * {@link ColumnsCollectionDriverHost} bindings.
+ */
+interface ColumnsCollectionDriver {
+  create(sources: ReadonlyArray<SerializedColumnsSource>, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+  isEmpty(handle: CollectionHandle): boolean;
+  isFinal(handle: CollectionHandle): boolean;
+  getColumns(handle: CollectionHandle, host: ColumnsCollectionDriverHost): ColumnUniversalId[];
+  addSource(handle: CollectionHandle, sources: ReadonlyArray<SerializedColumnsSource>, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+  discover(handle: CollectionHandle, options: ColumnsDiscoverOptions, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+  filter(handle: CollectionHandle, options: ColumnsFilterOptions, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/services/service_types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/services/service_types.d.ts
 //#region src/services/service_types.d.ts
-type ServiceTypesLike<Model = unknown, Ui = unknown, Kind extends ServiceType = ServiceType> = {
+type ServiceTypesLike<Model = unknown, Ui = unknown, Kind extends ServiceType = ServiceType, ModelHost = Model, UiHost = Ui> = {
   readonly __types?: {
     model: Model;
     ui: Ui;
     kind: Kind;
+    modelHost: ModelHost;
+    uiHost: UiHost;
   };
 };
-type InferServiceUi<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, infer U, ServiceType> ? U : unknown;
+type InferServiceUi<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, infer U, ServiceType, unknown, unknown> ? U : unknown;
 type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded$1<string, S>;
 type ServiceType = "node" | "wasm" | "main";
 type ServiceBrand<T> = T extends Branded$1<string, infer S extends ServiceTypesLike> ? S : never;
@@ -3685,15 +4089,16 @@ type ServiceNameLiterals = { [K in keyof TServices]: ExtractServiceName<TService
 /** Auto-derived requires* feature flags from Services keys. */
 type ServiceRequireFlags = { [K in keyof TServices as `requires${K & string}`]?: boolean };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.d.ts
 //#region src/services/service_declarations.d.ts
 declare const Services: {
-  PFrameSpec: Branded$1<"pframeSpec", ServiceTypesLike<PFrameSpecDriver, PFrameSpecDriver, "wasm">>;
-  PFrame: Branded$1<"pframe", ServiceTypesLike<PFrameModelDriver<PColumn<string | PColumnValues | DataInfo<string>>>, PFrameDriver, "node">>;
-  Dialog: Branded$1<"dialog", ServiceTypesLike<Record<string, never>, DialogService, "main">>;
+  PFrameSpec: Branded$1<"pframeSpec", ServiceTypesLike<PFrameSpecDriver, PFrameSpecDriver, "wasm", PFrameSpecDriver, PFrameSpecDriver>>;
+  PFrame: Branded$1<"pframe", ServiceTypesLike<PFrameModelDriver<PColumn<string | PColumnValues | DataInfo<string>>>, PFrameDriver, "node", PFrameModelDriver<PColumn<string | PColumnValues | DataInfo<string>>>, PFrameDriver>>;
+  Dialog: Branded$1<"dialog", ServiceTypesLike<Record<string, never>, DialogService, "main", Record<string, never>, DialogService>>;
+  ColumnsCollection: Branded$1<"columnsCollection", ServiceTypesLike<ColumnsCollectionDriverModel, ColumnsCollectionDriverModel, "wasm", ColumnsCollectionDriver, ColumnsCollectionDriver>>;
 }; //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.d.ts
 /**
  * Known block flags. Flags are set during model compilation, see `BlockModel.create` for more details and for initial values.
  */
@@ -3711,7 +4116,7 @@ type BlockCodeKnownFeatureFlags = {
  * older desktop apps.
  */
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/driver_kit.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/driver_kit.d.ts
 //#region src/driver_kit.d.ts
 /** Set of all drivers exposed in UI SDK via the platforma object. */
 interface DriverKit {
@@ -3732,7 +4137,7 @@ interface DriverKit {
   readonly pFrameDriver: PFrameDriver;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/errors.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/errors.d.ts
 type ResultOrError<S, F = Error> = {
   value: S;
   error?: undefined;
@@ -3740,7 +4145,7 @@ type ResultOrError<S, F = Error> = {
   error: F;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.46.3/node_modules/@milaboratories/pl-model-common/dist/utag.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.47.1/node_modules/@milaboratories/pl-model-common/dist/utag.d.ts
 //#region src/utag.d.ts
 /** Value returned for changing states supporting reactive listening for changes */
 interface ValueWithUTag<V> {
@@ -3759,7 +4164,7 @@ interface ValueWithUTagAndAuthor<V> extends ValueWithUTag<V> {
   readonly author?: AuthorMarker;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/block_state_patch.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_state_patch.d.ts
 //#region src/block_state_patch.d.ts
 /** Patch for the structural object */
 type Patch<K, V> = {
@@ -3771,7 +4176,7 @@ type Unionize<T extends Record<string, unknown>> = { [K in keyof T]: Patch<K, T[
 /** Patch for the BlockState, pushed by onStateUpdates method in SDK. */
 type BlockStatePatch<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = Unionize<BlockState<Args, Outputs, UiState, Href>>; //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/plugin_handle.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/plugin_handle.d.ts
 //#region src/plugin_handle.d.ts
 /**
  * Phantom-only base type for constraining PluginHandle's type parameter.
@@ -3800,7 +4205,7 @@ interface PluginFactoryLike<Data extends Record<string, unknown> = Record<string
 type PluginHandle<F extends PluginFactoryLike = PluginFactoryLike> = Branded<string, F>;
 /** Construct the output key for a plugin output in the block outputs map. */
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/block_storage.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_storage.d.ts
 /** Payload for storage mutation operations. SDK defines specific operations. */
 type MutateStoragePayload<T = unknown> = {
   operation: "update-block-data";
@@ -3818,7 +4223,7 @@ type MutateStoragePayload<T = unknown> = {
  * @returns A new BlockStorage with updated data
  */
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/bconfig/lambdas.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/bconfig/lambdas.d.ts
 /** Additional information that may alter lambda rendering procedure. */
 type ConfigRenderLambdaFlags = {
   /**
@@ -3855,7 +4260,7 @@ type InferOutputsFromLambdas<OutputsCfg extends Record<string, ConfigRenderLambd
   } ? false : true;
 } }; //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/block_api_v1.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_api_v1.d.ts
 //#region src/block_api_v1.d.ts
 /** Returned by state subscription methods to be able to cancel the subscription. */
 type CancelSubscription = () => void;
@@ -3950,7 +4355,7 @@ interface GetOperation<T> extends BaseOperation {
   value: T;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/block_api_v2.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_api_v2.d.ts
 //#region src/block_api_v2.d.ts
 /** Defines methods to read and write current block data. */
 interface BlockApiV2<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> {
@@ -4000,12 +4405,12 @@ interface BlockApiV2<Args = unknown, Outputs extends BlockOutputsBase = BlockOut
   dispose(): Promise<ResultOrError<void>>;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/version.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/version.d.ts
 type SdkInfo = {
   readonly sdkVersion: string;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/services/block_services.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/services/block_services.d.ts
 //#region src/services/block_services.d.ts
 /**
  * Services required by all V3 blocks by default.
@@ -4018,17 +4423,18 @@ declare const BLOCK_SERVICE_FLAGS: {
   readonly requiresPFrameSpec: true;
   readonly requiresPFrame: true;
   readonly requiresDialog: true;
+  readonly requiresColumnsCollection: true;
 };
 type BlockServiceFlags = typeof BLOCK_SERVICE_FLAGS;
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/services/service_resolve.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/services/service_resolve.d.ts
 //#region src/services/service_resolve.d.ts
 type FlagToName<Flag extends string> = Flag extends `requires${infer K}` ? K extends keyof ServiceNameLiterals ? ServiceNameLiterals[K] : never : never;
 type RequiredServiceNames<Flags> = { [K in keyof Flags & `requires${string}`]: Flags[K] extends true ? FlagToName<K & string> : never }[keyof Flags & `requires${string}`];
 type ResolveUiServices<Flags> = Pick<UiServices$1, RequiredServiceNames<Flags> & keyof UiServices$1>;
 type BlockDefaultUiServices = ResolveUiServices<BlockServiceFlags>; //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/plugin_model.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/plugin_model.d.ts
 /**
  * Runtime definition for a single public output field.
  * Stored in PluginModel and passed through BlockModelInfo to the UI layer.
@@ -4037,7 +4443,7 @@ type PublicOutputFieldDef = {
   readonly getter: (data: unknown) => unknown;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/block_api_v3.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/block_api_v3.d.ts
 //#region src/block_api_v3.d.ts
 /** Defines methods to read and write current block data. */
 interface BlockApiV3<_Data = unknown, _Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, Href extends `/${string}` = `/${string}`> {
@@ -4068,7 +4474,7 @@ interface BlockApiV3<_Data = unknown, _Args = unknown, Outputs extends BlockOutp
   dispose(): Promise<ResultOrError<void>>;
 } //#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.79.24/node_modules/@platforma-sdk/model/dist/platforma.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.80.2/node_modules/@platforma-sdk/model/dist/platforma.d.ts
 //#region src/platforma.d.ts
 /** Defines all methods to interact with the platform environment from within a block UI. @deprecated */
 interface PlatformaV1<Args = unknown, Outputs extends Record<string, OutputWithStatus<unknown>> = Record<string, OutputWithStatus<unknown>>, UiState = unknown, Href extends `/${string}` = `/${string}`> extends BlockApiV1<Args, Outputs, UiState, Href>, DriverKit {
@@ -4159,36 +4565,38 @@ type SelectedScope = {
 };
 /** A selectable scope. Alias of `SelectedScope` — the label lives on the base type. */
 /**
- * One embedding card in the settings list: a (sequence scope, model) task the
- * user assembles. `scope` and `model` are each undefined until picked — the UI
- * fills one and bidirectionally filters the other. `fidelity` applies only when
- * `model` is ESM-2.
+ * The single (sequence scope, model) selection the user assembles. `scope` and
+ * `model` are each undefined until picked — the UI fills one and bidirectionally
+ * filters the other. `fidelity` applies only when `model` is ESM-2. Always present
+ * in `BlockData` (initialised to `{}`); the args lambda wraps it into the workflow's
+ * 1-element task list, so the workflow's list contract is unchanged.
  */
-type EmbeddingCard = {
-  /** Stable card key for the `PlElementList` (`get-item-key`). */id: string;
+type EmbeddingSelection = {
   scope?: SelectedScope;
   model?: EmbeddingModelId; /** ESM-2 fidelity; ignored for other models. */
-  fidelity?: Fidelity; /** UI: card expanded in the list. */
-  isExpanded?: boolean;
+  fidelity?: Fidelity;
 };
 /**
- * Per-scope record in the Python step's `stats.json` output — one entry per
- * selected scope. `n_entities = 0` marks an empty scope.
+ * Frozen V2 card shape (per-card model selection, before the single-selection
+ * redesign). Kept only as the migration source type so `BlockDataV2` stays
+ * historically accurate; new code uses `EmbeddingSelection`. `id` was the stable
+ * key for V2's `PlElementList`; dropped in V3.
  */
 /**
- * V2 BlockData. Model selection moves per-scope: the global `fidelity` + flat
- * `selectedScopes` become a list of embedding cards, each a (scope, model,
- * fidelity?) task. Enables specialist models and same-scope model comparison.
+ * V3 BlockData. The card list collapses to a single (scope, model) selection: the
+ * block embeds ONE combination per run. `embedding` is always present (init `{}`);
+ * the args lambda wraps it into the workflow's 1-element task list, so the workflow
+ * contract is unchanged.
  */
-type BlockDataV2 = {
-  inputAnchor?: PlRef; /** The embedding cards (scope × model tasks) the user has assembled. */
-  embeddings: EmbeddingCard[];
+type BlockDataV3 = {
+  inputAnchor?: PlRef; /** The single (scope, model, fidelity?) selection the user assembles. */
+  embedding: EmbeddingSelection;
   /**
-   * Init-guard: canonical id of the anchor whose default cards were last seeded.
-   * Prevents re-seeding on panel reopen / server patch; triggers re-seed +
-   * reconciliation on input change.
+   * Init-guard: canonical id of the anchor whose default selection was last seeded.
+   * Prevents re-seeding on panel reopen / server patch; triggers a re-seed on
+   * input change.
    */
-  embeddingsInitializedForAnchor?: string; /** Advanced resource overrides (GiB / cores); undefined → workflow defaults. */
+  embeddingInitializedForAnchor?: string; /** Advanced resource overrides (GiB / cores); undefined → workflow sizes automatically from device + input. */
   mem?: number;
   cpu?: number;
   defaultBlockLabel?: string;
@@ -4196,7 +4604,7 @@ type BlockDataV2 = {
 /** Current BlockData shape. */
 /**
  * One embedding task in the workflow input: a scope plus the model to embed it
- * with (and ESM-2 fidelity, when applicable). Projected from `BlockData.embeddings`.
+ * with (and ESM-2 fidelity, when applicable). Projected from `BlockData.embedding`.
  */
 type EmbeddingTask = {
   scope: SelectedScope;
@@ -4205,20 +4613,20 @@ type EmbeddingTask = {
 };
 /**
  * Workflow input shape. Args projection in `index.ts` builds this from
- * `BlockData`, validating that `inputAnchor` is set and every card is a complete,
+ * `BlockData`, validating that `inputAnchor` is set and the selection is a complete,
  * compatible (scope, model) pair (throws otherwise — the V3 idiom replaces V1's
  * `.argsValid()`).
  */
 type BlockArgs = {
-  inputAnchor: PlRef; /** Tasks to emit, projected from `data.embeddings` (validated complete + compatible). */
-  embeddings: EmbeddingTask[]; /** Advanced resource overrides for the embedding step (GiB / cores); undefined → workflow defaults. */
+  inputAnchor: PlRef; /** Tasks to emit — a 1-element list projected from `data.embedding` (validated complete + compatible). */
+  embeddings: EmbeddingTask[]; /** Advanced resource overrides for the embedding step (GiB / cores); undefined → workflow sizes automatically. */
   mem?: number;
   cpu?: number;
 }; //#endregion
 //#endregion
 //#region ../model/dist/index.d.ts
 //#region src/index.d.ts
-declare const platforma: PlatformaExtended<PlatformaV3<BlockDataV2, BlockArgs, InferOutputsFromLambdas<{
+declare const platforma: PlatformaExtended<PlatformaV3<BlockDataV3, BlockArgs, InferOutputsFromLambdas<{
   inputOptions: ConfigRenderLambda<{
     readonly ref: {
       readonly __isRef: true;
@@ -4228,36 +4636,6 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockDataV2, BlockArgs, I
     };
     readonly label: string;
   }[]>;
-} & {
-  inputSpec: ConfigRenderLambda<{
-    readonly kind: "PColumn";
-    readonly name: string;
-    readonly domain?: {
-      [x: string]: string;
-    } | undefined;
-    readonly contextDomain?: {
-      [x: string]: string;
-    } | undefined;
-    readonly annotations?: {
-      [x: string]: string;
-    } | undefined;
-    readonly valueType: "Int" | "Long" | "Float" | "Double" | "String" | "Bytes";
-    readonly parentAxes?: number[] | undefined;
-    readonly axesSpec: {
-      readonly type: AxisValueType;
-      readonly name: string;
-      readonly domain?: {
-        [x: string]: string;
-      } | undefined;
-      readonly contextDomain?: {
-        [x: string]: string;
-      } | undefined;
-      readonly annotations?: {
-        [x: string]: string;
-      } | undefined;
-      readonly parentAxes?: number[] | undefined;
-    }[];
-  } | undefined>;
 } & {
   availableScopes: ConfigRenderLambda<{
     options: {
@@ -4284,7 +4662,8 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockDataV2, BlockArgs, I
   } | undefined>;
 } & {
   stats: ConfigRenderLambda<{
-    device_used: "cpu" | "gpu";
+    device_used: "cpu" | "cuda" | "mps";
+    device_requested?: "cpu" | "gpu" | undefined;
     model: ModelTag;
     max_length?: number | undefined;
     scopes: {
@@ -4296,7 +4675,7 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockDataV2, BlockArgs, I
       max_length?: number | undefined;
       n_entities?: number | undefined;
       n_dropped_empty?: number | undefined;
-      n_truncated?: number | undefined;
+      n_truncated?: number | null | undefined;
     }[];
   } | undefined>;
 } & {