@milaboratories/pl-model-common 1.47.3 → 1.49.0

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"}

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

@@ -1,7 +1,6 @@
 import { SpecQuery, SpecQueryBooleanExpression, SpecQueryExpression, SpecQueryJoinEntry } from "./query_spec.js";
-
 //#region src/drivers/pframe/query/utils.d.ts
-declare function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression;
+export declare function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression;
 /**
  * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.
  *
@@ -12,20 +11,25 @@ declare function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQue
  * 4. Assemble node with transformed children
  * 5. Apply `node` to the assembled node
  */
-declare function traverseQuerySpec<C1, C2>(query: SpecQuery<C1>, visitor: {
-  /** Transform column references in leaf nodes (column, sparseToDenseColumn). */column: (c: C1) => C2; /** Visit a node after its children have been traversed. */
-  node?: (node: SpecQuery<C2>) => SpecQuery<C2>; /** Visit a join entry after its inner query has been traversed. */
+export declare function traverseQuerySpec<C1, C2>(query: SpecQuery<C1>, visitor: {
+  /** Transform column references in leaf nodes (column, sparseToDenseColumn). */
+  column: (c: C1) => C2;
+  /** Visit a node after its children have been traversed. */
+  node?: (node: SpecQuery<C2>) => SpecQuery<C2>;
+  /** Visit a join entry after its inner query has been traversed. */
   joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;
 }): SpecQuery<C2>;
 /** Recursively maps all column references in a SpecQuery tree. */
-declare function mapSpecQueryColumns<C1, C2>(query: SpecQuery<C1>, visitor: {
-  /** Transform column references in leaf nodes (column, sparseToDenseColumn). */column: (c: C1) => C2; /** Visit a node after its children have been traversed. */
-  node?: (node: SpecQuery<C2>) => SpecQuery<C2>; /** Visit a join entry after its inner query has been traversed. */
+export declare function mapSpecQueryColumns<C1, C2>(query: SpecQuery<C1>, visitor: {
+  /** Transform column references in leaf nodes (column, sparseToDenseColumn). */
+  column: (c: C1) => C2;
+  /** Visit a node after its children have been traversed. */
+  node?: (node: SpecQuery<C2>) => SpecQuery<C2>;
+  /** Visit a join entry after its inner query has been traversed. */
   joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;
 }): SpecQuery<C2>;
 /** Collects all column references from a SpecQuery tree. */
-declare function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[];
-declare function sortSpecQuery(query: SpecQuery): SpecQuery;
+export declare function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[];
+export declare function sortSpecQuery(query: SpecQuery): SpecQuery;
 //#endregion
-export { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sortSpecQuery, traverseQuerySpec };
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"mappings":";;;iBAuBgB,mBAAA,CAAoB,IAAA,EAAM,mBAAA,GAAsB,IAAA,IAAQ,0BAA0B;;AAAlG;;;;;;;;;iBAiBgB,iBAAA,SACd,KAAA,EAAO,SAAA,CAAU,EAAA,GACjB,OAAA;EAFc,+EAIZ,MAAA,GAAS,CAAA,EAAG,EAAA,KAAO,EAAA,EAJU;EAM7B,IAAA,IAAQ,IAAA,EAAM,SAAA,CAAU,EAAA,MAAQ,SAAA,CAAU,EAAA,GALrC;EAOL,SAAA,IAAa,KAAA,EAAO,kBAAA,CAAmB,EAAA,MAAQ,kBAAA,CAAmB,EAAA;AAAA,IAEnE,SAAA,CAAU,EAAA;;iBA4DG,mBAAA,SACd,KAAA,EAAO,SAAA,CAAU,EAAA,GACjB,OAAA;EAlE4C,+EAoE1C,MAAA,GAAS,CAAA,EAAG,EAAA,KAAO,EAAA,EAlEoB;EAoEvC,IAAA,IAAQ,IAAA,EAAM,SAAA,CAAU,EAAA,MAAQ,SAAA,CAAU,EAAA,GApEwB;EAsElE,SAAA,IAAa,KAAA,EAAO,kBAAA,CAAmB,EAAA,MAAQ,kBAAA,CAAmB,EAAA;AAAA,IAEnE,SAAA,CAAU,EAAA;;iBAKG,uBAAA,IAA2B,KAAA,EAAO,SAAA,CAAU,CAAA,IAAK,CAAA;AAAA,iBAWjD,aAAA,CAAc,KAAA,EAAO,SAAA,GAAY,SAAS"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"mappings":";;wBAuBgB,oBAAoB,MAAM,sBAAsB,QAAQ;;;;;;;;;;;wBAiBxD,kBAAkB,IAAI,IACpC,OAAO,UAAU,KACjB;;EAEE,SAAS,GAAG,OAAO;;EAEnB,QAAQ,MAAM,UAAU,QAAQ,UAAU;;EAE1C,aAAa,OAAO,mBAAmB,QAAQ,mBAAmB;IAEnE,UAAU;;wBA4DG,oBAAoB,IAAI,IACtC,OAAO,UAAU,KACjB;;EAEE,SAAS,GAAG,OAAO;;EAEnB,QAAQ,MAAM,UAAU,QAAQ,UAAU;;EAE1C,aAAa,OAAO,mBAAmB,QAAQ,mBAAmB;IAEnE,UAAU;;wBAKG,wBAAwB,GAAG,OAAO,UAAU,KAAK;wBAWjD,cAAc,OAAO,YAAY"}

package/dist/drivers/pframe/spec/anchored.d.ts

@@ -2,13 +2,12 @@ import { PColumnSpec } from "./spec.js";
 import { SUniversalPColumnId, UniversalPColumnId } from "./ids.js";
 import { AxisFilter } from "./filtered_column.js";
 import { AnchoredPColumnId, AnchoredPColumnSelector, PColumnSelector } from "./selectors.js";
-
 //#region src/drivers/pframe/spec/anchored.d.ts
 /**
  * Context for resolving and generating anchored references to columns and axes
  * Maintains maps of known domain values and axes that can be referenced by anchors
  */
-declare class AnchoredIdDeriver {
+export declare class AnchoredIdDeriver {
   readonly anchors: Record<string, Pick<PColumnSpec, "axesSpec" | "domain" | "contextDomain">>;
   private readonly axes;
   private readonly domains;
@@ -53,7 +52,7 @@ declare class AnchoredIdDeriver {
 /**
  * Options for the resolveAnchors function
  */
-type ResolveAnchorsOptions = {
+export type ResolveAnchorsOptions = {
   /**
    * If true, missing domain keys in anchors will be ignored.
    * If false (default), an error will be thrown.
@@ -70,7 +69,6 @@ type ResolveAnchorsOptions = {
  * @returns A non-anchored column matcher with all references resolved to actual values
  * @deprecated - This function by parent PColumnCollection
  */
-declare function resolveAnchors(anchors: Record<string, Pick<PColumnSpec, "axesSpec" | "domain" | "contextDomain">>, matcher: AnchoredPColumnSelector, options?: ResolveAnchorsOptions): PColumnSelector;
+export declare function resolveAnchors(anchors: Record<string, Pick<PColumnSpec, "axesSpec" | "domain" | "contextDomain">>, matcher: AnchoredPColumnSelector, options?: ResolveAnchorsOptions): PColumnSelector;
 //#endregion
-export { AnchoredIdDeriver, ResolveAnchorsOptions, resolveAnchors };
 //# sourceMappingURL=anchored.d.ts.map

package/dist/drivers/pframe/spec/anchored.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anchored.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/anchored.ts"],"mappings":";;;;;;;;AAgCA;;cAAa,iBAAA;EAAA,SAqBO,OAAA,EAAS,MAAA,SAEvB,IAAA,CAAK,WAAA;EAAA,iBAtBQ,IAAA;EAAA,iBACA,OAAA;EAAA,iBACA,cAAA;EAoBb;;;;EAAA,iBAfa,WAAA;EAAA,iBACA,kBAAA;EAiEsC;;;EAAA,iBA7DtC,kBAAA;EAAA,iBACA,yBAAA;EAgL0D;;;;cAzKzD,OAAA,EAAS,MAAA,SAEvB,IAAA,CAAK,WAAA;EAtBQ;;;;;EAiEjB,MAAA,CAAO,IAAA,EAAM,WAAA,GAAc,iBAAA;EApDV;;;;;;EA4DjB,MAAA,CAAO,IAAA,EAAM,WAAA,EAAa,WAAA,GAAc,UAAA,KAAe,kBAAA;EAR1C;;;;;;EA4Hb,OAAA,CAAQ,IAAA,EAAM,WAAA,EAAa,WAAA,GAAc,UAAA,KAAe,mBAAA;AAAA;;;;KAQ9C,qBAAA;EAR+B;;;;EAazC,oBAAoB;AAAA;;;;AAAA;AAatB;;;;;;iBAAgB,cAAA,CACd,OAAA,EAAS,MAAA,SAAe,IAAA,CAAK,WAAA,6CAC7B,OAAA,EAAS,uBAAA,EACT,OAAA,GAAU,qBAAA,GACT,eAAA"}
+{"version":3,"file":"anchored.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/anchored.ts"],"mappings":";;;;;;;;;qBAgCa;WAqBO,SAAS,eAEvB,KAAK;mBAtBQ;mBACA;mBACA;;;;;mBAKA;mBACA;;;;mBAIA;mBACA;;;;;EAMjB,YACkB,SAAS,eAEvB,KAAK;;;;;;EA2CT,OAAO,MAAM,cAAc;;;;;;;EAQ3B,OAAO,MAAM,aAAa,cAAc,eAAe;;;;;;;EAoHvD,QAAQ,MAAM,aAAa,cAAc,eAAe;;;;;YAQ9C;;;;;EAKV;;;;;;;;;;;;wBAac,eACd,SAAS,eAAe,KAAK,wDAC7B,SAAS,yBACT,UAAU,wBACT"}

package/dist/drivers/pframe/spec/discovered_column.d.ts

@@ -2,38 +2,37 @@ import { CanonicalizedJson } from "../../../json.js";
 import { ColumnUniversalId } from "./ids.js";
 import { AxisQualification } from "./selectors.js";
 import { PObjectId } from "../../../pool/spec.js";
+import "../../../pool/index.js";
 import { Branded } from "@milaboratories/helpers";
-
 //#region src/drivers/pframe/spec/discovered_column.d.ts
-interface ColumnDiscoveredKey {
+export interface ColumnDiscoveredKey {
   __isDiscovered: true;
   column: ColumnUniversalId;
   path?: PathItem[];
   columnQualifications?: AxisQualification[];
   queriesQualifications?: Record<PObjectId, AxisQualification[]>;
 }
-type ColumnDiscoveredId = Branded<CanonicalizedJson<ColumnDiscoveredKey>, "ColumnDiscoveredId">;
+export type ColumnDiscoveredId = Branded<CanonicalizedJson<ColumnDiscoveredKey>, "ColumnDiscoveredId">;
 type PathItem = {
   type: "linker";
   column: ColumnUniversalId;
 };
-declare function isColumnDiscoveredKey(obj: unknown): obj is ColumnDiscoveredKey;
-declare function isColumnDiscoveredId(str: unknown): str is ColumnDiscoveredId;
-declare function distillColumnDiscoveredKey(props: ColumnDiscoveredKey): ColumnDiscoveredKey;
-declare function createColumnDiscoveredId(props: {
+export declare function isColumnDiscoveredKey(obj: unknown): obj is ColumnDiscoveredKey;
+export declare function isColumnDiscoveredId(str: unknown): str is ColumnDiscoveredId;
+export declare function distillColumnDiscoveredKey(props: ColumnDiscoveredKey): ColumnDiscoveredKey;
+export declare function createColumnDiscoveredId(props: {
   column: ColumnUniversalId;
   path?: PathItem[];
   columnQualifications?: AxisQualification[];
   queriesQualifications?: Record<PObjectId, AxisQualification[]>;
 }): ColumnDiscoveredId;
-declare function createColumnDiscoveredKey(props: {
+export declare function createColumnDiscoveredKey(props: {
   column: ColumnUniversalId;
   path?: PathItem[];
   columnQualifications?: AxisQualification[];
   queriesQualifications?: Record<PObjectId, AxisQualification[]>;
 }): ColumnDiscoveredKey;
-declare function parseColumnDiscoveredId(id: ColumnDiscoveredId): ColumnDiscoveredKey;
-declare function stringifyColumnDiscoveredId(id: Omit<ColumnDiscoveredKey, "__isDiscovered">): ColumnDiscoveredId;
+export declare function parseColumnDiscoveredId(id: ColumnDiscoveredId): ColumnDiscoveredKey;
+export declare function stringifyColumnDiscoveredId(id: Omit<ColumnDiscoveredKey, "__isDiscovered">): ColumnDiscoveredId;
 //#endregion
-export { ColumnDiscoveredId, ColumnDiscoveredKey, createColumnDiscoveredId, createColumnDiscoveredKey, distillColumnDiscoveredKey, isColumnDiscoveredId, isColumnDiscoveredKey, parseColumnDiscoveredId, stringifyColumnDiscoveredId };
 //# sourceMappingURL=discovered_column.d.ts.map

package/dist/drivers/pframe/spec/discovered_column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovered_column.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"mappings":";;;;;;;UAMiB,mBAAA;EACf,cAAA;EACA,MAAA,EAAQ,iBAAA;EACR,IAAA,GAAO,QAAA;EACP,oBAAA,GAAuB,iBAAA;EACvB,qBAAA,GAAwB,MAAA,CAAO,SAAA,EAAW,iBAAA;AAAA;AAAA,KAGhC,kBAAA,GAAqB,OAAA,CAC/B,iBAAA,CAAkB,mBAAA;AAAA,KAIf,QAAA;EACH,IAAA;EACA,MAAA,EAAQ,iBAAiB;AAAA;AAAA,iBAGX,qBAAA,CAAsB,GAAA,YAAe,GAAA,IAAO,mBAAmB;AAAA,iBAI/D,oBAAA,CAAqB,GAAA,YAAe,GAAA,IAAO,kBAAkB;AAAA,iBAK7D,0BAAA,CAA2B,KAAA,EAAO,mBAAA,GAAsB,mBAAmB;AAAA,iBAgB3E,wBAAA,CAAyB,KAAA;EACvC,MAAA,EAAQ,iBAAA;EACR,IAAA,GAAO,QAAA;EACP,oBAAA,GAAuB,iBAAA;EACvB,qBAAA,GAAwB,MAAA,CAAO,SAAA,EAAW,iBAAA;AAAA,IACxC,kBAAA;AAAA,iBAIY,yBAAA,CAA0B,KAAA;EACxC,MAAA,EAAQ,iBAAA;EACR,IAAA,GAAO,QAAA;EACP,oBAAA,GAAuB,iBAAA;EACvB,qBAAA,GAAwB,MAAA,CAAO,SAAA,EAAW,iBAAA;AAAA,IACxC,mBAAA;AAAA,iBAIY,uBAAA,CAAwB,EAAA,EAAI,kBAAA,GAAqB,mBAAmB;AAAA,iBAapE,2BAAA,CACd,EAAA,EAAI,IAAA,CAAK,mBAAA,sBACR,kBAAA"}
+{"version":3,"file":"discovered_column.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"mappings":";;;;;;;iBAMiB;EACf;EACA,QAAQ;EACR,OAAO;EACP,uBAAuB;EACvB,wBAAwB,OAAO,WAAW;;YAGhC,qBAAqB,QAC/B,kBAAkB;KAIf;EACH;EACA,QAAQ;;wBAGM,sBAAsB,eAAe,OAAO;wBAI5C,qBAAqB,eAAe,OAAO;wBAK3C,2BAA2B,OAAO,sBAAsB;wBAgBxD,yBAAyB;EACvC,QAAQ;EACR,OAAO;EACP,uBAAuB;EACvB,wBAAwB,OAAO,WAAW;IACxC;wBAIY,0BAA0B;EACxC,QAAQ;EACR,OAAO;EACP,uBAAuB;EACvB,wBAAwB,OAAO,WAAW;IACxC;wBAIY,wBAAwB,IAAI,qBAAqB;wBAajD,4BACd,IAAI,KAAK,yCACR"}

package/dist/drivers/pframe/spec/filtered_column.d.ts

@@ -3,22 +3,22 @@ import { PColumnSpec } from "./spec.js";
 import { ColumnUniversalId } from "./ids.js";
 import { AnchoredPColumnId } from "./selectors.js";
 import { Branded } from "@milaboratories/helpers";
-
 //#region src/drivers/pframe/spec/filtered_column.d.ts
 /** Value of an axis filter */
-type AxisFilterValue = number | string;
+export type AxisFilterValue = number | string;
 /** Axis filter by index */
-type AxisFilterByIdx = [number, AxisFilterValue];
+export type AxisFilterByIdx = [number, AxisFilterValue];
 /** Axis filter by name */
-type AxisFilterByName = [string, AxisFilterValue];
+export type AxisFilterByName = [string, AxisFilterValue];
 /** Axis filter */
-type AxisFilter = AxisFilterByIdx | AxisFilterByName;
+export type AxisFilter = AxisFilterByIdx | AxisFilterByName;
 /**
  * Identifies a column derived from a CanonicalPColumnId by fixing values on certain axes,
  * thus effectively reducing the dimensionality of the original column.
  */
-type FilteredPColumn<CID = AnchoredPColumnId, AFI = AxisFilter> = {
-  /** The original column identifier */source: CID;
+export type FilteredPColumn<CID = AnchoredPColumnId, AFI = AxisFilter> = {
+  /** The original column identifier */
+  source: CID;
   /**
    * List of fixed axes and their corresponding values.
    * Each entry fixes one axis to a specific value, creating a slice of the multidimensional data.
@@ -28,33 +28,33 @@ type FilteredPColumn<CID = AnchoredPColumnId, AFI = AxisFilter> = {
   axisFilters: AFI[];
 };
 /** @deprecated */
-type FilteredPColumnId = FilteredPColumn<AnchoredPColumnId, AxisFilterByIdx>;
+export type FilteredPColumnId = FilteredPColumn<AnchoredPColumnId, AxisFilterByIdx>;
 /**
  * Checks if a given value is a FilteredPColumn
  * @param id - The value to check
  * @returns True if the value is a FilteredPColumn, false otherwise
  * @deprecated use {@link isColumnFilteredKey} for the key form and `source` checks for the id form
  */
-declare function isFilteredPColumn(id: unknown): id is FilteredPColumn;
+export declare function isFilteredPColumn(id: unknown): id is FilteredPColumn;
 /**
  * `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 {
+export interface ColumnFilteredKey {
   __isFiltered: true;
   source: ColumnUniversalId;
   axisFilters: AxisFilterByIdx[];
 }
-type ColumnFilteredId = Branded<CanonicalizedJson<ColumnFilteredKey>, "ColumnFilteredId">;
-declare function stringifyColumnFilteredId(key: Omit<ColumnFilteredKey, "__isFiltered">): ColumnFilteredId;
-declare function isColumnFilteredKey(obj: unknown): obj is ColumnFilteredKey;
-declare function isColumnFilteredId(id: unknown): id is ColumnFilteredId;
-declare function createColumnFilteredId(props: {
+export type ColumnFilteredId = Branded<CanonicalizedJson<ColumnFilteredKey>, "ColumnFilteredId">;
+export declare function stringifyColumnFilteredId(key: Omit<ColumnFilteredKey, "__isFiltered">): ColumnFilteredId;
+export declare function isColumnFilteredKey(obj: unknown): obj is ColumnFilteredKey;
+export declare function isColumnFilteredId(id: unknown): id is ColumnFilteredId;
+export declare function createColumnFilteredId(props: {
   source: ColumnUniversalId;
   axisFilters: AxisFilterByIdx[];
 }): ColumnFilteredId;
-declare function createColumnFilteredKey(props: {
+export declare function createColumnFilteredKey(props: {
   source: ColumnUniversalId;
   axisFilters: AxisFilterByIdx[];
 }): ColumnFilteredKey;
@@ -67,7 +67,6 @@ declare function createColumnFilteredKey(props: {
  * `reconstructSpecFromId` (host, id-walking) and `ColumnFilteredRecipe.getSpec`
  * (sandbox, recipe-graph walking).
  */
-declare function applyAxisFilters(spec: PColumnSpec, axisFilters: AxisFilterByIdx[]): PColumnSpec;
+export declare function applyAxisFilters(spec: PColumnSpec, axisFilters: AxisFilterByIdx[]): PColumnSpec;
 //#endregion
-export { AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, ColumnFilteredId, ColumnFilteredKey, FilteredPColumn, FilteredPColumnId, applyAxisFilters, createColumnFilteredId, createColumnFilteredKey, isColumnFilteredId, isColumnFilteredKey, isFilteredPColumn, stringifyColumnFilteredId };
 //# sourceMappingURL=filtered_column.d.ts.map

package/dist/drivers/pframe/spec/filtered_column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filtered_column.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/filtered_column.ts"],"mappings":";;;;;;;;KAOY,eAAA;AAAZ;AAAA,KAGY,eAAA,YAA2B,eAAe;;KAG1C,gBAAA,YAA4B,eAAe;AAN5B;AAAA,KASf,UAAA,GAAa,eAAA,GAAkB,gBAAgB;;;;AANL;KAY1C,eAAA,OAAsB,iBAAA,QAAyB,UAAA;EAT/B,qCAW1B,MAAA,EAAQ,GAAA;EAX6C;AAAA;AAGvD;;;;EAgBE,WAAA,EAAa,GAAA;AAAA;;KAIH,iBAAA,GAAoB,eAAA,CAAgB,iBAAA,EAAmB,eAAA;;;;;;;iBAQnD,iBAAA,CAAkB,EAAA,YAAc,EAAA,IAAM,eAAe;;;;;;UASpD,iBAAA;EACf,YAAA;EACA,MAAA,EAAQ,iBAAA;EACR,WAAA,EAAa,eAAe;AAAA;AAAA,KAGlB,gBAAA,GAAmB,OAAA,CAAQ,iBAAA,CAAkB,iBAAA;AAAA,iBAEzC,yBAAA,CACd,GAAA,EAAK,IAAA,CAAK,iBAAA,oBACT,gBAAA;AAAA,iBAIa,mBAAA,CAAoB,GAAA,YAAe,GAAA,IAAO,iBAAiB;AAAA,iBAI3D,kBAAA,CAAmB,EAAA,YAAc,EAAA,IAAM,gBAAgB;AAAA,iBAKvD,sBAAA,CAAuB,KAAA;EACrC,MAAA,EAAQ,iBAAA;EACR,WAAA,EAAa,eAAA;AAAA,IACX,gBAAA;AAAA,iBAIY,uBAAA,CAAwB,KAAA;EACtC,MAAA,EAAQ,iBAAA;EACR,WAAA,EAAa,eAAA;AAAA,IACX,iBAAA;AA1CJ;;;;;;;;AAAqE;AAArE,iBA0DgB,gBAAA,CAAiB,IAAA,EAAM,WAAA,EAAa,WAAA,EAAa,eAAA,KAAoB,WAAA"}
+{"version":3,"file":"filtered_column.d.ts","names":[],"sources":["../../../../src/drivers/pframe/spec/filtered_column.ts"],"mappings":";;;;;;;YAOY;;YAGA,2BAA2B;;YAG3B,4BAA4B;;YAG5B,aAAa,kBAAkB;;;;;YAM/B,gBAAgB,MAAM,mBAAmB,MAAM;;EAEzD,QAAQ;;;;;;;EAQR,aAAa;;;YAIH,oBAAoB,gBAAgB,mBAAmB;;;;;;;wBAQnD,kBAAkB,cAAc,MAAM;;;;;;iBASrC;EACf;EACA,QAAQ;EACR,aAAa;;YAGH,mBAAmB,QAAQ,kBAAkB;wBAEzC,0BACd,KAAK,KAAK,qCACT;wBAIa,oBAAoB,eAAe,OAAO;wBAI1C,mBAAmB,cAAc,MAAM;wBAKvC,uBAAuB;EACrC,QAAQ;EACR,aAAa;IACX;wBAIY,wBAAwB;EACtC,QAAQ;EACR,aAAa;IACX;;;;;;;;;;wBAgBY,iBAAiB,MAAM,aAAa,aAAa,oBAAoB"}

package/dist/drivers/pframe/spec/ids.cjs

@@ -28,6 +28,153 @@ function parseColumnIdSafely(str, fallback = void 0) {
 		return fallback;
 	}
 }
+/** Whether `value` is any of the five key forms a {@link ColumnUniversalId} serializes. */
+function isColumnUniversalKey(value) {
+	return require_spec.isPObjectKey(value) || require_filtered_column.isColumnFilteredKey(value) || require_discovered_column.isColumnDiscoveredKey(value) || require_overridden.isColumnOverriddenKey(value);
+}
+function isColumnUniversalId(value) {
+	const key = (0, es_toolkit.isString)(value) ? require_json.parseJsonSafely(value, false) : false;
+	return key === false ? false : isColumnUniversalKey(key);
+}
+/**
+* Take a value out of however many `JSON.stringify` passes wrapped it, or `undefined`
+* when `s` is not JSON at all.
+*
+* The one definition of "how a value can be hiding inside a string" — a block id can sit
+* under several layers of escaping, and a walk over object properties reaches none of
+* them. Callers differ in what they do at the bottom (this deliberately says nothing
+* about which values count as identifiers), but they must agree on the mechanics, or
+* "what carries a block id" ends up with two answers that drift.
+*
+* The gate is cheap and does NOT require any marker in the body: a filtered id whose
+* innermost leaf is a {@link LocalPObjectKey} carries no `__isRef`, so demanding one
+* would miss it.
+*/
+function peelJsonLayers(s) {
+	let current = s;
+	let layers = 0;
+	for (;;) {
+		const c0 = current.charCodeAt(0);
+		if (c0 !== 123 && c0 !== 34) return void 0;
+		let parsed;
+		try {
+			parsed = JSON.parse(current);
+		} catch {
+			return;
+		}
+		if ((0, es_toolkit.isString)(parsed)) {
+			if (parsed.length >= current.length) return void 0;
+			current = parsed;
+			layers++;
+			continue;
+		}
+		return {
+			value: parsed,
+			layers
+		};
+	}
+}
+/**
+* Rewrite every block id buried inside a column id.
+*
+* A {@link GlobalPObjectKey} leaf names its upstream by block id, and the wrapper key forms
+* nest by *string* id rather than by object — so a block id can sit under several layers of
+* JSON escaping, and `queriesQualifications` carries one in a map *key*. A caller that only
+* walks object properties never reaches any of them, which is why moving a column id between
+* projects needs this rather than a generic walk.
+*
+* Recursion re-canonicalizes bottom-up, so every level is canonical afterwards — including
+* the rebuilt `queriesQualifications`, whose keys the canonical form sorts. That is the
+* property a textual rewrite cannot have: redirecting an id that is a map key changes what
+* the sorted order should be, and only rebuilding restores it.
+*
+* Returns the input itself when no block id changed, so a caller mapping ids to themselves
+* gets its value back byte-for-byte and never re-serializes a stored id. Any `string` is
+* accepted for the same reason: a caller sweeping a params object cannot know which of its
+* strings are ids, and one that is not is returned as-is.
+*
+* @param remapBlockId old block id → new block id. Throw from it to reject an id that cannot
+*   be mapped.
+*/
+function remapColumnIdBlockIds(id, remapBlockId) {
+	return ((0, es_toolkit.isString)(id) ? remapIdString(id, remapBlockId) : remapKey(id, remapBlockId)) ?? id;
+}
+/**
+* The string half of {@link remapColumnIdBlockIds}. `undefined` means "nothing to change",
+* which is what keeps an unaffected id from being re-serialized.
+*
+* Escape padding is peeled and put back, so an id that reached params through an extra
+* `JSON.stringify` is rewritten in place and comes back wrapped as it was found. A string
+* that does not peel to a column key is left alone: params hold ordinary strings too.
+*/
+function remapIdString(id, remapBlockId) {
+	const peeled = peelJsonLayers(id);
+	if (peeled === void 0 || !isColumnUniversalKey(peeled.value)) return void 0;
+	const remappedKey = remapKey(peeled.value, remapBlockId);
+	if (remappedKey === void 0) return void 0;
+	let rebuilt = stringifyColumnId(remappedKey);
+	for (let layer = 0; layer < peeled.layers; layer++) rebuilt = JSON.stringify(rebuilt);
+	return rebuilt;
+}
+/** The key half of {@link remapColumnIdBlockIds}. `undefined` means "nothing to change". */
+function remapKey(key, remapBlockId) {
+	if (require_spec.isGlobalPObjectKey(key)) {
+		const blockId = remapBlockId(key.blockId);
+		return blockId === key.blockId ? void 0 : {
+			...key,
+			blockId
+		};
+	}
+	if (require_spec.isLocalPObjectKey(key)) return void 0;
+	if (require_filtered_column.isColumnFilteredKey(key)) {
+		const source = remapIdString(key.source, remapBlockId);
+		return source === void 0 ? void 0 : {
+			...key,
+			source
+		};
+	}
+	if (require_overridden.isColumnOverriddenKey(key)) {
+		const source = remapIdString(key.source, remapBlockId);
+		return source === void 0 ? void 0 : {
+			...key,
+			source
+		};
+	}
+	if (require_discovered_column.isColumnDiscoveredKey(key)) return remapDiscoveredKey(key, remapBlockId);
+	throw new Error(`remapColumnIdBlockIds: unrecognized column id structure: ${JSON.stringify(key)}`);
+}
+/**
+* Discovered is the only key form carrying more than one nested id: the column it
+* discovered, one per linker hop, and one per entry in `queriesQualifications` — where the
+* id is the map key, not the value.
+*/
+function remapDiscoveredKey(key, remapBlockId) {
+	const column = remapIdString(key.column, remapBlockId);
+	let pathChanged = false;
+	const path = key.path?.map((item) => {
+		const itemColumn = remapIdString(item.column, remapBlockId);
+		if (itemColumn === void 0) return item;
+		pathChanged = true;
+		return {
+			...item,
+			column: itemColumn
+		};
+	});
+	let queriesChanged = false;
+	const queriesQualifications = key.queriesQualifications && Object.fromEntries(Object.entries(key.queriesQualifications).map(([queryId, qualifications]) => {
+		const remappedId = remapIdString(queryId, remapBlockId);
+		if (remappedId === void 0) return [queryId, qualifications];
+		queriesChanged = true;
+		return [remappedId, qualifications];
+	}));
+	if (column === void 0 && !pathChanged && !queriesChanged) return void 0;
+	return {
+		...key,
+		...column !== void 0 ? { column } : {},
+		...pathChanged ? { path } : {},
+		...queriesChanged ? { queriesQualifications } : {}
+	};
+}
 /**
 * Walk a rich column id down to its terminal leaf {@link PObjectId}.
 */
@@ -69,9 +216,13 @@ function reconstructSpecFromId(baseSpec, id) {
 }
 //#endregion
 exports.extractPObjectId = extractPObjectId;
+exports.isColumnUniversalId = isColumnUniversalId;
+exports.isColumnUniversalKey = isColumnUniversalKey;
 exports.parseColumnId = parseColumnId;
 exports.parseColumnIdSafely = parseColumnIdSafely;
+exports.peelJsonLayers = peelJsonLayers;
 exports.reconstructSpecFromId = reconstructSpecFromId;
+exports.remapColumnIdBlockIds = remapColumnIdBlockIds;
 exports.stringifyColumnId = stringifyColumnId;
 
 //# sourceMappingURL=ids.cjs.map