@milaboratories/pl-model-common 1.46.4 → 1.47.0

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

@@ -1023,6 +1023,29 @@ interface QueryTransformColumns<Q, E, SO> {
   /** 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
-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, QuerySymmetricJoin, QueryTransformColumns, RankingKind, TransformColumnEntry, TransformColumnsMode };
+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_spec.d.ts

@@ -1,5 +1,7 @@
 import { Domain, PColumnIdAndSpec } from "../spec/spec.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, QuerySymmetricJoin, QueryTransformColumns } from "./query_common.js";
+import { SpecOverrides } from "../spec/overridden.js";
+import { ColumnUniversalId } from "../spec/ids.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";
 //#region src/drivers/pframe/query/query_spec.d.ts
@@ -13,41 +15,39 @@ import { PObjectId } from "../../../pool/spec.js";
  *   qualifications: [{ axis: { name: 'sample' }, contextDomain: { ... } }]
  * }
  */
-type SpecQueryJoinEntry<C = PObjectId> = QueryJoinEntry<SpecQuery<C>> & {
-  qualifications?: {
+type SpecQueryJoinEntry<C = ColumnUniversalId> = QueryJoinEntry<SpecQuery<C>> & {
+  qualifications?: readonly {
     /** Axis to qualify. */axis: SingleAxisSelector; /** Additional domain constraints for this axis. */
     contextDomain: Domain;
   }[];
 };
 /** @see QueryColumn */
-type SpecQueryColumn<C = PObjectId> = QueryColumn<C>;
+type SpecQueryColumn<C = ColumnUniversalId> = QueryColumn<C>;
 /** @see QueryInlineColumn */
 type SpecQueryInlineColumn = QueryInlineColumn<PColumnIdAndSpec>;
 /** @see QuerySparseToDenseColumn */
-type SpecQuerySparseToDenseColumn<C = PObjectId> = QuerySparseToDenseColumn<C, SingleAxisSelector, PColumnIdAndSpec>;
+type SpecQuerySparseToDenseColumn<C = ColumnUniversalId> = QuerySparseToDenseColumn<C, SingleAxisSelector, PColumnIdAndSpec>;
 /** @see QuerySymmetricJoin */
-type SpecQuerySymmetricJoin<C = PObjectId> = QuerySymmetricJoin<SpecQueryJoinEntry<C>>;
+type SpecQuerySymmetricJoin<C = ColumnUniversalId> = QuerySymmetricJoin<SpecQueryJoinEntry<C>>;
 /** @see QueryOuterJoin */
-type SpecQueryOuterJoin<C = PObjectId> = QueryOuterJoin<SpecQueryJoinEntry<C>>;
-/**
- * Linker side of a spec-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.
- */
-type SpecQueryLinkerJoinLinker<C = PObjectId> = {
-  /** Linker column reference. */column: C;
-};
+type SpecQueryOuterJoin<C = ColumnUniversalId> = QueryOuterJoin<SpecQueryJoinEntry<C>>;
 /** @see QueryLinkerJoin */
-type SpecQueryLinkerJoin<C = PObjectId> = QueryLinkerJoin<SpecQueryLinkerJoinLinker<C>, SpecQueryJoinEntry<C>>;
+type SpecQueryLinkerJoin<C = ColumnUniversalId> = QueryLinkerJoin<SpecQuery<C>, SpecQueryJoinEntry<C>>;
 /** @see QuerySliceAxes */
-type SpecQuerySliceAxes<C = PObjectId> = QuerySliceAxes<SpecQuery<C>, SingleAxisSelector>;
+type SpecQuerySliceAxes<C = ColumnUniversalId> = QuerySliceAxes<SpecQuery<C>, SingleAxisSelector>;
 /** @see QuerySort */
-type SpecQuerySort<C = PObjectId> = QuerySort<SpecQuery<C>, SpecQueryExpression>;
+type SpecQuerySort<C = ColumnUniversalId> = QuerySort<SpecQuery<C>, SpecQueryExpression>;
 /** @see QueryFilter */
-type SpecQueryFilter<C = PObjectId> = QueryFilter<SpecQuery<C>, SpecQueryBooleanExpression>;
+type SpecQueryFilter<C = ColumnUniversalId> = QueryFilter<SpecQuery<C>, SpecQueryBooleanExpression>;
 /** @see QueryTransformColumns */
-type SpecQueryTransformColumns<C = PObjectId> = QueryTransformColumns<SpecQuery<C>, SpecQueryExpression, PColumnIdAndSpec>;
+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>;
 /**
  * Union of all spec layer query types.
  *
@@ -62,14 +62,15 @@ type SpecQueryTransformColumns<C = PObjectId> = QueryTransformColumns<SpecQuery<
  * - 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 SpecQuery<C = PObjectId> = SpecQueryColumn<C> | SpecQueryInlineColumn | SpecQuerySparseToDenseColumn<C> | SpecQuerySymmetricJoin<C> | SpecQueryOuterJoin<C> | SpecQueryLinkerJoin<C> | SpecQuerySliceAxes<C> | SpecQuerySort<C> | SpecQueryFilter<C> | SpecQueryTransformColumns<C>;
+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<PObjectId>;
+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
-export { SpecExprAxisRef, SpecExprColumnRef, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryLinkerJoin, SpecQueryLinkerJoinLinker, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin, SpecQueryTransformColumns };
+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":";;;;;;;;;;AA6CA;;;;;KAAY,kBAAA,KAAuB,SAAA,IAAa,cAAA,CAAe,SAAA,CAAU,CAAA;EACvE,cAAA;IAEQ,uBAAN,IAAA,EAAM,kBAAA,EAEe;IAArB,aAAA,EAAe,MAAA;EAAA;AAAA;;KAKP,eAAA,KAAoB,SAAA,IAAa,WAAA,CAAY,CAAA;;KAE7C,qBAAA,GAAwB,iBAAiB,CAAC,gBAAA;;KAE1C,4BAAA,KAAiC,SAAA,IAAa,wBAAA,CACxD,CAAA,EACA,kBAAA,EACA,gBAAA;;KAGU,sBAAA,KAA2B,SAAA,IAAa,kBAAA,CAAmB,kBAAA,CAAmB,CAAA;;KAE9E,kBAAA,KAAuB,SAAA,IAAa,cAAA,CAAe,kBAAA,CAAmB,CAAA;AAZlF;;;;;;AAAA,KAmBY,yBAAA,KAA8B,SAAA;EAnBc,+BAqBtD,MAAA,EAAQ,CAAC;AAAA;;KAGC,mBAAA,KAAwB,SAAA,IAAa,eAAA,CAC/C,yBAAA,CAA0B,CAAA,GAC1B,kBAAA,CAAmB,CAAA;;KAGT,kBAAA,KAAuB,SAAA,IAAa,cAAA,CAAe,SAAA,CAAU,CAAA,GAAI,kBAAA;AA3B7E;AAAA,KA6BY,aAAA,KAAkB,SAAA,IAAa,SAAA,CAAU,SAAA,CAAU,CAAA,GAAI,mBAAA;;KAEvD,eAAA,KAAoB,SAAA,IAAa,WAAA,CAAY,SAAA,CAAU,CAAA,GAAI,0BAAA;AA/BD;AAAA,KAiC1D,yBAAA,KAA8B,SAAA,IAAa,qBAAA,CACrD,SAAA,CAAU,CAAA,GACV,mBAAA,EACA,gBAAA;;;;;;;;;;;;;;;;KAkBU,SAAA,KAAc,SAAA,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;AA3DZ;AAAA,KA8DN,eAAA,GAAkB,WAAW,CAAC,kBAAA;;KAE9B,iBAAA,GAAoB,aAAa,CAAC,SAAA;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":";;;;;;;;;;;;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"}

package/dist/drivers/pframe/query/utils.cjs

@@ -65,20 +65,23 @@ function traverseQuerySpec(query, visitor) {
 				secondary: query.secondary.map(traverseEntry)
 			};
 			break;
-		case "linkerJoin":
+		case "linkerJoin": {
+			const linker = "type" in query.linker ? query.linker : {
+				type: "column",
+				column: query.linker.column
+			};
 			result = {
 				...query,
-				linker: {
-					...query.linker,
-					column: visitor.column(query.linker.column)
-				},
+				linker: traverseQuerySpec(linker, visitor),
 				secondary: query.secondary.map(traverseEntry)
 			};
 			break;
+		}
 		case "filter":
 		case "sort":
 		case "sliceAxes":
 		case "transformColumns":
+		case "specOverride":
 			result = {
 				...query,
 				input: traverseQuerySpec(query.input, visitor)
@@ -89,8 +92,8 @@ function traverseQuerySpec(query, visitor) {
 	return visitor.node ? visitor.node(result) : result;
 }
 /** Recursively maps all column references in a SpecQuery tree. */
-function mapSpecQueryColumns(query, cb) {
-	return traverseQuerySpec(query, { column: cb });
+function mapSpecQueryColumns(query, visitor) {
+	return traverseQuerySpec(query, visitor);
 }
 /** Collects all column references from a SpecQuery tree. */
 function collectSpecQueryColumns(query) {
@@ -185,7 +188,8 @@ function cmpQuerySpec(lhs, rhs) {
 		}
 		case "linkerJoin": {
 			const rhsLinker = rhs;
-			if (lhs.linker.column !== rhsLinker.linker.column) return lhs.linker.column < rhsLinker.linker.column ? -1 : 1;
+			const cmp = cmpQuerySpec(lhs.linker, rhsLinker.linker);
+			if (cmp !== 0) return cmp;
 			if (lhs.secondary.length !== rhsLinker.secondary.length) return lhs.secondary.length - rhsLinker.secondary.length;
 			for (let i = 0; i < lhs.secondary.length; i++) {
 				const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);
@@ -196,6 +200,12 @@ function cmpQuerySpec(lhs, rhs) {
 		case "sliceAxes": return cmpQuerySpec(lhs.input, rhs.input);
 		case "sort": return cmpQuerySpec(lhs.input, rhs.input);
 		case "filter": return cmpQuerySpec(lhs.input, rhs.input);
+		case "specOverride": {
+			const rhsSo = rhs;
+			const cmp = cmpQuerySpec(lhs.input, rhsSo.input);
+			if (cmp !== 0) return cmp;
+			return require_json.canonicalizeJson(lhs.override).localeCompare(require_json.canonicalizeJson(rhsSo.override));
+		}
 		case "transformColumns": {
 			const rhsTc = rhs;
 			const cmp = cmpQuerySpec(lhs.input, rhsTc.input);

package/dist/drivers/pframe/query/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["canonicalizeJson"],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"sourcesContent":["import { canonicalizeJson } from \"../../../json\";\nimport { assertNever } from \"../../../util\";\nimport type {\n  SpecQueryBooleanExpression,\n  SpecQueryExpression,\n  SpecQuery,\n  SpecQueryJoinEntry,\n} from \"./query_spec\";\n\nconst BOOLEAN_TYPES = new Set<SpecQueryBooleanExpression[\"type\"]>([\n  \"numericComparison\",\n  \"stringEquals\",\n  \"stringContains\",\n  \"stringContainsFuzzy\",\n  \"stringRegex\",\n  \"isNull\",\n  \"not\",\n  \"and\",\n  \"or\",\n  \"isIn\",\n  // \"isInPolygon\",  -- disabled until the Rust executor wires it up\n]);\n\nexport function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression {\n  return BOOLEAN_TYPES.has(\n    // @ts-expect-error -- TypeScript doesn't understand the discriminated union here, but we do at runtime\n    expr.type,\n  );\n}\n\n/**\n * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.\n *\n * Traversal order:\n * 1. Recurse into child queries\n * 2. Apply `column` to transform column references in leaf nodes\n * 3. Apply `joinEntry` to each join entry (with inner query already traversed)\n * 4. Assemble node with transformed children\n * 5. Apply `node` to the assembled node\n */\nexport function traverseQuerySpec<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  const traverseEntry = (entry: SpecQueryJoinEntry<C1>): SpecQueryJoinEntry<C2> => {\n    const traversed: SpecQueryJoinEntry<C2> = {\n      ...entry,\n      entry: traverseQuerySpec(entry.entry, visitor),\n    };\n    return visitor.joinEntry ? visitor.joinEntry(traversed) : traversed;\n  };\n\n  let result: SpecQuery<C2>;\n  switch (query.type) {\n    case \"column\":\n      result = { type: \"column\", column: visitor.column(query.column) };\n      break;\n    case \"sparseToDenseColumn\":\n      result = { ...query, column: visitor.column(query.column) };\n      break;\n    case \"inlineColumn\":\n      result = query;\n      break;\n    case \"innerJoin\":\n    case \"fullJoin\":\n      result = { ...query, entries: query.entries.map(traverseEntry) };\n      break;\n    case \"outerJoin\":\n      result = {\n        ...query,\n        primary: traverseEntry(query.primary),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"linkerJoin\":\n      result = {\n        ...query,\n        linker: { ...query.linker, column: visitor.column(query.linker.column) },\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"filter\":\n    case \"sort\":\n    case \"sliceAxes\":\n    case \"transformColumns\":\n      result = { ...query, input: traverseQuerySpec(query.input, visitor) };\n      break;\n    default:\n      assertNever(query);\n  }\n\n  return visitor.node ? visitor.node(result) : result;\n}\n\n/** Recursively maps all column references in a SpecQuery tree. */\nexport function mapSpecQueryColumns<C1, C2>(\n  query: SpecQuery<C1>,\n  cb: (c: C1) => C2,\n): SpecQuery<C2> {\n  return traverseQuerySpec(query, { column: cb });\n}\n\n/** Collects all column references from a SpecQuery tree. */\nexport function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[] {\n  const result: C[] = [];\n  traverseQuerySpec(query, {\n    column: (c: C) => {\n      result.push(c);\n      return c;\n    },\n  });\n  return result;\n}\n\nexport function sortSpecQuery(query: SpecQuery): SpecQuery {\n  return traverseQuerySpec(query, {\n    column: (c) => c,\n    node: (node) => {\n      switch (node.type) {\n        case \"sparseToDenseColumn\":\n          return {\n            ...node,\n            // toSorted preserves array length but the type system widens\n            // the non-empty tuple back to a plain array, so re-narrow.\n            axes: node.axes.toSorted((a, b) =>\n              canonicalizeJson(a).localeCompare(canonicalizeJson(b)),\n            ) as typeof node.axes,\n          };\n        case \"innerJoin\":\n        case \"fullJoin\": {\n          const sorted = [...node.entries].sort(cmpQueryJoinEntrySpec);\n          return { ...node, entries: sorted };\n        }\n        case \"outerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"linkerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"sliceAxes\":\n          return {\n            ...node,\n            axisFilters: node.axisFilters.toSorted((a, b) => {\n              const ak = canonicalizeJson(a.axisSelector);\n              const bk = canonicalizeJson(b.axisSelector);\n              return ak < bk ? -1 : ak === bk ? 0 : 1;\n            }),\n          };\n        default:\n          return node;\n      }\n    },\n    joinEntry: (entry) => {\n      // Preserve absence of `qualifications` (absent == `[]`) so canonical\n      // output is stable across both input forms.\n      if (entry.qualifications === undefined || entry.qualifications.length === 0) {\n        return entry;\n      }\n      return {\n        ...entry,\n        qualifications: entry.qualifications.toSorted((a, b) => {\n          const ak = canonicalizeJson(a.axis);\n          const bk = canonicalizeJson(b.axis);\n          return ak < bk ? -1 : ak === bk ? 0 : 1;\n        }),\n      };\n    },\n  });\n}\n\nfunction cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  switch (lhs.type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"inlineColumn\":\n      return lhs.spec.columnId < (rhs as typeof lhs).spec.columnId\n        ? -1\n        : lhs.spec.columnId === (rhs as typeof lhs).spec.columnId\n          ? 0\n          : 1;\n    case \"sparseToDenseColumn\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"innerJoin\":\n    case \"fullJoin\": {\n      const rhsJoin = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsJoin.entries.length) {\n        return lhs.entries.length - rhsJoin.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.entries[i], rhsJoin.entries[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"outerJoin\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpQueryJoinEntrySpec(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"linkerJoin\": {\n      const rhsLinker = rhs as typeof lhs;\n      if (lhs.linker.column !== rhsLinker.linker.column) {\n        return lhs.linker.column < rhsLinker.linker.column ? -1 : 1;\n      }\n      if (lhs.secondary.length !== rhsLinker.secondary.length) {\n        return lhs.secondary.length - rhsLinker.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"sliceAxes\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"sort\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"filter\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"transformColumns\": {\n      const rhsTc = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsTc.input);\n      if (cmp !== 0) return cmp;\n      const modeCmp = lhs.mode.localeCompare(rhsTc.mode);\n      if (modeCmp !== 0) return modeCmp;\n      // Column entries are positional; compare by canonical JSON.\n      return canonicalizeJson(lhs.columns).localeCompare(canonicalizeJson(rhsTc.columns));\n    }\n    default:\n      assertNever(lhs);\n  }\n}\n\nfunction cmpQueryJoinEntrySpec(lhs: SpecQueryJoinEntry, rhs: SpecQueryJoinEntry): number {\n  const cmp = cmpQuerySpec(lhs.entry, rhs.entry);\n  if (cmp !== 0) return cmp;\n  // Absent `qualifications` is equivalent to an empty list.\n  const lhsQ = lhs.qualifications ?? [];\n  const rhsQ = rhs.qualifications ?? [];\n  if (lhsQ.length !== rhsQ.length) {\n    return lhsQ.length - rhsQ.length;\n  }\n  for (let i = 0; i < lhsQ.length; i++) {\n    const l = canonicalizeJson(lhsQ[i]);\n    const r = canonicalizeJson(rhsQ[i]);\n    if (l !== r) return l < r ? -1 : 1;\n  }\n  return 0;\n}\n"],"mappings":"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"}
+{"version":3,"file":"utils.cjs","names":["canonicalizeJson"],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"sourcesContent":["import { canonicalizeJson } from \"../../../json\";\nimport { assertNever } from \"../../../util\";\nimport type {\n  SpecQueryBooleanExpression,\n  SpecQueryExpression,\n  SpecQuery,\n  SpecQueryJoinEntry,\n} from \"./query_spec\";\n\nconst BOOLEAN_TYPES = new Set<SpecQueryBooleanExpression[\"type\"]>([\n  \"numericComparison\",\n  \"stringEquals\",\n  \"stringContains\",\n  \"stringContainsFuzzy\",\n  \"stringRegex\",\n  \"isNull\",\n  \"not\",\n  \"and\",\n  \"or\",\n  \"isIn\",\n  // \"isInPolygon\",  -- disabled until the Rust executor wires it up\n]);\n\nexport function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression {\n  return BOOLEAN_TYPES.has(\n    // @ts-expect-error -- TypeScript doesn't understand the discriminated union here, but we do at runtime\n    expr.type,\n  );\n}\n\n/**\n * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.\n *\n * Traversal order:\n * 1. Recurse into child queries\n * 2. Apply `column` to transform column references in leaf nodes\n * 3. Apply `joinEntry` to each join entry (with inner query already traversed)\n * 4. Assemble node with transformed children\n * 5. Apply `node` to the assembled node\n */\nexport function traverseQuerySpec<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  const traverseEntry = (entry: SpecQueryJoinEntry<C1>): SpecQueryJoinEntry<C2> => {\n    const traversed: SpecQueryJoinEntry<C2> = {\n      ...entry,\n      entry: traverseQuerySpec(entry.entry, visitor),\n    };\n    return visitor.joinEntry ? visitor.joinEntry(traversed) : traversed;\n  };\n\n  let result: SpecQuery<C2>;\n  switch (query.type) {\n    case \"column\":\n      result = { type: \"column\", column: visitor.column(query.column) };\n      break;\n    case \"sparseToDenseColumn\":\n      result = { ...query, column: visitor.column(query.column) };\n      break;\n    case \"inlineColumn\":\n      result = query;\n      break;\n    case \"innerJoin\":\n    case \"fullJoin\":\n      result = { ...query, entries: query.entries.map(traverseEntry) };\n      break;\n    case \"outerJoin\":\n      result = {\n        ...query,\n        primary: traverseEntry(query.primary),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"linkerJoin\": {\n      // Back-compat: pre-#c7309fc8 blocks emit `linker` as `{ column }` without\n      // a `type` — tag it as a `column` node so recursion handles it normally.\n      const linker =\n        \"type\" in query.linker\n          ? query.linker\n          : ({ type: \"column\", column: (query.linker as { column: C1 }).column } as SpecQuery<C1>);\n      result = {\n        ...query,\n        linker: traverseQuerySpec(linker, visitor),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    }\n    case \"filter\":\n    case \"sort\":\n    case \"sliceAxes\":\n    case \"transformColumns\":\n    case \"specOverride\":\n      result = { ...query, input: traverseQuerySpec(query.input, visitor) };\n      break;\n    default:\n      assertNever(query);\n  }\n\n  return visitor.node ? visitor.node(result) : result;\n}\n\n/** Recursively maps all column references in a SpecQuery tree. */\nexport function mapSpecQueryColumns<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  return traverseQuerySpec(query, visitor);\n}\n\n/** Collects all column references from a SpecQuery tree. */\nexport function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[] {\n  const result: C[] = [];\n  traverseQuerySpec(query, {\n    column: (c: C) => {\n      result.push(c);\n      return c;\n    },\n  });\n  return result;\n}\n\nexport function sortSpecQuery(query: SpecQuery): SpecQuery {\n  return traverseQuerySpec(query, {\n    column: (c) => c,\n    node: (node) => {\n      switch (node.type) {\n        case \"sparseToDenseColumn\":\n          return {\n            ...node,\n            // toSorted preserves array length but the type system widens\n            // the non-empty tuple back to a plain array, so re-narrow.\n            axes: node.axes.toSorted((a, b) =>\n              canonicalizeJson(a).localeCompare(canonicalizeJson(b)),\n            ) as typeof node.axes,\n          };\n        case \"innerJoin\":\n        case \"fullJoin\": {\n          const sorted = [...node.entries].sort(cmpQueryJoinEntrySpec);\n          return { ...node, entries: sorted };\n        }\n        case \"outerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"linkerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"sliceAxes\":\n          return {\n            ...node,\n            axisFilters: node.axisFilters.toSorted((a, b) => {\n              const ak = canonicalizeJson(a.axisSelector);\n              const bk = canonicalizeJson(b.axisSelector);\n              return ak < bk ? -1 : ak === bk ? 0 : 1;\n            }),\n          };\n        default:\n          return node;\n      }\n    },\n    joinEntry: (entry) => {\n      // Preserve absence of `qualifications` (absent == `[]`) so canonical\n      // output is stable across both input forms.\n      if (entry.qualifications === undefined || entry.qualifications.length === 0) {\n        return entry;\n      }\n      return {\n        ...entry,\n        qualifications: entry.qualifications.toSorted((a, b) => {\n          const ak = canonicalizeJson(a.axis);\n          const bk = canonicalizeJson(b.axis);\n          return ak < bk ? -1 : ak === bk ? 0 : 1;\n        }),\n      };\n    },\n  });\n}\n\nfunction cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  switch (lhs.type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"inlineColumn\":\n      return lhs.spec.columnId < (rhs as typeof lhs).spec.columnId\n        ? -1\n        : lhs.spec.columnId === (rhs as typeof lhs).spec.columnId\n          ? 0\n          : 1;\n    case \"sparseToDenseColumn\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"innerJoin\":\n    case \"fullJoin\": {\n      const rhsJoin = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsJoin.entries.length) {\n        return lhs.entries.length - rhsJoin.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.entries[i], rhsJoin.entries[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"outerJoin\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpQueryJoinEntrySpec(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"linkerJoin\": {\n      const rhsLinker = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.linker, rhsLinker.linker);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsLinker.secondary.length) {\n        return lhs.secondary.length - rhsLinker.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"sliceAxes\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"sort\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"filter\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"specOverride\": {\n      const rhsSo = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsSo.input);\n      if (cmp !== 0) return cmp;\n      return canonicalizeJson(lhs.override).localeCompare(canonicalizeJson(rhsSo.override));\n    }\n    case \"transformColumns\": {\n      const rhsTc = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsTc.input);\n      if (cmp !== 0) return cmp;\n      const modeCmp = lhs.mode.localeCompare(rhsTc.mode);\n      if (modeCmp !== 0) return modeCmp;\n      // Column entries are positional; compare by canonical JSON.\n      return canonicalizeJson(lhs.columns).localeCompare(canonicalizeJson(rhsTc.columns));\n    }\n    default:\n      assertNever(lhs);\n  }\n}\n\nfunction cmpQueryJoinEntrySpec(lhs: SpecQueryJoinEntry, rhs: SpecQueryJoinEntry): number {\n  const cmp = cmpQuerySpec(lhs.entry, rhs.entry);\n  if (cmp !== 0) return cmp;\n  // Absent `qualifications` is equivalent to an empty list.\n  const lhsQ = lhs.qualifications ?? [];\n  const rhsQ = rhs.qualifications ?? [];\n  if (lhsQ.length !== rhsQ.length) {\n    return lhsQ.length - rhsQ.length;\n  }\n  for (let i = 0; i < lhsQ.length; i++) {\n    const l = canonicalizeJson(lhsQ[i]);\n    const r = canonicalizeJson(rhsQ[i]);\n    if (l !== r) return l < r ? -1 : 1;\n  }\n  return 0;\n}\n"],"mappings":"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"}

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

@@ -18,7 +18,11 @@ declare function traverseQuerySpec<C1, C2>(query: SpecQuery<C1>, visitor: {
   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>, cb: (c: C1) => C2): SpecQuery<C2>;
+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;

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;;iBAoDG,mBAAA,SACd,KAAA,EAAO,SAAA,CAAU,EAAA,GACjB,EAAA,GAAK,CAAA,EAAG,EAAA,KAAO,EAAA,GACd,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":";;;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"}

package/dist/drivers/pframe/query/utils.js

@@ -65,20 +65,23 @@ function traverseQuerySpec(query, visitor) {
 				secondary: query.secondary.map(traverseEntry)
 			};
 			break;
-		case "linkerJoin":
+		case "linkerJoin": {
+			const linker = "type" in query.linker ? query.linker : {
+				type: "column",
+				column: query.linker.column
+			};
 			result = {
 				...query,
-				linker: {
-					...query.linker,
-					column: visitor.column(query.linker.column)
-				},
+				linker: traverseQuerySpec(linker, visitor),
 				secondary: query.secondary.map(traverseEntry)
 			};
 			break;
+		}
 		case "filter":
 		case "sort":
 		case "sliceAxes":
 		case "transformColumns":
+		case "specOverride":
 			result = {
 				...query,
 				input: traverseQuerySpec(query.input, visitor)
@@ -89,8 +92,8 @@ function traverseQuerySpec(query, visitor) {
 	return visitor.node ? visitor.node(result) : result;
 }
 /** Recursively maps all column references in a SpecQuery tree. */
-function mapSpecQueryColumns(query, cb) {
-	return traverseQuerySpec(query, { column: cb });
+function mapSpecQueryColumns(query, visitor) {
+	return traverseQuerySpec(query, visitor);
 }
 /** Collects all column references from a SpecQuery tree. */
 function collectSpecQueryColumns(query) {
@@ -185,7 +188,8 @@ function cmpQuerySpec(lhs, rhs) {
 		}
 		case "linkerJoin": {
 			const rhsLinker = rhs;
-			if (lhs.linker.column !== rhsLinker.linker.column) return lhs.linker.column < rhsLinker.linker.column ? -1 : 1;
+			const cmp = cmpQuerySpec(lhs.linker, rhsLinker.linker);
+			if (cmp !== 0) return cmp;
 			if (lhs.secondary.length !== rhsLinker.secondary.length) return lhs.secondary.length - rhsLinker.secondary.length;
 			for (let i = 0; i < lhs.secondary.length; i++) {
 				const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);
@@ -196,6 +200,12 @@ function cmpQuerySpec(lhs, rhs) {
 		case "sliceAxes": return cmpQuerySpec(lhs.input, rhs.input);
 		case "sort": return cmpQuerySpec(lhs.input, rhs.input);
 		case "filter": return cmpQuerySpec(lhs.input, rhs.input);
+		case "specOverride": {
+			const rhsSo = rhs;
+			const cmp = cmpQuerySpec(lhs.input, rhsSo.input);
+			if (cmp !== 0) return cmp;
+			return canonicalizeJson(lhs.override).localeCompare(canonicalizeJson(rhsSo.override));
+		}
 		case "transformColumns": {
 			const rhsTc = rhs;
 			const cmp = cmpQuerySpec(lhs.input, rhsTc.input);

package/dist/drivers/pframe/query/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"sourcesContent":["import { canonicalizeJson } from \"../../../json\";\nimport { assertNever } from \"../../../util\";\nimport type {\n  SpecQueryBooleanExpression,\n  SpecQueryExpression,\n  SpecQuery,\n  SpecQueryJoinEntry,\n} from \"./query_spec\";\n\nconst BOOLEAN_TYPES = new Set<SpecQueryBooleanExpression[\"type\"]>([\n  \"numericComparison\",\n  \"stringEquals\",\n  \"stringContains\",\n  \"stringContainsFuzzy\",\n  \"stringRegex\",\n  \"isNull\",\n  \"not\",\n  \"and\",\n  \"or\",\n  \"isIn\",\n  // \"isInPolygon\",  -- disabled until the Rust executor wires it up\n]);\n\nexport function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression {\n  return BOOLEAN_TYPES.has(\n    // @ts-expect-error -- TypeScript doesn't understand the discriminated union here, but we do at runtime\n    expr.type,\n  );\n}\n\n/**\n * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.\n *\n * Traversal order:\n * 1. Recurse into child queries\n * 2. Apply `column` to transform column references in leaf nodes\n * 3. Apply `joinEntry` to each join entry (with inner query already traversed)\n * 4. Assemble node with transformed children\n * 5. Apply `node` to the assembled node\n */\nexport function traverseQuerySpec<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  const traverseEntry = (entry: SpecQueryJoinEntry<C1>): SpecQueryJoinEntry<C2> => {\n    const traversed: SpecQueryJoinEntry<C2> = {\n      ...entry,\n      entry: traverseQuerySpec(entry.entry, visitor),\n    };\n    return visitor.joinEntry ? visitor.joinEntry(traversed) : traversed;\n  };\n\n  let result: SpecQuery<C2>;\n  switch (query.type) {\n    case \"column\":\n      result = { type: \"column\", column: visitor.column(query.column) };\n      break;\n    case \"sparseToDenseColumn\":\n      result = { ...query, column: visitor.column(query.column) };\n      break;\n    case \"inlineColumn\":\n      result = query;\n      break;\n    case \"innerJoin\":\n    case \"fullJoin\":\n      result = { ...query, entries: query.entries.map(traverseEntry) };\n      break;\n    case \"outerJoin\":\n      result = {\n        ...query,\n        primary: traverseEntry(query.primary),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"linkerJoin\":\n      result = {\n        ...query,\n        linker: { ...query.linker, column: visitor.column(query.linker.column) },\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"filter\":\n    case \"sort\":\n    case \"sliceAxes\":\n    case \"transformColumns\":\n      result = { ...query, input: traverseQuerySpec(query.input, visitor) };\n      break;\n    default:\n      assertNever(query);\n  }\n\n  return visitor.node ? visitor.node(result) : result;\n}\n\n/** Recursively maps all column references in a SpecQuery tree. */\nexport function mapSpecQueryColumns<C1, C2>(\n  query: SpecQuery<C1>,\n  cb: (c: C1) => C2,\n): SpecQuery<C2> {\n  return traverseQuerySpec(query, { column: cb });\n}\n\n/** Collects all column references from a SpecQuery tree. */\nexport function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[] {\n  const result: C[] = [];\n  traverseQuerySpec(query, {\n    column: (c: C) => {\n      result.push(c);\n      return c;\n    },\n  });\n  return result;\n}\n\nexport function sortSpecQuery(query: SpecQuery): SpecQuery {\n  return traverseQuerySpec(query, {\n    column: (c) => c,\n    node: (node) => {\n      switch (node.type) {\n        case \"sparseToDenseColumn\":\n          return {\n            ...node,\n            // toSorted preserves array length but the type system widens\n            // the non-empty tuple back to a plain array, so re-narrow.\n            axes: node.axes.toSorted((a, b) =>\n              canonicalizeJson(a).localeCompare(canonicalizeJson(b)),\n            ) as typeof node.axes,\n          };\n        case \"innerJoin\":\n        case \"fullJoin\": {\n          const sorted = [...node.entries].sort(cmpQueryJoinEntrySpec);\n          return { ...node, entries: sorted };\n        }\n        case \"outerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"linkerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"sliceAxes\":\n          return {\n            ...node,\n            axisFilters: node.axisFilters.toSorted((a, b) => {\n              const ak = canonicalizeJson(a.axisSelector);\n              const bk = canonicalizeJson(b.axisSelector);\n              return ak < bk ? -1 : ak === bk ? 0 : 1;\n            }),\n          };\n        default:\n          return node;\n      }\n    },\n    joinEntry: (entry) => {\n      // Preserve absence of `qualifications` (absent == `[]`) so canonical\n      // output is stable across both input forms.\n      if (entry.qualifications === undefined || entry.qualifications.length === 0) {\n        return entry;\n      }\n      return {\n        ...entry,\n        qualifications: entry.qualifications.toSorted((a, b) => {\n          const ak = canonicalizeJson(a.axis);\n          const bk = canonicalizeJson(b.axis);\n          return ak < bk ? -1 : ak === bk ? 0 : 1;\n        }),\n      };\n    },\n  });\n}\n\nfunction cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  switch (lhs.type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"inlineColumn\":\n      return lhs.spec.columnId < (rhs as typeof lhs).spec.columnId\n        ? -1\n        : lhs.spec.columnId === (rhs as typeof lhs).spec.columnId\n          ? 0\n          : 1;\n    case \"sparseToDenseColumn\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"innerJoin\":\n    case \"fullJoin\": {\n      const rhsJoin = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsJoin.entries.length) {\n        return lhs.entries.length - rhsJoin.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.entries[i], rhsJoin.entries[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"outerJoin\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpQueryJoinEntrySpec(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"linkerJoin\": {\n      const rhsLinker = rhs as typeof lhs;\n      if (lhs.linker.column !== rhsLinker.linker.column) {\n        return lhs.linker.column < rhsLinker.linker.column ? -1 : 1;\n      }\n      if (lhs.secondary.length !== rhsLinker.secondary.length) {\n        return lhs.secondary.length - rhsLinker.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"sliceAxes\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"sort\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"filter\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"transformColumns\": {\n      const rhsTc = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsTc.input);\n      if (cmp !== 0) return cmp;\n      const modeCmp = lhs.mode.localeCompare(rhsTc.mode);\n      if (modeCmp !== 0) return modeCmp;\n      // Column entries are positional; compare by canonical JSON.\n      return canonicalizeJson(lhs.columns).localeCompare(canonicalizeJson(rhsTc.columns));\n    }\n    default:\n      assertNever(lhs);\n  }\n}\n\nfunction cmpQueryJoinEntrySpec(lhs: SpecQueryJoinEntry, rhs: SpecQueryJoinEntry): number {\n  const cmp = cmpQuerySpec(lhs.entry, rhs.entry);\n  if (cmp !== 0) return cmp;\n  // Absent `qualifications` is equivalent to an empty list.\n  const lhsQ = lhs.qualifications ?? [];\n  const rhsQ = rhs.qualifications ?? [];\n  if (lhsQ.length !== rhsQ.length) {\n    return lhsQ.length - rhsQ.length;\n  }\n  for (let i = 0; i < lhsQ.length; i++) {\n    const l = canonicalizeJson(lhsQ[i]);\n    const r = canonicalizeJson(rhsQ[i]);\n    if (l !== r) return l < r ? -1 : 1;\n  }\n  return 0;\n}\n"],"mappings":"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"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../../../src/drivers/pframe/query/utils.ts"],"sourcesContent":["import { canonicalizeJson } from \"../../../json\";\nimport { assertNever } from \"../../../util\";\nimport type {\n  SpecQueryBooleanExpression,\n  SpecQueryExpression,\n  SpecQuery,\n  SpecQueryJoinEntry,\n} from \"./query_spec\";\n\nconst BOOLEAN_TYPES = new Set<SpecQueryBooleanExpression[\"type\"]>([\n  \"numericComparison\",\n  \"stringEquals\",\n  \"stringContains\",\n  \"stringContainsFuzzy\",\n  \"stringRegex\",\n  \"isNull\",\n  \"not\",\n  \"and\",\n  \"or\",\n  \"isIn\",\n  // \"isInPolygon\",  -- disabled until the Rust executor wires it up\n]);\n\nexport function isBooleanExpression(expr: SpecQueryExpression): expr is SpecQueryBooleanExpression {\n  return BOOLEAN_TYPES.has(\n    // @ts-expect-error -- TypeScript doesn't understand the discriminated union here, but we do at runtime\n    expr.type,\n  );\n}\n\n/**\n * Recursively traverses a SpecQuery tree bottom-up, applying visitor callbacks.\n *\n * Traversal order:\n * 1. Recurse into child queries\n * 2. Apply `column` to transform column references in leaf nodes\n * 3. Apply `joinEntry` to each join entry (with inner query already traversed)\n * 4. Assemble node with transformed children\n * 5. Apply `node` to the assembled node\n */\nexport function traverseQuerySpec<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  const traverseEntry = (entry: SpecQueryJoinEntry<C1>): SpecQueryJoinEntry<C2> => {\n    const traversed: SpecQueryJoinEntry<C2> = {\n      ...entry,\n      entry: traverseQuerySpec(entry.entry, visitor),\n    };\n    return visitor.joinEntry ? visitor.joinEntry(traversed) : traversed;\n  };\n\n  let result: SpecQuery<C2>;\n  switch (query.type) {\n    case \"column\":\n      result = { type: \"column\", column: visitor.column(query.column) };\n      break;\n    case \"sparseToDenseColumn\":\n      result = { ...query, column: visitor.column(query.column) };\n      break;\n    case \"inlineColumn\":\n      result = query;\n      break;\n    case \"innerJoin\":\n    case \"fullJoin\":\n      result = { ...query, entries: query.entries.map(traverseEntry) };\n      break;\n    case \"outerJoin\":\n      result = {\n        ...query,\n        primary: traverseEntry(query.primary),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    case \"linkerJoin\": {\n      // Back-compat: pre-#c7309fc8 blocks emit `linker` as `{ column }` without\n      // a `type` — tag it as a `column` node so recursion handles it normally.\n      const linker =\n        \"type\" in query.linker\n          ? query.linker\n          : ({ type: \"column\", column: (query.linker as { column: C1 }).column } as SpecQuery<C1>);\n      result = {\n        ...query,\n        linker: traverseQuerySpec(linker, visitor),\n        secondary: query.secondary.map(traverseEntry),\n      };\n      break;\n    }\n    case \"filter\":\n    case \"sort\":\n    case \"sliceAxes\":\n    case \"transformColumns\":\n    case \"specOverride\":\n      result = { ...query, input: traverseQuerySpec(query.input, visitor) };\n      break;\n    default:\n      assertNever(query);\n  }\n\n  return visitor.node ? visitor.node(result) : result;\n}\n\n/** Recursively maps all column references in a SpecQuery tree. */\nexport function mapSpecQueryColumns<C1, C2>(\n  query: SpecQuery<C1>,\n  visitor: {\n    /** Transform column references in leaf nodes (column, sparseToDenseColumn). */\n    column: (c: C1) => C2;\n    /** Visit a node after its children have been traversed. */\n    node?: (node: SpecQuery<C2>) => SpecQuery<C2>;\n    /** Visit a join entry after its inner query has been traversed. */\n    joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;\n  },\n): SpecQuery<C2> {\n  return traverseQuerySpec(query, visitor);\n}\n\n/** Collects all column references from a SpecQuery tree. */\nexport function collectSpecQueryColumns<C>(query: SpecQuery<C>): C[] {\n  const result: C[] = [];\n  traverseQuerySpec(query, {\n    column: (c: C) => {\n      result.push(c);\n      return c;\n    },\n  });\n  return result;\n}\n\nexport function sortSpecQuery(query: SpecQuery): SpecQuery {\n  return traverseQuerySpec(query, {\n    column: (c) => c,\n    node: (node) => {\n      switch (node.type) {\n        case \"sparseToDenseColumn\":\n          return {\n            ...node,\n            // toSorted preserves array length but the type system widens\n            // the non-empty tuple back to a plain array, so re-narrow.\n            axes: node.axes.toSorted((a, b) =>\n              canonicalizeJson(a).localeCompare(canonicalizeJson(b)),\n            ) as typeof node.axes,\n          };\n        case \"innerJoin\":\n        case \"fullJoin\": {\n          const sorted = [...node.entries].sort(cmpQueryJoinEntrySpec);\n          return { ...node, entries: sorted };\n        }\n        case \"outerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"linkerJoin\": {\n          const sorted = [...node.secondary].sort(cmpQueryJoinEntrySpec);\n          return { ...node, secondary: sorted };\n        }\n        case \"sliceAxes\":\n          return {\n            ...node,\n            axisFilters: node.axisFilters.toSorted((a, b) => {\n              const ak = canonicalizeJson(a.axisSelector);\n              const bk = canonicalizeJson(b.axisSelector);\n              return ak < bk ? -1 : ak === bk ? 0 : 1;\n            }),\n          };\n        default:\n          return node;\n      }\n    },\n    joinEntry: (entry) => {\n      // Preserve absence of `qualifications` (absent == `[]`) so canonical\n      // output is stable across both input forms.\n      if (entry.qualifications === undefined || entry.qualifications.length === 0) {\n        return entry;\n      }\n      return {\n        ...entry,\n        qualifications: entry.qualifications.toSorted((a, b) => {\n          const ak = canonicalizeJson(a.axis);\n          const bk = canonicalizeJson(b.axis);\n          return ak < bk ? -1 : ak === bk ? 0 : 1;\n        }),\n      };\n    },\n  });\n}\n\nfunction cmpQuerySpec(lhs: SpecQuery, rhs: SpecQuery): number {\n  if (lhs.type !== rhs.type) {\n    return lhs.type < rhs.type ? -1 : 1;\n  }\n  switch (lhs.type) {\n    case \"column\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"inlineColumn\":\n      return lhs.spec.columnId < (rhs as typeof lhs).spec.columnId\n        ? -1\n        : lhs.spec.columnId === (rhs as typeof lhs).spec.columnId\n          ? 0\n          : 1;\n    case \"sparseToDenseColumn\":\n      return lhs.column < (rhs as typeof lhs).column\n        ? -1\n        : lhs.column === (rhs as typeof lhs).column\n          ? 0\n          : 1;\n    case \"innerJoin\":\n    case \"fullJoin\": {\n      const rhsJoin = rhs as typeof lhs;\n      if (lhs.entries.length !== rhsJoin.entries.length) {\n        return lhs.entries.length - rhsJoin.entries.length;\n      }\n      for (let i = 0; i < lhs.entries.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.entries[i], rhsJoin.entries[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"outerJoin\": {\n      const rhsOuter = rhs as typeof lhs;\n      const cmp = cmpQueryJoinEntrySpec(lhs.primary, rhsOuter.primary);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsOuter.secondary.length) {\n        return lhs.secondary.length - rhsOuter.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsOuter.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"linkerJoin\": {\n      const rhsLinker = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.linker, rhsLinker.linker);\n      if (cmp !== 0) return cmp;\n      if (lhs.secondary.length !== rhsLinker.secondary.length) {\n        return lhs.secondary.length - rhsLinker.secondary.length;\n      }\n      for (let i = 0; i < lhs.secondary.length; i++) {\n        const cmp = cmpQueryJoinEntrySpec(lhs.secondary[i], rhsLinker.secondary[i]);\n        if (cmp !== 0) return cmp;\n      }\n      return 0;\n    }\n    case \"sliceAxes\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"sort\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"filter\":\n      return cmpQuerySpec(lhs.input, (rhs as typeof lhs).input);\n    case \"specOverride\": {\n      const rhsSo = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsSo.input);\n      if (cmp !== 0) return cmp;\n      return canonicalizeJson(lhs.override).localeCompare(canonicalizeJson(rhsSo.override));\n    }\n    case \"transformColumns\": {\n      const rhsTc = rhs as typeof lhs;\n      const cmp = cmpQuerySpec(lhs.input, rhsTc.input);\n      if (cmp !== 0) return cmp;\n      const modeCmp = lhs.mode.localeCompare(rhsTc.mode);\n      if (modeCmp !== 0) return modeCmp;\n      // Column entries are positional; compare by canonical JSON.\n      return canonicalizeJson(lhs.columns).localeCompare(canonicalizeJson(rhsTc.columns));\n    }\n    default:\n      assertNever(lhs);\n  }\n}\n\nfunction cmpQueryJoinEntrySpec(lhs: SpecQueryJoinEntry, rhs: SpecQueryJoinEntry): number {\n  const cmp = cmpQuerySpec(lhs.entry, rhs.entry);\n  if (cmp !== 0) return cmp;\n  // Absent `qualifications` is equivalent to an empty list.\n  const lhsQ = lhs.qualifications ?? [];\n  const rhsQ = rhs.qualifications ?? [];\n  if (lhsQ.length !== rhsQ.length) {\n    return lhsQ.length - rhsQ.length;\n  }\n  for (let i = 0; i < lhsQ.length; i++) {\n    const l = canonicalizeJson(lhsQ[i]);\n    const r = canonicalizeJson(rhsQ[i]);\n    if (l !== r) return l < r ? -1 : 1;\n  }\n  return 0;\n}\n"],"mappings":"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"}

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

@@ -1,6 +1,6 @@
-import { AxisFilter } from "./filtered_column.js";
-import { SUniversalPColumnId, UniversalPColumnId } from "./ids.js";
 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

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

@@ -1,36 +1,52 @@
 const require_json = require("../../../json.cjs");
 let _milaboratories_helpers = require("@milaboratories/helpers");
 //#region src/drivers/pframe/spec/discovered_column.ts
-function isDiscoveredPColumn(obj) {
-	return typeof obj === "object" && obj !== null && "path" in obj && "column" in obj && "columnQualifications" in obj && "queriesQualifications" in obj;
+function isColumnDiscoveredKey(obj) {
+	return typeof obj === "object" && obj !== null && "__isDiscovered" in obj;
 }
-function distillDiscoveredPColumn(props) {
+function isColumnDiscoveredId(str) {
+	if (typeof str !== "string") return false;
+	return isColumnDiscoveredKey(require_json.parseJsonSafely(str));
+}
+function distillColumnDiscoveredKey(props) {
 	return {
+		__isDiscovered: true,
 		column: props.column,
 		path: Array.isArray(props.path) && props.path.length > 0 ? props.path : void 0,
 		columnQualifications: Array.isArray(props.columnQualifications) && props.columnQualifications.length > 0 ? props.columnQualifications : void 0,
 		queriesQualifications: props.queriesQualifications && Object.keys(props.queriesQualifications).length > 0 ? props.queriesQualifications : void 0
 	};
 }
-function createDiscoveredPColumnId(props) {
-	return stringifyDiscoveredPColumnId(props);
+function createColumnDiscoveredId(props) {
+	return stringifyColumnDiscoveredId(props);
+}
+function createColumnDiscoveredKey(props) {
+	return distillColumnDiscoveredKey({
+		__isDiscovered: true,
+		...props
+	});
 }
-function parseDiscoveredPColumnId(id) {
+function parseColumnDiscoveredId(id) {
 	try {
 		const parsed = JSON.parse(id);
-		return isDiscoveredPColumn(parsed) ? parsed : (0, _milaboratories_helpers.throwError)("Parsed object is not a valid DiscoveredPColumn");
+		return isColumnDiscoveredKey(parsed) ? parsed : (0, _milaboratories_helpers.throwError)("Parsed object is not a valid DiscoveredPColumn");
 	} catch {
-		throw new Error("Invalid DiscoveredPColumnId: not a valid JSON or does not conform to DiscoveredPColumn structure");
+		throw new Error("Invalid ColumnDiscoveredId: not a valid JSON or does not conform to DiscoveredPColumn structure");
 	}
 }
-function stringifyDiscoveredPColumnId(id) {
-	return require_json.canonicalizeJson(distillDiscoveredPColumn(id));
+function stringifyColumnDiscoveredId(id) {
+	return require_json.canonicalizeJson(distillColumnDiscoveredKey({
+		__isDiscovered: true,
+		...id
+	}));
 }
 //#endregion
-exports.createDiscoveredPColumnId = createDiscoveredPColumnId;
-exports.distillDiscoveredPColumn = distillDiscoveredPColumn;
-exports.isDiscoveredPColumn = isDiscoveredPColumn;
-exports.parseDiscoveredPColumnId = parseDiscoveredPColumnId;
-exports.stringifyDiscoveredPColumnId = stringifyDiscoveredPColumnId;
+exports.createColumnDiscoveredId = createColumnDiscoveredId;
+exports.createColumnDiscoveredKey = createColumnDiscoveredKey;
+exports.distillColumnDiscoveredKey = distillColumnDiscoveredKey;
+exports.isColumnDiscoveredId = isColumnDiscoveredId;
+exports.isColumnDiscoveredKey = isColumnDiscoveredKey;
+exports.parseColumnDiscoveredId = parseColumnDiscoveredId;
+exports.stringifyColumnDiscoveredId = stringifyColumnDiscoveredId;
 
 //# sourceMappingURL=discovered_column.cjs.map

package/dist/drivers/pframe/spec/discovered_column.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"discovered_column.cjs","names":["canonicalizeJson"],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"sourcesContent":["import { Branded, throwError } from \"@milaboratories/helpers\";\nimport { PObjectId } from \"../../../pool\";\nimport { AxisQualification } from \"./selectors\";\nimport { canonicalizeJson } from \"../../../json\";\n\nexport type DiscoveredPColumn = {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n};\n\nexport type DiscoveredPColumnId = Branded<PObjectId, \"DiscoveredPColumnId\">; // CanonicalizedJson<DiscoveredPColumn>;\n\ntype PathItem = {\n  type: \"linker\";\n  column: PObjectId;\n};\n\nexport function isDiscoveredPColumn(obj: unknown): obj is DiscoveredPColumn {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"path\" in obj &&\n    \"column\" in obj &&\n    \"columnQualifications\" in obj &&\n    \"queriesQualifications\" in obj\n  );\n}\n\nexport function distillDiscoveredPColumn(props: DiscoveredPColumn): DiscoveredPColumn {\n  return {\n    column: props.column,\n    path: Array.isArray(props.path) && props.path.length > 0 ? props.path : undefined,\n    columnQualifications:\n      Array.isArray(props.columnQualifications) && props.columnQualifications.length > 0\n        ? props.columnQualifications\n        : undefined,\n    queriesQualifications:\n      props.queriesQualifications && Object.keys(props.queriesQualifications).length > 0\n        ? props.queriesQualifications\n        : undefined,\n  };\n}\n\nexport function createDiscoveredPColumnId(props: {\n  column: PObjectId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n}): DiscoveredPColumnId {\n  return stringifyDiscoveredPColumnId(props);\n}\n\nexport function parseDiscoveredPColumnId(id: DiscoveredPColumnId): DiscoveredPColumn {\n  try {\n    const parsed = JSON.parse(id);\n    return isDiscoveredPColumn(parsed)\n      ? parsed\n      : throwError(\"Parsed object is not a valid DiscoveredPColumn\");\n  } catch {\n    throw new Error(\n      \"Invalid DiscoveredPColumnId: not a valid JSON or does not conform to DiscoveredPColumn structure\",\n    );\n  }\n}\n\nexport function stringifyDiscoveredPColumnId(id: DiscoveredPColumn) {\n  return canonicalizeJson<DiscoveredPColumn>(\n    distillDiscoveredPColumn(id),\n  ) as string as DiscoveredPColumnId;\n}\n"],"mappings":";;;AAmBA,SAAgB,oBAAoB,KAAwC;CAC1E,OACE,OAAO,QAAQ,YACf,QAAQ,QACR,UAAU,OACV,YAAY,OACZ,0BAA0B,OAC1B,2BAA2B;AAE/B;AAEA,SAAgB,yBAAyB,OAA6C;CACpF,OAAO;EACL,QAAQ,MAAM;EACd,MAAM,MAAM,QAAQ,MAAM,IAAI,KAAK,MAAM,KAAK,SAAS,IAAI,MAAM,OAAO,KAAA;EACxE,sBACE,MAAM,QAAQ,MAAM,oBAAoB,KAAK,MAAM,qBAAqB,SAAS,IAC7E,MAAM,uBACN,KAAA;EACN,uBACE,MAAM,yBAAyB,OAAO,KAAK,MAAM,qBAAqB,CAAC,CAAC,SAAS,IAC7E,MAAM,wBACN,KAAA;CACR;AACF;AAEA,SAAgB,0BAA0B,OAKlB;CACtB,OAAO,6BAA6B,KAAK;AAC3C;AAEA,SAAgB,yBAAyB,IAA4C;CACnF,IAAI;EACF,MAAM,SAAS,KAAK,MAAM,EAAE;EAC5B,OAAO,oBAAoB,MAAM,IAC7B,UAAA,GAAA,wBAAA,WAAA,CACW,gDAAgD;CACjE,QAAQ;EACN,MAAM,IAAI,MACR,kGACF;CACF;AACF;AAEA,SAAgB,6BAA6B,IAAuB;CAClE,OAAOA,aAAAA,iBACL,yBAAyB,EAAE,CAC7B;AACF"}
+{"version":3,"file":"discovered_column.cjs","names":["parseJsonSafely","canonicalizeJson"],"sources":["../../../../src/drivers/pframe/spec/discovered_column.ts"],"sourcesContent":["import { type Branded, throwError } from \"@milaboratories/helpers\";\nimport { type CanonicalizedJson, canonicalizeJson, parseJsonSafely } from \"../../../json\";\nimport { PObjectId } from \"../../../pool\";\nimport { AxisQualification } from \"./selectors\";\nimport { ColumnUniversalId } from \"./ids\";\n\nexport interface ColumnDiscoveredKey {\n  __isDiscovered: true;\n  column: ColumnUniversalId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n}\n\nexport type ColumnDiscoveredId = Branded<\n  CanonicalizedJson<ColumnDiscoveredKey>,\n  \"ColumnDiscoveredId\"\n>;\n\ntype PathItem = {\n  type: \"linker\";\n  column: ColumnUniversalId;\n};\n\nexport function isColumnDiscoveredKey(obj: unknown): obj is ColumnDiscoveredKey {\n  return typeof obj === \"object\" && obj !== null && \"__isDiscovered\" in obj;\n}\n\nexport function isColumnDiscoveredId(str: unknown): str is ColumnDiscoveredId {\n  if (typeof str !== \"string\") return false;\n  return isColumnDiscoveredKey(parseJsonSafely(str));\n}\n\nexport function distillColumnDiscoveredKey(props: ColumnDiscoveredKey): ColumnDiscoveredKey {\n  return {\n    __isDiscovered: true,\n    column: props.column,\n    path: Array.isArray(props.path) && props.path.length > 0 ? props.path : undefined,\n    columnQualifications:\n      Array.isArray(props.columnQualifications) && props.columnQualifications.length > 0\n        ? props.columnQualifications\n        : undefined,\n    queriesQualifications:\n      props.queriesQualifications && Object.keys(props.queriesQualifications).length > 0\n        ? props.queriesQualifications\n        : undefined,\n  };\n}\n\nexport function createColumnDiscoveredId(props: {\n  column: ColumnUniversalId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n}): ColumnDiscoveredId {\n  return stringifyColumnDiscoveredId(props);\n}\n\nexport function createColumnDiscoveredKey(props: {\n  column: ColumnUniversalId;\n  path?: PathItem[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n}): ColumnDiscoveredKey {\n  return distillColumnDiscoveredKey({ __isDiscovered: true, ...props });\n}\n\nexport function parseColumnDiscoveredId(id: ColumnDiscoveredId): ColumnDiscoveredKey {\n  try {\n    const parsed = JSON.parse(id);\n    return isColumnDiscoveredKey(parsed)\n      ? parsed\n      : throwError(\"Parsed object is not a valid DiscoveredPColumn\");\n  } catch {\n    throw new Error(\n      \"Invalid ColumnDiscoveredId: not a valid JSON or does not conform to DiscoveredPColumn structure\",\n    );\n  }\n}\n\nexport function stringifyColumnDiscoveredId(\n  id: Omit<ColumnDiscoveredKey, \"__isDiscovered\">,\n): ColumnDiscoveredId {\n  return canonicalizeJson<ColumnDiscoveredKey>(\n    distillColumnDiscoveredKey({ __isDiscovered: true, ...id }),\n  ) as ColumnDiscoveredId;\n}\n"],"mappings":";;;AAwBA,SAAgB,sBAAsB,KAA0C;CAC9E,OAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,oBAAoB;AACxE;AAEA,SAAgB,qBAAqB,KAAyC;CAC5E,IAAI,OAAO,QAAQ,UAAU,OAAO;CACpC,OAAO,sBAAsBA,aAAAA,gBAAgB,GAAG,CAAC;AACnD;AAEA,SAAgB,2BAA2B,OAAiD;CAC1F,OAAO;EACL,gBAAgB;EAChB,QAAQ,MAAM;EACd,MAAM,MAAM,QAAQ,MAAM,IAAI,KAAK,MAAM,KAAK,SAAS,IAAI,MAAM,OAAO,KAAA;EACxE,sBACE,MAAM,QAAQ,MAAM,oBAAoB,KAAK,MAAM,qBAAqB,SAAS,IAC7E,MAAM,uBACN,KAAA;EACN,uBACE,MAAM,yBAAyB,OAAO,KAAK,MAAM,qBAAqB,CAAC,CAAC,SAAS,IAC7E,MAAM,wBACN,KAAA;CACR;AACF;AAEA,SAAgB,yBAAyB,OAKlB;CACrB,OAAO,4BAA4B,KAAK;AAC1C;AAEA,SAAgB,0BAA0B,OAKlB;CACtB,OAAO,2BAA2B;EAAE,gBAAgB;EAAM,GAAG;CAAM,CAAC;AACtE;AAEA,SAAgB,wBAAwB,IAA6C;CACnF,IAAI;EACF,MAAM,SAAS,KAAK,MAAM,EAAE;EAC5B,OAAO,sBAAsB,MAAM,IAC/B,UAAA,GAAA,wBAAA,WAAA,CACW,gDAAgD;CACjE,QAAQ;EACN,MAAM,IAAI,MACR,iGACF;CACF;AACF;AAEA,SAAgB,4BACd,IACoB;CACpB,OAAOC,aAAAA,iBACL,2BAA2B;EAAE,gBAAgB;EAAM,GAAG;CAAG,CAAC,CAC5D;AACF"}

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

@@ -1,29 +1,39 @@
+import { CanonicalizedJson } from "../../../json.js";
+import { ColumnUniversalId } from "./ids.js";
 import { AxisQualification } from "./selectors.js";
 import { PObjectId } from "../../../pool/spec.js";
 import { Branded } from "@milaboratories/helpers";
 
 //#region src/drivers/pframe/spec/discovered_column.d.ts
-type DiscoveredPColumn = {
-  column: PObjectId;
+interface ColumnDiscoveredKey {
+  __isDiscovered: true;
+  column: ColumnUniversalId;
   path?: PathItem[];
   columnQualifications?: AxisQualification[];
   queriesQualifications?: Record<PObjectId, AxisQualification[]>;
-};
-type DiscoveredPColumnId = Branded<PObjectId, "DiscoveredPColumnId">;
+}
+type ColumnDiscoveredId = Branded<CanonicalizedJson<ColumnDiscoveredKey>, "ColumnDiscoveredId">;
 type PathItem = {
   type: "linker";
-  column: PObjectId;
+  column: ColumnUniversalId;
 };
-declare function isDiscoveredPColumn(obj: unknown): obj is DiscoveredPColumn;
-declare function distillDiscoveredPColumn(props: DiscoveredPColumn): DiscoveredPColumn;
-declare function createDiscoveredPColumnId(props: {
-  column: PObjectId;
+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: {
+  column: ColumnUniversalId;
+  path?: PathItem[];
+  columnQualifications?: AxisQualification[];
+  queriesQualifications?: Record<PObjectId, AxisQualification[]>;
+}): ColumnDiscoveredId;
+declare function createColumnDiscoveredKey(props: {
+  column: ColumnUniversalId;
   path?: PathItem[];
   columnQualifications?: AxisQualification[];
   queriesQualifications?: Record<PObjectId, AxisQualification[]>;
-}): DiscoveredPColumnId;
-declare function parseDiscoveredPColumnId(id: DiscoveredPColumnId): DiscoveredPColumn;
-declare function stringifyDiscoveredPColumnId(id: DiscoveredPColumn): DiscoveredPColumnId;
+}): ColumnDiscoveredKey;
+declare function parseColumnDiscoveredId(id: ColumnDiscoveredId): ColumnDiscoveredKey;
+declare function stringifyColumnDiscoveredId(id: Omit<ColumnDiscoveredKey, "__isDiscovered">): ColumnDiscoveredId;
 //#endregion
-export { DiscoveredPColumn, DiscoveredPColumnId, createDiscoveredPColumnId, distillDiscoveredPColumn, isDiscoveredPColumn, parseDiscoveredPColumnId, stringifyDiscoveredPColumnId };
+export { ColumnDiscoveredId, ColumnDiscoveredKey, createColumnDiscoveredId, createColumnDiscoveredKey, distillColumnDiscoveredKey, isColumnDiscoveredId, isColumnDiscoveredKey, parseColumnDiscoveredId, stringifyColumnDiscoveredId };
 //# sourceMappingURL=discovered_column.d.ts.map