@milaboratories/pl-model-common 1.48.0 → 1.50.0

package/dist/drivers/pframe/query/query_common.d.ts

@@ -1,14 +1,18 @@
 import { AxisValueType, ColumnValueType } from "../spec/spec.js";
+import "../spec/index.js";
 import { JsonDataInfo } from "../data_info.js";
 import { PObjectId } from "../../../pool/spec.js";
+import "../../../pool/index.js";
 //#region src/drivers/pframe/query/query_common.d.ts
 /**
  * Structural type information for a single column: the axis value types (in
  * order) and the single column value type. Mirrors the self-contained
  * `typeSpec` shape carried by the data layer (`{ axes, column }`).
  */
-type ColumnTypeSpec = {
-  /** List of axis value types defining the dimensions of the data */axes: AxisValueType[]; /** The single column value type */
+export type ColumnTypeSpec = {
+  /** List of axis value types defining the dimensions of the data */
+  axes: AxisValueType[];
+  /** The single column value type */
   column: ColumnValueType;
 };
 /**
@@ -29,7 +33,7 @@ type ColumnTypeSpec = {
  * - `exp` - Exponential function (e^x)
  * - `negate` - Negation (-x)
  */
-type NumericUnaryOperand = "abs" | "ceil" | "floor" | "round" | "sqrt" | "log" | "log2" | "log10" | "exp" | "negate";
+export type NumericUnaryOperand = "abs" | "ceil" | "floor" | "round" | "sqrt" | "log" | "log2" | "log10" | "exp" | "negate";
 /**
  * Binary mathematical operation kinds.
  *
@@ -44,7 +48,7 @@ type NumericUnaryOperand = "abs" | "ceil" | "floor" | "round" | "sqrt" | "log" |
  * - `mod` - Modulo: left % right
  * - `power` - Exponentiation: left ** right
  */
-type NumericBinaryOperand = "add" | "sub" | "mul" | "div" | "mod" | "power";
+export type NumericBinaryOperand = "add" | "sub" | "mul" | "div" | "mod" | "power";
 /**
  * Numeric comparison operation kinds.
  *
@@ -59,7 +63,7 @@ type NumericBinaryOperand = "add" | "sub" | "mul" | "div" | "mod" | "power";
  * - `gt` - Greater than: left > right
  * - `ge` - Greater or equal: left >= right
  */
-type NumericComparisonOperand = "eq" | "ne" | "lt" | "le" | "gt" | "ge";
+export type NumericComparisonOperand = "eq" | "ne" | "lt" | "le" | "gt" | "ge";
 /**
  * Constant value expression.
  *
@@ -76,7 +80,7 @@ type NumericComparisonOperand = "eq" | "ne" | "lt" | "le" | "gt" | "ge";
  * // Constant boolean
  * { type: 'constant', value: true }
  */
-type ExprConstant = {
+export type ExprConstant = {
   type: "constant";
   value: string | number | boolean;
 };
@@ -96,7 +100,7 @@ type ExprConstant = {
  * // Combine with NOT to check for non-null
  * { type: 'not', input: { type: 'isNull', input: columnRef } }
  */
-interface ExprIsNull<I> {
+export interface ExprIsNull<I> {
   type: "isNull";
   /** Input expression to check for null */
   input: I;
@@ -122,7 +126,7 @@ interface ExprIsNull<I> {
  * // Replace null strings with 'unknown'
  * { type: 'fillNull', input: nameColumn, replacement: { type: 'constant', value: 'unknown' } }
  */
-interface ExprFillNull<I> {
+export interface ExprFillNull<I> {
   type: "fillNull";
   /** Value to check for null */
   input: I;
@@ -148,7 +152,7 @@ interface ExprFillNull<I> {
  *
  * @see NumericUnaryOperand for available operations
  */
-interface ExprNumericUnary<I> {
+export interface ExprNumericUnary<I> {
   type: "numericUnary";
   /** The mathematical operation to apply */
   operand: NumericUnaryOperand;
@@ -174,7 +178,7 @@ interface ExprNumericUnary<I> {
  *
  * @see NumericBinaryOperand for available operations
  */
-interface ExprNumericBinary<I> {
+export interface ExprNumericBinary<I> {
   type: "numericBinary";
   /** The arithmetic operation to apply */
   operand: NumericBinaryOperand;
@@ -208,7 +212,7 @@ interface ExprNumericBinary<I> {
  *
  * @see NumericComparisonOperand for available operations
  */
-interface ExprNumericComparison<I> {
+export interface ExprNumericComparison<I> {
   type: "numericComparison";
   /** The comparison operation to apply */
   operand: NumericComparisonOperand;
@@ -237,7 +241,7 @@ interface ExprNumericComparison<I> {
  * // Matches: "john", "JOHN", "John", "jOhN"
  * { type: 'stringEquals', input: nameColumn, value: 'John', caseInsensitive: true }
  */
-interface ExprStringEquals<I> {
+export interface ExprStringEquals<I> {
   type: "stringEquals";
   /** Input expression (must evaluate to string) */
   input: I;
@@ -265,7 +269,7 @@ interface ExprStringEquals<I> {
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions | MDN Regular Expressions Guide}
  */
-interface ExprStringRegex<I> {
+export interface ExprStringRegex<I> {
   type: "stringRegex";
   /** Input expression (must evaluate to string) */
   input: I;
@@ -289,7 +293,7 @@ interface ExprStringRegex<I> {
  * // Case-insensitive contains
  * { type: 'stringContains', input: descColumn, value: 'ERROR', caseInsensitive: true }
  */
-interface ExprStringContains<I> {
+export interface ExprStringContains<I> {
   type: "stringContains";
   /** Input expression (must evaluate to string) */
   input: I;
@@ -332,7 +336,7 @@ interface ExprStringContains<I> {
  *   wildcard: '?'
  * }
  */
-interface ExprStringContainsFuzzy<I> {
+export interface ExprStringContainsFuzzy<I> {
   type: "stringContainsFuzzy";
   /** Input expression (must evaluate to string) */
   input: I;
@@ -371,7 +375,7 @@ interface ExprStringContainsFuzzy<I> {
  * // NOT (value > 10)
  * { type: 'not', input: comparisonExpr }
  */
-interface ExprLogicalUnary<I> {
+export interface ExprLogicalUnary<I> {
   type: "not";
   /** Input boolean expression to negate */
   input: I;
@@ -396,7 +400,7 @@ interface ExprLogicalUnary<I> {
  * // (status == 'active') OR (status == 'pending')
  * { type: 'or', input: [statusActive, statusPending] }
  */
-interface ExprLogicalVariadic<I> {
+export interface ExprLogicalVariadic<I> {
   /** Logical operation: 'and' or 'or' */
   type: "and" | "or";
   /** Array of boolean expressions to combine (minimum 2 elements) */
@@ -421,7 +425,7 @@ interface ExprLogicalVariadic<I> {
  *   set: ['active', 'pending', 'review']
  * }
  */
-interface ExprIsIn<I, T extends string | number> {
+export interface ExprIsIn<I, T extends string | number> {
   type: "isIn";
   /** Input expression to test */
   input: I;
@@ -442,7 +446,7 @@ interface ExprIsIn<I, T extends string | number> {
  *
  * @template I - The expression type (for recursion)
  */
-interface ExprCast<I> {
+export interface ExprCast<I> {
   type: "cast";
   /** Expression to cast. */
   input: I;
@@ -454,7 +458,7 @@ interface ExprCast<I> {
  *
  * @template I - The expression type (for recursion)
  */
-interface ExprConditionalCase<I> {
+export interface ExprConditionalCase<I> {
   /** Boolean predicate that selects this branch. */
   when: I;
   /** Value produced when `when` evaluates to true. */
@@ -482,7 +486,7 @@ interface ExprConditionalCase<I> {
  *   otherwise: { type: 'constant', value: 'low' }
  * }
  */
-interface ExprConditional<I> {
+export interface ExprConditional<I> {
   type: "conditional";
   /** Cases evaluated in order; first matching wins. At least one. */
   cases: [ExprConditionalCase<I>, ...ExprConditionalCase<I>[]];
@@ -490,7 +494,7 @@ interface ExprConditional<I> {
   otherwise?: I;
 }
 /** Ranking function kind. */
-type RankingKind = "rank" | "denseRank" | "rowNumber";
+export type RankingKind = "rank" | "denseRank" | "rowNumber";
 /**
  * Ranking expression (always a window function).
  *
@@ -501,7 +505,7 @@ type RankingKind = "rank" | "denseRank" | "rowNumber";
  * @template A - Axis selector type
  * @template C - Column selector type
  */
-interface ExprRanking<I, A, C> {
+export interface ExprRanking<I, A, C> {
   type: "ranking";
   /** Ranking semantics. */
   kind: RankingKind;
@@ -527,7 +531,7 @@ interface ExprRanking<I, A, C> {
  * // Reference axis by index (data layer)
  * { type: 'axisRef', value: 0 }
  */
-interface ExprAxisRef<A> {
+export interface ExprAxisRef<A> {
   type: "axisRef";
   /** Axis identifier (selector or index depending on context) */
   value: A;
@@ -547,12 +551,12 @@ interface ExprAxisRef<A> {
  * // Reference column by index (data layer)
  * { type: 'columnRef', value: 0 }
  */
-interface ExprColumnRef<C> {
+export interface ExprColumnRef<C> {
   type: "columnRef";
   /** Column identifier (ID or index depending on context) */
   value: C;
 }
-type InferBooleanExpressionUnion<E> = [E extends ExprNumericComparison<unknown> ? Extract<E, {
+export type InferBooleanExpressionUnion<E> = [E extends ExprNumericComparison<unknown> ? Extract<E, {
   type: "numericComparison";
 }> : never, E extends ExprStringEquals<unknown> ? Extract<E, {
   type: "stringEquals";
@@ -588,7 +592,7 @@ type InferBooleanExpressionUnion<E> = [E extends ExprNumericComparison<unknown>
  * // Select axis by index
  * { type: 'axis', id: 0 }
  */
-interface QueryAxisSelector<A> {
+export interface QueryAxisSelector<A> {
   type: "axis";
   /** Axis identifier (name or index depending on context) */
   id: A;
@@ -610,7 +614,7 @@ interface QueryAxisSelector<A> {
  * // Select column by index
  * { type: 'column', id: 0 }
  */
-interface QueryColumnSelector<C> {
+export interface QueryColumnSelector<C> {
   type: "column";
   /** Column identifier (name or index depending on context) */
   id: C;
@@ -622,7 +626,7 @@ interface QueryColumnSelector<C> {
  * `partitionBy` / `over` fields of window expressions where either an
  * axis or a column can drive the partition.
  */
-type QuerySelector<A, C> = QueryAxisSelector<A> | QueryColumnSelector<C>;
+export type QuerySelector<A, C> = QueryAxisSelector<A> | QueryColumnSelector<C>;
 /**
  * Left outer join query operation.
  *
@@ -649,7 +653,7 @@ type QuerySelector<A, C> = QueryAxisSelector<A> | QueryColumnSelector<C>;
  * }
  * // Result has all samples; annotations/metadata are null where not available
  */
-interface QueryOuterJoin<JE extends QueryJoinEntry<unknown>> {
+export interface QueryOuterJoin<JE extends QueryJoinEntry<unknown>> {
   type: "outerJoin";
   /** Primary query - all its records are preserved */
   primary: JE;
@@ -689,13 +693,15 @@ interface QueryOuterJoin<JE extends QueryJoinEntry<unknown>> {
  *   axisFilters: [{ axisSelector: 0, constant: 'Sample1' }]
  * }
  */
-interface QuerySliceAxes<Q, A> {
+export interface QuerySliceAxes<Q, A> {
   type: "sliceAxes";
   /** Input query to slice */
   input: Q;
   /** List of axis filters to apply (at least one required) */
   axisFilters: {
-    /** Axis to filter. `SingleAxisSelector` at the spec layer; axis index at the data layer. */axisSelector: A; /** The constant value to filter the axis to */
+    /** Axis to filter. `SingleAxisSelector` at the spec layer; axis index at the data layer. */
+    axisSelector: A;
+    /** The constant value to filter the axis to */
     constant: string | number;
   }[];
 }
@@ -725,13 +731,14 @@ interface QuerySliceAxes<Q, A> {
  *   ]
  * }
  */
-interface QuerySort<Q, E> {
+export interface QuerySort<Q, E> {
   type: "sort";
   /** Input query to sort */
   input: Q;
   /** Sort criteria in priority order (at least one required) */
   sortBy: {
-    expression: E; /** If true, sort ascending (A-Z, 0-9); if false, descending */
+    expression: E;
+    /** If true, sort ascending (A-Z, 0-9); if false, descending */
     ascending: boolean;
     /**
      * Null placement control:
@@ -773,7 +780,7 @@ interface QuerySort<Q, E> {
  *   }
  * }
  */
-interface QueryFilter<Q, E> {
+export interface QueryFilter<Q, E> {
   type: "filter";
   /** Input query to filter */
   input: Q;
@@ -795,7 +802,7 @@ interface QueryFilter<Q, E> {
  *
  * @template C - Column reference type (e.g., PObjectId for spec, full PColumn for rich queries)
  */
-interface QueryColumn<C = PObjectId> {
+export interface QueryColumn<C = PObjectId> {
   type: "column";
   /** Column reference (ID or full column object depending on context) */
   column: C;
@@ -819,7 +826,7 @@ interface QueryColumn<C = PObjectId> {
  *   dataInfo: { ... } // JsonDataInfo object
  * }
  */
-interface QueryInlineColumn<T> {
+export interface QueryInlineColumn<T> {
   type: "inlineColumn";
   /** Type specification defining axes and column types */
   spec: T;
@@ -867,7 +874,7 @@ interface QueryInlineColumn<T> {
  *   specOverride: { ... }
  * }
  */
-interface QuerySparseToDenseColumn<C, A, SO> {
+export interface QuerySparseToDenseColumn<C, A, SO> {
   type: "sparseToDenseColumn";
   /** Column reference (ID or full column object depending on context) */
   column: C;
@@ -914,7 +921,7 @@ interface QuerySparseToDenseColumn<C, A, SO> {
  *   entries: [query1Entry, query2Entry]
  * }
  */
-interface QuerySymmetricJoin<JE extends QueryJoinEntry<unknown>> {
+export interface QuerySymmetricJoin<JE extends QueryJoinEntry<unknown>> {
   /** 'innerJoin' for intersection, 'fullJoin' for union with nulls */
   type: "innerJoin" | "fullJoin";
   /** Queries to join (at least one required) */
@@ -933,7 +940,7 @@ interface QuerySymmetricJoin<JE extends QueryJoinEntry<unknown>> {
  * // Wrap a query for use in join
  * { entry: someQuery }
  */
-interface QueryJoinEntry<Q> {
+export interface QueryJoinEntry<Q> {
   /** The query to be joined */
   entry: Q;
 }
@@ -968,7 +975,7 @@ interface QueryJoinEntry<Q> {
  *   secondary: [{ entry: restQuery, ... }]
  * }
  */
-interface QueryLinkerJoin<L, JE extends QueryJoinEntry<unknown>> {
+export interface QueryLinkerJoin<L, JE extends QueryJoinEntry<unknown>> {
   type: "linkerJoin";
   /** Linker side — column reference plus layer-specific integration data. */
   linker: L;
@@ -986,7 +993,7 @@ interface QueryLinkerJoin<L, JE extends QueryJoinEntry<unknown>> {
  * The Rust runtime accepts the legacy `"add"` tag as a serde alias;
  * new code should emit `"append"`.
  */
-type TransformColumnsMode = "append" | "replace";
+export type TransformColumnsMode = "append" | "replace";
 /**
  * Single column entry for {@link QueryTransformColumns}.
  *
@@ -994,7 +1001,7 @@ type TransformColumnsMode = "append" | "replace";
  * @template SO - Spec override type (typically `PColumnIdAndSpec` at
  *   the spec layer, or layer-specific id+typespec at the data layer)
  */
-interface TransformColumnEntry<E, SO> {
+export interface TransformColumnEntry<E, SO> {
   /** Expression computing the column values. */
   expression: E;
   /**
@@ -1014,7 +1021,7 @@ interface TransformColumnEntry<E, SO> {
  * @template E - Expression type
  * @template SO - Spec override type
  */
-interface QueryTransformColumns<Q, E, SO> {
+export interface QueryTransformColumns<Q, E, SO> {
   type: "transformColumns";
   /** Input query. */
   input: Q;
@@ -1039,7 +1046,7 @@ interface QueryTransformColumns<Q, E, SO> {
  * @template Q - Input query type
  * @template SO - Spec override type
  */
-interface QuerySpecOverride<Q, SO> {
+export interface QuerySpecOverride<Q, SO> {
   type: "specOverride";
   /** Input query whose spec is to be overridden. */
   input: Q;
@@ -1047,5 +1054,4 @@ interface QuerySpecOverride<Q, SO> {
   override: SO;
 }
 //#endregion
-export { ColumnTypeSpec, ExprAxisRef, ExprCast, ExprColumnRef, ExprConditional, ExprConditionalCase, ExprConstant, ExprFillNull, ExprIsIn, ExprIsNull, ExprLogicalUnary, ExprLogicalVariadic, ExprNumericBinary, ExprNumericComparison, ExprNumericUnary, ExprRanking, ExprStringContains, ExprStringContainsFuzzy, ExprStringEquals, ExprStringRegex, InferBooleanExpressionUnion, NumericBinaryOperand, NumericComparisonOperand, NumericUnaryOperand, QueryAxisSelector, QueryColumn, QueryColumnSelector, QueryFilter, QueryInlineColumn, QueryJoinEntry, QueryLinkerJoin, QueryOuterJoin, QuerySelector, QuerySliceAxes, QuerySort, QuerySparseToDenseColumn, QuerySpecOverride, QuerySymmetricJoin, QueryTransformColumns, RankingKind, TransformColumnEntry, TransformColumnsMode };
 //# sourceMappingURL=query_common.d.ts.map

package/dist/drivers/pframe/query/query_common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query_common.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_common.ts"],"mappings":"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"}
+{"version":3,"file":"query_common.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_common.ts"],"mappings":"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"}

package/dist/drivers/pframe/query/query_data.d.ts

@@ -1,5 +1,6 @@
 import { ColumnTypeSpec, ExprAxisRef, ExprCast, ExprColumnRef, ExprConditional, ExprConstant, ExprFillNull, ExprIsIn, ExprIsNull, ExprLogicalUnary, ExprLogicalVariadic, ExprNumericBinary, ExprNumericComparison, ExprNumericUnary, ExprRanking, ExprStringContains, ExprStringContainsFuzzy, ExprStringEquals, ExprStringRegex, InferBooleanExpressionUnion, QueryColumn, QueryFilter, QueryInlineColumn, QueryJoinEntry, QueryLinkerJoin, QueryOuterJoin, QuerySliceAxes, QuerySort, QuerySparseToDenseColumn, QuerySymmetricJoin, QueryTransformColumns } from "./query_common.js";
 import { PObjectId } from "../../../pool/spec.js";
+import "../../../pool/index.js";
 //#region src/drivers/pframe/query/query_data.d.ts
 /**
  * Column identifier with type specification.
@@ -8,7 +9,9 @@ import { PObjectId } from "../../../pool/spec.js";
  * 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 */
+  /** Unique identifier of the column */
+  id: PObjectId;
+  /** Type specification defining the axes and the single column value type */
   spec: ColumnTypeSpec;
 };
 /**
@@ -23,20 +26,20 @@ type ColumnIdAndTypeSpec = {
  * // - This entry's axis 1 maps to result axis 2
  * { entry: queryData, axesMapping: [0, 2] }
  */
-interface DataQueryJoinEntry extends QueryJoinEntry<DataQuery> {
+export interface DataQueryJoinEntry extends QueryJoinEntry<DataQuery> {
   /** Maps this entry's axes to the result axes by index */
   axesMapping: number[];
 }
 /** @see QueryColumn */
-type DataQueryColumn = QueryColumn;
+export type DataQueryColumn = QueryColumn;
 /** @see QueryInlineColumn */
-type DataQueryInlineColumn = QueryInlineColumn<ColumnIdAndTypeSpec>;
+export type DataQueryInlineColumn = QueryInlineColumn<ColumnIdAndTypeSpec>;
 /** @see QuerySparseToDenseColumn */
-type DataQuerySparseToDenseColumn = QuerySparseToDenseColumn<PObjectId, number, ColumnIdAndTypeSpec>;
+export type DataQuerySparseToDenseColumn = QuerySparseToDenseColumn<PObjectId, number, ColumnIdAndTypeSpec>;
 /** @see QuerySymmetricJoin */
-type DataQuerySymmetricJoin = QuerySymmetricJoin<DataQueryJoinEntry>;
+export type DataQuerySymmetricJoin = QuerySymmetricJoin<DataQueryJoinEntry>;
 /** @see QueryOuterJoin */
-type DataQueryOuterJoin = QueryOuterJoin<DataQueryJoinEntry>;
+export type DataQueryOuterJoin = QueryOuterJoin<DataQueryJoinEntry>;
 /**
  * Linker side of a data-layer linker-join.
  *
@@ -45,21 +48,24 @@ type DataQueryOuterJoin = QueryOuterJoin<DataQueryJoinEntry>;
  * - `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. */
+export 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>;
+export type DataQueryLinkerJoin = QueryLinkerJoin<DataQueryLinkerJoinLinker, DataQueryJoinEntry>;
 /** @see QuerySliceAxes */
-type DataQuerySliceAxes = QuerySliceAxes<DataQuery, number>;
+export type DataQuerySliceAxes = QuerySliceAxes<DataQuery, number>;
 /** @see QuerySort */
-type DataQuerySort = QuerySort<DataQuery, DataQueryExpression>;
+export type DataQuerySort = QuerySort<DataQuery, DataQueryExpression>;
 /** @see QueryFilter */
-type DataQueryFilter = QueryFilter<DataQuery, DataQueryBooleanExpression>;
+export type DataQueryFilter = QueryFilter<DataQuery, DataQueryBooleanExpression>;
 /** @see QueryTransformColumns */
-type DataQueryTransformColumns = QueryTransformColumns<DataQuery, DataQueryExpression, ColumnIdAndTypeSpec>;
+export type DataQueryTransformColumns = QueryTransformColumns<DataQuery, DataQueryExpression, ColumnIdAndTypeSpec>;
 /**
  * Union of all data layer query types.
  *
@@ -71,13 +77,12 @@ type DataQueryTransformColumns = QueryTransformColumns<DataQuery, DataQueryExpre
  * - Join operations: innerJoin, fullJoin, outerJoin, linkerJoin
  * - Transformations: sliceAxes, sort, filter, transformColumns
  */
-type DataQuery = DataQueryColumn | DataQueryInlineColumn | DataQuerySparseToDenseColumn | DataQuerySymmetricJoin | DataQueryOuterJoin | DataQueryLinkerJoin | DataQuerySliceAxes | DataQuerySort | DataQueryFilter | DataQueryTransformColumns;
+export type DataQuery = DataQueryColumn | DataQueryInlineColumn | DataQuerySparseToDenseColumn | DataQuerySymmetricJoin | DataQueryOuterJoin | DataQueryLinkerJoin | DataQuerySliceAxes | DataQuerySort | DataQueryFilter | DataQueryTransformColumns;
 /** @see ExprAxisRef */
-type DataExprAxisRef = ExprAxisRef<number>;
+export 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>;
+export type DataExprColumnRef = ExprColumnRef<number>;
+export 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>;
+export type DataQueryBooleanExpression = InferBooleanExpressionUnion<DataQueryExpression>;
 //#endregion
-export { DataExprAxisRef, DataExprColumnRef, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryLinkerJoin, DataQueryLinkerJoinLinker, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin, DataQueryTransformColumns };
 //# sourceMappingURL=query_data.d.ts.map

package/dist/drivers/pframe/query/query_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query_data.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_data.ts"],"mappings":";;;;;;AAiCwB;;;KAQnB,mBAAA;EAEH,sCAAA,EAAA,EAAI,SAAA,EAEJ;EAAA,IAAA,EAAM,cAAc;AAAA;AAAA;AAetB;;;;;;;;AAEa;AAIb;;AArBsB,UAeL,kBAAA,SAA2B,cAAc,CAAC,SAAA;EAMlB;EAJvC,WAAA;AAAA;;KAIU,eAAA,GAAkB,WAAW;;KAE7B,qBAAA,GAAwB,iBAAiB,CAAC,mBAAA;AAEtD;AAAA,KAAY,4BAAA,GAA+B,wBAAA,CACzC,SAAA,UAEA,mBAAA;;KAGU,sBAAA,GAAyB,kBAAkB,CAAC,kBAAA;;KAE5C,kBAAA,GAAqB,cAAc,CAAC,kBAAA;;;;;;;AAL3B;AAGrB;KAWY,yBAAA;iCAEV,MAAA,EAAQ,SAAS,EAbuD;EAexE,WAAA,YAb4B;EAe5B,kBAAA;AAAA;AAfgE;AAAA,KAkBtD,mBAAA,GAAsB,eAAA,CAAgB,yBAAA,EAA2B,kBAAA;;KAEjE,kBAAA,GAAqB,cAAc,CAAC,SAAA;;KAEpC,aAAA,GAAgB,SAAA,CAAU,SAAA,EAAW,mBAAA;;KAErC,eAAA,GAAkB,WAAA,CAAY,SAAA,EAAW,0BAAA;;KAEzC,yBAAA,GAA4B,qBAAA,CACtC,SAAA,EACA,mBAAA,EACA,mBAAA;AAdkB;AAGpB;;;;;;;;;;AAHoB,KA4BR,SAAA,GACR,eAAA,GACA,qBAAA,GACA,4BAAA,GACA,sBAAA,GACA,kBAAA,GACA,mBAAA,GACA,kBAAA,GACA,aAAA,GACA,eAAA,GACA,yBAAA;;KAGQ,eAAA,GAAkB,WAAW;AApCzC;AAAA,KAsCY,iBAAA,GAAoB,aAAa;AAAA,KAEjC,mBAAA,GACR,iBAAA,GACA,eAAA,GACA,YAAA,GACA,iBAAA,CAAkB,mBAAA,IAClB,qBAAA,CAAsB,mBAAA,IACtB,gBAAA,CAAiB,mBAAA,IACjB,gBAAA,CAAiB,mBAAA,IACjB,kBAAA,CAAmB,mBAAA,IACnB,eAAA,CAAgB,mBAAA,IAChB,uBAAA,CAAwB,mBAAA,IACxB,UAAA,CAAW,mBAAA,IACX,YAAA,CAAa,mBAAA,IACb,gBAAA,CAAiB,mBAAA,IACjB,mBAAA,CAAoB,mBAAA,IACpB,QAAA,CAAS,mBAAA,YACT,QAAA,CAAS,mBAAA,YAET,QAAA,CAAS,mBAAA,IACT,eAAA,CAAgB,mBAAA,IAEhB,WAAA,CAAY,mBAAA;AAAA,KAGJ,0BAAA,GAA6B,2BAA2B,CAAC,mBAAA"}
+{"version":3,"file":"query_data.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_data.ts"],"mappings":";;;;;;;;;;KAyCK;;EAEH,IAAI;;EAEJ,MAAM;;;;;;;;;;;;;;iBAeS,2BAA2B,eAAe;;EAEzD;;;YAIU,kBAAkB;;YAElB,wBAAwB,kBAAkB;;YAE1C,+BAA+B,yBACzC,mBAEA;;YAGU,yBAAyB,mBAAmB;;YAE5C,qBAAqB,eAAe;;;;;;;;;YASpC;;EAEV,QAAQ;;EAER;;EAEA;;;YAGU,sBAAsB,gBAAgB,2BAA2B;;YAEjE,qBAAqB,eAAe;;YAEpC,gBAAgB,UAAU,WAAW;;YAErC,kBAAkB,YAAY,WAAW;;YAEzC,4BAA4B,sBACtC,WACA,qBACA;;;;;;;;;;;;YAcU,YACR,kBACA,wBACA,+BACA,yBACA,qBACA,sBACA,qBACA,gBACA,kBACA;;YAGQ,kBAAkB;;YAElB,oBAAoB;YAEpB,sBACR,oBACA,kBACA,eACA,kBAAkB,uBAClB,sBAAsB,uBACtB,iBAAiB,uBACjB,iBAAiB,uBACjB,mBAAmB,uBACnB,gBAAgB,uBAChB,wBAAwB,uBACxB,WAAW,uBACX,aAAa,uBACb,iBAAiB,uBACjB,oBAAoB,uBACpB,SAAS,+BACT,SAAS,+BAET,SAAS,uBACT,gBAAgB,uBAEhB,YAAY;YAGJ,6BAA6B,4BAA4B"}

package/dist/drivers/pframe/query/query_spec.d.ts

@@ -1,9 +1,11 @@
 import { Domain, PColumnIdAndSpec } from "../spec/spec.js";
 import { SpecOverrides } from "../spec/overridden.js";
 import { ColumnUniversalId } from "../spec/ids.js";
+import "../spec/index.js";
 import { ExprAxisRef, ExprCast, ExprColumnRef, ExprConditional, ExprConstant, ExprFillNull, ExprIsIn, ExprIsNull, ExprLogicalUnary, ExprLogicalVariadic, ExprNumericBinary, ExprNumericComparison, ExprNumericUnary, ExprRanking, ExprStringContains, ExprStringContainsFuzzy, ExprStringEquals, ExprStringRegex, InferBooleanExpressionUnion, QueryColumn, QueryFilter, QueryInlineColumn, QueryJoinEntry, QueryLinkerJoin, QueryOuterJoin, QuerySliceAxes, QuerySort, QuerySparseToDenseColumn, QuerySpecOverride, QuerySymmetricJoin, QueryTransformColumns } from "./query_common.js";
 import { SingleAxisSelector } from "../spec/selectors.js";
 import { PObjectId } from "../../../pool/spec.js";
+import "../../../pool/index.js";
 //#region src/drivers/pframe/query/query_spec.d.ts
 /**
  * Join entry for spec-layer queries — the base join entry extended with
@@ -15,39 +17,41 @@ import { PObjectId } from "../../../pool/spec.js";
  *   qualifications: [{ axis: { name: 'sample' }, contextDomain: { ... } }]
  * }
  */
-type SpecQueryJoinEntry<C = ColumnUniversalId> = QueryJoinEntry<SpecQuery<C>> & {
+export type SpecQueryJoinEntry<C = ColumnUniversalId> = QueryJoinEntry<SpecQuery<C>> & {
   qualifications?: readonly {
-    /** Axis to qualify. */axis: SingleAxisSelector; /** Additional domain constraints for this axis. */
+    /** Axis to qualify. */
+    axis: SingleAxisSelector;
+    /** Additional domain constraints for this axis. */
     contextDomain: Domain;
   }[];
 };
 /** @see QueryColumn */
-type SpecQueryColumn<C = ColumnUniversalId> = QueryColumn<C>;
+export type SpecQueryColumn<C = ColumnUniversalId> = QueryColumn<C>;
 /** @see QueryInlineColumn */
-type SpecQueryInlineColumn = QueryInlineColumn<PColumnIdAndSpec>;
+export type SpecQueryInlineColumn = QueryInlineColumn<PColumnIdAndSpec>;
 /** @see QuerySparseToDenseColumn */
-type SpecQuerySparseToDenseColumn<C = ColumnUniversalId> = QuerySparseToDenseColumn<C, SingleAxisSelector, PColumnIdAndSpec>;
+export type SpecQuerySparseToDenseColumn<C = ColumnUniversalId> = QuerySparseToDenseColumn<C, SingleAxisSelector, PColumnIdAndSpec>;
 /** @see QuerySymmetricJoin */
-type SpecQuerySymmetricJoin<C = ColumnUniversalId> = QuerySymmetricJoin<SpecQueryJoinEntry<C>>;
+export type SpecQuerySymmetricJoin<C = ColumnUniversalId> = QuerySymmetricJoin<SpecQueryJoinEntry<C>>;
 /** @see QueryOuterJoin */
-type SpecQueryOuterJoin<C = ColumnUniversalId> = QueryOuterJoin<SpecQueryJoinEntry<C>>;
+export type SpecQueryOuterJoin<C = ColumnUniversalId> = QueryOuterJoin<SpecQueryJoinEntry<C>>;
 /** @see QueryLinkerJoin */
-type SpecQueryLinkerJoin<C = ColumnUniversalId> = QueryLinkerJoin<SpecQuery<C>, SpecQueryJoinEntry<C>>;
+export type SpecQueryLinkerJoin<C = ColumnUniversalId> = QueryLinkerJoin<SpecQuery<C>, SpecQueryJoinEntry<C>>;
 /** @see QuerySliceAxes */
-type SpecQuerySliceAxes<C = ColumnUniversalId> = QuerySliceAxes<SpecQuery<C>, SingleAxisSelector>;
+export type SpecQuerySliceAxes<C = ColumnUniversalId> = QuerySliceAxes<SpecQuery<C>, SingleAxisSelector>;
 /** @see QuerySort */
-type SpecQuerySort<C = ColumnUniversalId> = QuerySort<SpecQuery<C>, SpecQueryExpression>;
+export type SpecQuerySort<C = ColumnUniversalId> = QuerySort<SpecQuery<C>, SpecQueryExpression>;
 /** @see QueryFilter */
-type SpecQueryFilter<C = ColumnUniversalId> = QueryFilter<SpecQuery<C>, SpecQueryBooleanExpression>;
+export type SpecQueryFilter<C = ColumnUniversalId> = QueryFilter<SpecQuery<C>, SpecQueryBooleanExpression>;
 /** @see QueryTransformColumns */
-type SpecQueryTransformColumns<C = ColumnUniversalId> = QueryTransformColumns<SpecQuery<C>, SpecQueryExpression, PColumnIdAndSpec>;
+export type SpecQueryTransformColumns<C = ColumnUniversalId> = QueryTransformColumns<SpecQuery<C>, SpecQueryExpression, PColumnIdAndSpec>;
 /**
  * Client-side spec-override node — collapsed at the host boundary, never
  * sent to pframe-engine.
  *
  * @see QuerySpecOverride
  */
-type SpecQuerySpecOverride<C = ColumnUniversalId> = QuerySpecOverride<SpecQuery<C>, SpecOverrides>;
+export type SpecQuerySpecOverride<C = ColumnUniversalId> = QuerySpecOverride<SpecQuery<C>, SpecOverrides>;
 /**
  * Union of all spec layer query types.
  *
@@ -64,13 +68,12 @@ type SpecQuerySpecOverride<C = ColumnUniversalId> = QuerySpecOverride<SpecQuery<
  * - Transformations: sliceAxes, sort, filter, transformColumns
  * - Client-side overlays: specOverride (collapsed before reaching the engine)
  */
-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>;
+export 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>;
+export 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>;
+export type SpecExprColumnRef = ExprColumnRef<ColumnUniversalId>;
+export 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>;
+export type SpecQueryBooleanExpression = InferBooleanExpressionUnion<SpecQueryExpression>;
 //#endregion
-export { SpecExprAxisRef, SpecExprColumnRef, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryLinkerJoin, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySpecOverride, SpecQuerySymmetricJoin, SpecQueryTransformColumns };
 //# sourceMappingURL=query_spec.d.ts.map

package/dist/drivers/pframe/query/query_spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query_spec.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_spec.ts"],"mappings":";;;;;;;;;;;;AAgDA;;;;;KAAY,kBAAA,KAAuB,iBAAA,IAAqB,cAAA,CAAe,SAAA,CAAU,CAAA;EAC/E,cAAA;IAEQ,uBAAN,IAAA,EAAM,kBAAA,EAEe;IAArB,aAAA,EAAe,MAAA;EAAA;AAAA;;KAKP,eAAA,KAAoB,iBAAA,IAAqB,WAAA,CAAY,CAAA;;KAErD,qBAAA,GAAwB,iBAAiB,CAAC,gBAAA;;KAE1C,4BAAA,KAAiC,iBAAA,IAAqB,wBAAA,CAChE,CAAA,EACA,kBAAA,EACA,gBAAA;;KAGU,sBAAA,KAA2B,iBAAA,IAAqB,kBAAA,CAC1D,kBAAA,CAAmB,CAAA;;KAGT,kBAAA,KAAuB,iBAAA,IAAqB,cAAA,CAAe,kBAAA,CAAmB,CAAA;AAd1F;AAAA,KAgBY,mBAAA,KAAwB,iBAAA,IAAqB,eAAA,CACvD,SAAA,CAAU,CAAA,GACV,kBAAA,CAAmB,CAAA;;KAGT,kBAAA,KAAuB,iBAAA,IAAqB,cAAA,CACtD,SAAA,CAAU,CAAA,GACV,kBAAA;;KAGU,aAAA,KAAkB,iBAAA,IAAqB,SAAA,CAAU,SAAA,CAAU,CAAA,GAAI,mBAAA;;KAE/D,eAAA,KAAoB,iBAAA,IAAqB,WAAA,CACnD,SAAA,CAAU,CAAA,GACV,0BAAA;;KAGU,yBAAA,KAA8B,iBAAA,IAAqB,qBAAA,CAC7D,SAAA,CAAU,CAAA,GACV,mBAAA,EACA,gBAAA;;;;AApCgE;AAElE;;KA0CY,qBAAA,KAA0B,iBAAA,IAAqB,iBAAA,CACzD,SAAA,CAAU,CAAA,GACV,aAAA;;AA5CoE;AAEtE;;;;;;;;;;;;;;KA6DY,SAAA,KAAc,iBAAA,IACtB,eAAA,CAAgB,CAAA,IAChB,qBAAA,GACA,4BAAA,CAA6B,CAAA,IAC7B,sBAAA,CAAuB,CAAA,IACvB,kBAAA,CAAmB,CAAA,IACnB,mBAAA,CAAoB,CAAA,IACpB,kBAAA,CAAmB,CAAA,IACnB,aAAA,CAAc,CAAA,IACd,eAAA,CAAgB,CAAA,IAChB,yBAAA,CAA0B,CAAA,IAC1B,qBAAA,CAAsB,CAAA;;KAGd,eAAA,GAAkB,WAAW,CAAC,kBAAA;AAxExB;AAAA,KA0EN,iBAAA,GAAoB,aAAa,CAAC,iBAAA;AAAA,KAElC,mBAAA,GACR,iBAAA,GACA,eAAA,GACA,YAAA,GACA,iBAAA,CAAkB,mBAAA,IAClB,qBAAA,CAAsB,mBAAA,IACtB,gBAAA,CAAiB,mBAAA,IACjB,gBAAA,CAAiB,mBAAA,IACjB,kBAAA,CAAmB,mBAAA,IACnB,eAAA,CAAgB,mBAAA,IAChB,uBAAA,CAAwB,mBAAA,IACxB,UAAA,CAAW,mBAAA,IACX,YAAA,CAAa,mBAAA,IACb,gBAAA,CAAiB,mBAAA,IACjB,mBAAA,CAAoB,mBAAA,IACpB,QAAA,CAAS,mBAAA,YACT,QAAA,CAAS,mBAAA,YAET,QAAA,CAAS,mBAAA,IACT,eAAA,CAAgB,mBAAA,IAEhB,WAAA,CAAY,mBAAA,EAAqB,kBAAA,EAAoB,SAAA;AAAA,KAG7C,0BAAA,GAA6B,2BAA2B,CAAC,mBAAA"}
+{"version":3,"file":"query_spec.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/query_spec.ts"],"mappings":";;;;;;;;;;;;;;;;;;;YAgDY,mBAAmB,IAAI,qBAAqB,eAAe,UAAU;EAC/E;;IAEE,MAAM;;IAEN,eAAe;;;;YAKP,gBAAgB,IAAI,qBAAqB,YAAY;;YAErD,wBAAwB,kBAAkB;;YAE1C,6BAA6B,IAAI,qBAAqB,yBAChE,GACA,oBACA;;YAGU,uBAAuB,IAAI,qBAAqB,mBAC1D,mBAAmB;;YAGT,mBAAmB,IAAI,qBAAqB,eAAe,mBAAmB;;YAE9E,oBAAoB,IAAI,qBAAqB,gBACvD,UAAU,IACV,mBAAmB;;YAGT,mBAAmB,IAAI,qBAAqB,eACtD,UAAU,IACV;;YAGU,cAAc,IAAI,qBAAqB,UAAU,UAAU,IAAI;;YAE/D,gBAAgB,IAAI,qBAAqB,YACnD,UAAU,IACV;;YAGU,0BAA0B,IAAI,qBAAqB,sBAC7D,UAAU,IACV,qBACA;;;;;;;YAQU,sBAAsB,IAAI,qBAAqB,kBACzD,UAAU,IACV;;;;;;;;;;;;;;;;;YAmBU,UAAU,IAAI,qBACtB,gBAAgB,KAChB,wBACA,6BAA6B,KAC7B,uBAAuB,KACvB,mBAAmB,KACnB,oBAAoB,KACpB,mBAAmB,KACnB,cAAc,KACd,gBAAgB,KAChB,0BAA0B,KAC1B,sBAAsB;;YAGd,kBAAkB,YAAY;;YAE9B,oBAAoB,cAAc;YAElC,sBACR,oBACA,kBACA,eACA,kBAAkB,uBAClB,sBAAsB,uBACtB,iBAAiB,uBACjB,iBAAiB,uBACjB,mBAAmB,uBACnB,gBAAgB,uBAChB,wBAAwB,uBACxB,WAAW,uBACX,aAAa,uBACb,iBAAiB,uBACjB,oBAAoB,uBACpB,SAAS,+BACT,SAAS,+BAET,SAAS,uBACT,gBAAgB,uBAEhB,YAAY,qBAAqB,oBAAoB;YAG7C,6BAA6B,4BAA4B"}