@milaboratories/pl-model-common 1.25.2 → 1.26.0

package/dist/pool/query.cjs

@@ -17,7 +17,7 @@ function executePSpecPredicate(predicate, spec) {
 		case "name_pattern": return require_spec.isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));
 		case "annotation": return require_spec.isPColumnSpec(spec) && spec.annotations !== void 0 && spec.annotations[predicate.annotation] === predicate.value;
 		case "annotation_pattern": return require_spec.isPColumnSpec(spec) && spec.annotations !== void 0 && spec.annotations[predicate.annotation] !== void 0 && Boolean(spec.annotations[predicate.annotation].match(predicate.pattern));
-		case "has_axes": return require_spec.isPColumnSpec(spec) && predicate.axes.every((matcher) => spec.axesSpec.some((axisSpec) => (matcher.type === void 0 || matcher.type === axisSpec.type) && (matcher.name === void 0 || matcher.name === axisSpec.name) && (matcher.domain === void 0 || Object.keys(matcher.domain).length === 0 || axisSpec.domain !== void 0 && Object.entries(matcher.domain).every(([domain, domainValue]) => axisSpec.domain[domain] === domainValue))));
+		case "has_axes": return require_spec.isPColumnSpec(spec) && predicate.axes.every((matcher) => spec.axesSpec.some((axisSpec) => (matcher.type === void 0 || matcher.type === axisSpec.type) && (matcher.name === void 0 || matcher.name === axisSpec.name) && (matcher.domain === void 0 || Object.keys(matcher.domain).length === 0 || axisSpec.domain !== void 0 && Object.entries(matcher.domain).every(([domain, domainValue]) => axisSpec.domain[domain] === domainValue)) && (matcher.contextDomain === void 0 || Object.keys(matcher.contextDomain).length === 0 || axisSpec.contextDomain !== void 0 && Object.entries(matcher.contextDomain).every(([key, value]) => axisSpec.contextDomain[key] === value))));
 		default: assertNever(predicate);
 	}
 }

package/dist/pool/query.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"query.cjs","names":["isPColumnSpec"],"sources":["../../src/pool/query.ts"],"sourcesContent":["import type { AxisId } from \"../drivers\";\nimport type { PObjectSpec } from \"./spec\";\nimport { isPColumnSpec } from \"./spec\";\n\nexport type PSpecPredicate =\n  | {\n      type: \"and\" | \"or\";\n      operands: PSpecPredicate[];\n    }\n  | {\n      type: \"not\";\n      operand: PSpecPredicate;\n    }\n  | {\n      type: \"name\";\n      name: string;\n    }\n  | {\n      type: \"name_pattern\";\n      pattern: string;\n    }\n  | {\n      type: \"annotation\";\n      annotation: string;\n      value: string;\n    }\n  | {\n      type: \"annotation_pattern\";\n      annotation: string;\n      pattern: string;\n    }\n  | {\n      type: \"has_axes\";\n      axes: Partial<AxisId>[];\n    };\n\nfunction assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x); // This is ok, because this is a possible runtime error\n}\n\nexport function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean {\n  switch (predicate.type) {\n    case \"and\":\n      for (const operator of predicate.operands)\n        if (!executePSpecPredicate(operator, spec)) return false;\n      return true;\n    case \"or\":\n      for (const operator of predicate.operands)\n        if (executePSpecPredicate(operator, spec)) return true;\n      return false;\n    case \"not\":\n      return !executePSpecPredicate(predicate.operand, spec);\n    case \"name\":\n      return isPColumnSpec(spec) && spec.name === predicate.name;\n    case \"name_pattern\":\n      return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));\n    case \"annotation\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] === predicate.value\n      );\n    case \"annotation_pattern\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] !== undefined &&\n        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))\n      );\n    case \"has_axes\":\n      return (\n        isPColumnSpec(spec) &&\n        predicate.axes.every((matcher) =>\n          spec.axesSpec.some(\n            (axisSpec) =>\n              (matcher.type === undefined || matcher.type === axisSpec.type) &&\n              (matcher.name === undefined || matcher.name === axisSpec.name) &&\n              (matcher.domain === undefined ||\n                Object.keys(matcher.domain).length === 0 ||\n                (axisSpec.domain !== undefined &&\n                  Object.entries(matcher.domain).every(\n                    ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,\n                  ))),\n          ),\n        )\n      );\n    default:\n      assertNever(predicate);\n  }\n}\n"],"mappings":";;;AAoCA,SAAS,YAAY,GAAiB;AACpC,OAAM,IAAI,MAAM,wBAAwB,EAAE;;AAG5C,SAAgB,sBAAsB,WAA2B,MAA4B;AAC3F,SAAQ,UAAU,MAAlB;EACE,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,CAAC,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACrD,UAAO;EACT,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACpD,UAAO;EACT,KAAK,MACH,QAAO,CAAC,sBAAsB,UAAU,SAAS,KAAK;EACxD,KAAK,OACH,QAAOA,2BAAc,KAAK,IAAI,KAAK,SAAS,UAAU;EACxD,KAAK,eACH,QAAOA,2BAAc,KAAK,IAAI,QAAQ,KAAK,KAAK,MAAM,UAAU,QAAQ,CAAC;EAC3E,KAAK,aACH,QACEA,2BAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAAU;EAEzD,KAAK,qBACH,QACEA,2BAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAC3C,QAAQ,KAAK,YAAY,UAAU,YAAY,MAAM,UAAU,QAAQ,CAAC;EAE5E,KAAK,WACH,QACEA,2BAAc,KAAK,IACnB,UAAU,KAAK,OAAO,YACpB,KAAK,SAAS,MACX,cACE,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,WAAW,UAClB,OAAO,KAAK,QAAQ,OAAO,CAAC,WAAW,KACtC,SAAS,WAAW,UACnB,OAAO,QAAQ,QAAQ,OAAO,CAAC,OAC5B,CAAC,QAAQ,iBAAiB,SAAS,OAAQ,YAAY,YACzD,EACR,CACF;EAEL,QACE,aAAY,UAAU"}
+{"version":3,"file":"query.cjs","names":["isPColumnSpec"],"sources":["../../src/pool/query.ts"],"sourcesContent":["import type { AxisId } from \"../drivers\";\nimport type { PObjectSpec } from \"./spec\";\nimport { isPColumnSpec } from \"./spec\";\n\nexport type PSpecPredicate =\n  | {\n      type: \"and\" | \"or\";\n      operands: PSpecPredicate[];\n    }\n  | {\n      type: \"not\";\n      operand: PSpecPredicate;\n    }\n  | {\n      type: \"name\";\n      name: string;\n    }\n  | {\n      type: \"name_pattern\";\n      pattern: string;\n    }\n  | {\n      type: \"annotation\";\n      annotation: string;\n      value: string;\n    }\n  | {\n      type: \"annotation_pattern\";\n      annotation: string;\n      pattern: string;\n    }\n  | {\n      type: \"has_axes\";\n      axes: Partial<AxisId>[];\n    };\n\nfunction assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x); // This is ok, because this is a possible runtime error\n}\n\nexport function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean {\n  switch (predicate.type) {\n    case \"and\":\n      for (const operator of predicate.operands)\n        if (!executePSpecPredicate(operator, spec)) return false;\n      return true;\n    case \"or\":\n      for (const operator of predicate.operands)\n        if (executePSpecPredicate(operator, spec)) return true;\n      return false;\n    case \"not\":\n      return !executePSpecPredicate(predicate.operand, spec);\n    case \"name\":\n      return isPColumnSpec(spec) && spec.name === predicate.name;\n    case \"name_pattern\":\n      return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));\n    case \"annotation\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] === predicate.value\n      );\n    case \"annotation_pattern\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] !== undefined &&\n        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))\n      );\n    case \"has_axes\":\n      return (\n        isPColumnSpec(spec) &&\n        predicate.axes.every((matcher) =>\n          spec.axesSpec.some(\n            (axisSpec) =>\n              (matcher.type === undefined || matcher.type === axisSpec.type) &&\n              (matcher.name === undefined || matcher.name === axisSpec.name) &&\n              (matcher.domain === undefined ||\n                Object.keys(matcher.domain).length === 0 ||\n                (axisSpec.domain !== undefined &&\n                  Object.entries(matcher.domain).every(\n                    ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,\n                  ))) &&\n              (matcher.contextDomain === undefined ||\n                Object.keys(matcher.contextDomain).length === 0 ||\n                (axisSpec.contextDomain !== undefined &&\n                  Object.entries(matcher.contextDomain).every(\n                    ([key, value]) => axisSpec.contextDomain![key] === value,\n                  ))),\n          ),\n        )\n      );\n    default:\n      assertNever(predicate);\n  }\n}\n"],"mappings":";;;AAoCA,SAAS,YAAY,GAAiB;AACpC,OAAM,IAAI,MAAM,wBAAwB,EAAE;;AAG5C,SAAgB,sBAAsB,WAA2B,MAA4B;AAC3F,SAAQ,UAAU,MAAlB;EACE,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,CAAC,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACrD,UAAO;EACT,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACpD,UAAO;EACT,KAAK,MACH,QAAO,CAAC,sBAAsB,UAAU,SAAS,KAAK;EACxD,KAAK,OACH,QAAOA,2BAAc,KAAK,IAAI,KAAK,SAAS,UAAU;EACxD,KAAK,eACH,QAAOA,2BAAc,KAAK,IAAI,QAAQ,KAAK,KAAK,MAAM,UAAU,QAAQ,CAAC;EAC3E,KAAK,aACH,QACEA,2BAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAAU;EAEzD,KAAK,qBACH,QACEA,2BAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAC3C,QAAQ,KAAK,YAAY,UAAU,YAAY,MAAM,UAAU,QAAQ,CAAC;EAE5E,KAAK,WACH,QACEA,2BAAc,KAAK,IACnB,UAAU,KAAK,OAAO,YACpB,KAAK,SAAS,MACX,cACE,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,WAAW,UAClB,OAAO,KAAK,QAAQ,OAAO,CAAC,WAAW,KACtC,SAAS,WAAW,UACnB,OAAO,QAAQ,QAAQ,OAAO,CAAC,OAC5B,CAAC,QAAQ,iBAAiB,SAAS,OAAQ,YAAY,YACzD,MACJ,QAAQ,kBAAkB,UACzB,OAAO,KAAK,QAAQ,cAAc,CAAC,WAAW,KAC7C,SAAS,kBAAkB,UAC1B,OAAO,QAAQ,QAAQ,cAAc,CAAC,OACnC,CAAC,KAAK,WAAW,SAAS,cAAe,SAAS,MACpD,EACR,CACF;EAEL,QACE,aAAY,UAAU"}

package/dist/pool/query.js

@@ -17,7 +17,7 @@ function executePSpecPredicate(predicate, spec) {
 		case "name_pattern": return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));
 		case "annotation": return isPColumnSpec(spec) && spec.annotations !== void 0 && spec.annotations[predicate.annotation] === predicate.value;
 		case "annotation_pattern": return isPColumnSpec(spec) && spec.annotations !== void 0 && spec.annotations[predicate.annotation] !== void 0 && Boolean(spec.annotations[predicate.annotation].match(predicate.pattern));
-		case "has_axes": return isPColumnSpec(spec) && predicate.axes.every((matcher) => spec.axesSpec.some((axisSpec) => (matcher.type === void 0 || matcher.type === axisSpec.type) && (matcher.name === void 0 || matcher.name === axisSpec.name) && (matcher.domain === void 0 || Object.keys(matcher.domain).length === 0 || axisSpec.domain !== void 0 && Object.entries(matcher.domain).every(([domain, domainValue]) => axisSpec.domain[domain] === domainValue))));
+		case "has_axes": return isPColumnSpec(spec) && predicate.axes.every((matcher) => spec.axesSpec.some((axisSpec) => (matcher.type === void 0 || matcher.type === axisSpec.type) && (matcher.name === void 0 || matcher.name === axisSpec.name) && (matcher.domain === void 0 || Object.keys(matcher.domain).length === 0 || axisSpec.domain !== void 0 && Object.entries(matcher.domain).every(([domain, domainValue]) => axisSpec.domain[domain] === domainValue)) && (matcher.contextDomain === void 0 || Object.keys(matcher.contextDomain).length === 0 || axisSpec.contextDomain !== void 0 && Object.entries(matcher.contextDomain).every(([key, value]) => axisSpec.contextDomain[key] === value))));
 		default: assertNever(predicate);
 	}
 }

package/dist/pool/query.js.map

@@ -1 +1 @@
-{"version":3,"file":"query.js","names":[],"sources":["../../src/pool/query.ts"],"sourcesContent":["import type { AxisId } from \"../drivers\";\nimport type { PObjectSpec } from \"./spec\";\nimport { isPColumnSpec } from \"./spec\";\n\nexport type PSpecPredicate =\n  | {\n      type: \"and\" | \"or\";\n      operands: PSpecPredicate[];\n    }\n  | {\n      type: \"not\";\n      operand: PSpecPredicate;\n    }\n  | {\n      type: \"name\";\n      name: string;\n    }\n  | {\n      type: \"name_pattern\";\n      pattern: string;\n    }\n  | {\n      type: \"annotation\";\n      annotation: string;\n      value: string;\n    }\n  | {\n      type: \"annotation_pattern\";\n      annotation: string;\n      pattern: string;\n    }\n  | {\n      type: \"has_axes\";\n      axes: Partial<AxisId>[];\n    };\n\nfunction assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x); // This is ok, because this is a possible runtime error\n}\n\nexport function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean {\n  switch (predicate.type) {\n    case \"and\":\n      for (const operator of predicate.operands)\n        if (!executePSpecPredicate(operator, spec)) return false;\n      return true;\n    case \"or\":\n      for (const operator of predicate.operands)\n        if (executePSpecPredicate(operator, spec)) return true;\n      return false;\n    case \"not\":\n      return !executePSpecPredicate(predicate.operand, spec);\n    case \"name\":\n      return isPColumnSpec(spec) && spec.name === predicate.name;\n    case \"name_pattern\":\n      return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));\n    case \"annotation\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] === predicate.value\n      );\n    case \"annotation_pattern\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] !== undefined &&\n        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))\n      );\n    case \"has_axes\":\n      return (\n        isPColumnSpec(spec) &&\n        predicate.axes.every((matcher) =>\n          spec.axesSpec.some(\n            (axisSpec) =>\n              (matcher.type === undefined || matcher.type === axisSpec.type) &&\n              (matcher.name === undefined || matcher.name === axisSpec.name) &&\n              (matcher.domain === undefined ||\n                Object.keys(matcher.domain).length === 0 ||\n                (axisSpec.domain !== undefined &&\n                  Object.entries(matcher.domain).every(\n                    ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,\n                  ))),\n          ),\n        )\n      );\n    default:\n      assertNever(predicate);\n  }\n}\n"],"mappings":";;;AAoCA,SAAS,YAAY,GAAiB;AACpC,OAAM,IAAI,MAAM,wBAAwB,EAAE;;AAG5C,SAAgB,sBAAsB,WAA2B,MAA4B;AAC3F,SAAQ,UAAU,MAAlB;EACE,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,CAAC,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACrD,UAAO;EACT,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACpD,UAAO;EACT,KAAK,MACH,QAAO,CAAC,sBAAsB,UAAU,SAAS,KAAK;EACxD,KAAK,OACH,QAAO,cAAc,KAAK,IAAI,KAAK,SAAS,UAAU;EACxD,KAAK,eACH,QAAO,cAAc,KAAK,IAAI,QAAQ,KAAK,KAAK,MAAM,UAAU,QAAQ,CAAC;EAC3E,KAAK,aACH,QACE,cAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAAU;EAEzD,KAAK,qBACH,QACE,cAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAC3C,QAAQ,KAAK,YAAY,UAAU,YAAY,MAAM,UAAU,QAAQ,CAAC;EAE5E,KAAK,WACH,QACE,cAAc,KAAK,IACnB,UAAU,KAAK,OAAO,YACpB,KAAK,SAAS,MACX,cACE,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,WAAW,UAClB,OAAO,KAAK,QAAQ,OAAO,CAAC,WAAW,KACtC,SAAS,WAAW,UACnB,OAAO,QAAQ,QAAQ,OAAO,CAAC,OAC5B,CAAC,QAAQ,iBAAiB,SAAS,OAAQ,YAAY,YACzD,EACR,CACF;EAEL,QACE,aAAY,UAAU"}
+{"version":3,"file":"query.js","names":[],"sources":["../../src/pool/query.ts"],"sourcesContent":["import type { AxisId } from \"../drivers\";\nimport type { PObjectSpec } from \"./spec\";\nimport { isPColumnSpec } from \"./spec\";\n\nexport type PSpecPredicate =\n  | {\n      type: \"and\" | \"or\";\n      operands: PSpecPredicate[];\n    }\n  | {\n      type: \"not\";\n      operand: PSpecPredicate;\n    }\n  | {\n      type: \"name\";\n      name: string;\n    }\n  | {\n      type: \"name_pattern\";\n      pattern: string;\n    }\n  | {\n      type: \"annotation\";\n      annotation: string;\n      value: string;\n    }\n  | {\n      type: \"annotation_pattern\";\n      annotation: string;\n      pattern: string;\n    }\n  | {\n      type: \"has_axes\";\n      axes: Partial<AxisId>[];\n    };\n\nfunction assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x); // This is ok, because this is a possible runtime error\n}\n\nexport function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean {\n  switch (predicate.type) {\n    case \"and\":\n      for (const operator of predicate.operands)\n        if (!executePSpecPredicate(operator, spec)) return false;\n      return true;\n    case \"or\":\n      for (const operator of predicate.operands)\n        if (executePSpecPredicate(operator, spec)) return true;\n      return false;\n    case \"not\":\n      return !executePSpecPredicate(predicate.operand, spec);\n    case \"name\":\n      return isPColumnSpec(spec) && spec.name === predicate.name;\n    case \"name_pattern\":\n      return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));\n    case \"annotation\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] === predicate.value\n      );\n    case \"annotation_pattern\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] !== undefined &&\n        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))\n      );\n    case \"has_axes\":\n      return (\n        isPColumnSpec(spec) &&\n        predicate.axes.every((matcher) =>\n          spec.axesSpec.some(\n            (axisSpec) =>\n              (matcher.type === undefined || matcher.type === axisSpec.type) &&\n              (matcher.name === undefined || matcher.name === axisSpec.name) &&\n              (matcher.domain === undefined ||\n                Object.keys(matcher.domain).length === 0 ||\n                (axisSpec.domain !== undefined &&\n                  Object.entries(matcher.domain).every(\n                    ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,\n                  ))) &&\n              (matcher.contextDomain === undefined ||\n                Object.keys(matcher.contextDomain).length === 0 ||\n                (axisSpec.contextDomain !== undefined &&\n                  Object.entries(matcher.contextDomain).every(\n                    ([key, value]) => axisSpec.contextDomain![key] === value,\n                  ))),\n          ),\n        )\n      );\n    default:\n      assertNever(predicate);\n  }\n}\n"],"mappings":";;;AAoCA,SAAS,YAAY,GAAiB;AACpC,OAAM,IAAI,MAAM,wBAAwB,EAAE;;AAG5C,SAAgB,sBAAsB,WAA2B,MAA4B;AAC3F,SAAQ,UAAU,MAAlB;EACE,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,CAAC,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACrD,UAAO;EACT,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACpD,UAAO;EACT,KAAK,MACH,QAAO,CAAC,sBAAsB,UAAU,SAAS,KAAK;EACxD,KAAK,OACH,QAAO,cAAc,KAAK,IAAI,KAAK,SAAS,UAAU;EACxD,KAAK,eACH,QAAO,cAAc,KAAK,IAAI,QAAQ,KAAK,KAAK,MAAM,UAAU,QAAQ,CAAC;EAC3E,KAAK,aACH,QACE,cAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAAU;EAEzD,KAAK,qBACH,QACE,cAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAC3C,QAAQ,KAAK,YAAY,UAAU,YAAY,MAAM,UAAU,QAAQ,CAAC;EAE5E,KAAK,WACH,QACE,cAAc,KAAK,IACnB,UAAU,KAAK,OAAO,YACpB,KAAK,SAAS,MACX,cACE,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,WAAW,UAClB,OAAO,KAAK,QAAQ,OAAO,CAAC,WAAW,KACtC,SAAS,WAAW,UACnB,OAAO,QAAQ,QAAQ,OAAO,CAAC,OAC5B,CAAC,QAAQ,iBAAiB,SAAS,OAAQ,YAAY,YACzD,MACJ,QAAQ,kBAAkB,UACzB,OAAO,KAAK,QAAQ,cAAc,CAAC,WAAW,KAC7C,SAAS,kBAAkB,UAC1B,OAAO,QAAQ,QAAQ,cAAc,CAAC,OACnC,CAAC,KAAK,WAAW,SAAS,cAAe,SAAS,MACpD,EACR,CACF;EAEL,QACE,aAAY,UAAU"}

package/dist/pool/spec.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"spec.cjs","names":[],"sources":["../../src/pool/spec.ts"],"sourcesContent":["import type { Branded } from \"../branding\";\nimport type { JoinEntry, PColumn, PColumnLazy, PColumnSpec } from \"../drivers\";\nimport { assertNever } from \"../util\";\nimport type { ResultPoolEntry } from \"./entry\";\n\n/** Any object exported into the result pool by the block always have spec attached to it */\nexport type PObjectSpec = {\n  /** PObject kind discriminator */\n  readonly kind: string;\n\n  /** Name is common part of PObject identity */\n  readonly name: string;\n\n  /** Domain is a set of key-value pairs that can be used to identify the object */\n  readonly domain?: Record<string, string>;\n\n  /** Additional information attached to the object */\n  readonly annotations?: Record<string, string>;\n};\n\n/** Stable PObject id */\nexport type PObjectId = Branded<string, \"PColumnId\">;\n\n/**\n * Full PObject representation.\n *\n * @template Data type of the object referencing or describing the \"data\" part of the PObject\n * */\nexport interface PObject<Data> {\n  /** Fully rendered PObjects are assigned a stable identifier. */\n  readonly id: PObjectId;\n\n  /** PObject spec, allowing it to be found among other PObjects */\n  readonly spec: PObjectSpec;\n\n  /** A handle to data object */\n  readonly data: Data;\n}\n\nexport function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec {\n  return spec.kind === \"PColumn\";\n}\n\nexport function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {\n  return isPColumnSpec(obj.spec);\n}\n\nexport function isPColumnSpecResult(\n  r: ResultPoolEntry<PObjectSpec>,\n): r is ResultPoolEntry<PColumnSpec> {\n  return isPColumnSpec(r.obj);\n}\n\nexport function isPColumnResult<T>(\n  r: ResultPoolEntry<PObject<T>>,\n): r is ResultPoolEntry<PColumn<T>> {\n  return isPColumnSpec(r.obj.spec);\n}\n\nexport function ensurePColumn<T>(obj: PObject<T>): PColumn<T> {\n  if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);\n  return obj;\n}\n\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | PColumnLazy<D1>,\n  cb: (d: D1) => D2,\n): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | undefined,\n  cb: (d: D1) => D2,\n): PColumn<D2> | undefined;\nexport function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined {\n  return pObj === undefined\n    ? undefined\n    : {\n        ...pObj,\n        data: cb(typeof pObj.data === \"function\" ? pObj.data() : pObj.data),\n      };\n}\n\nexport function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[] {\n  const columns = new Map<PObjectId, PColumn<D>>();\n  const addAllColumns = (entry: JoinEntry<PColumn<D>>) => {\n    switch (entry.type) {\n      case \"column\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"slicedColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"artificialColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"inlineColumn\":\n        return;\n      case \"full\":\n      case \"inner\":\n        for (const e of entry.entries) addAllColumns(e);\n        return;\n      case \"outer\":\n        addAllColumns(entry.primary);\n        for (const e of entry.secondary) addAllColumns(e);\n        return;\n      default:\n        assertNever(entry);\n    }\n  };\n  addAllColumns(entry);\n  return [...columns.values()];\n}\n"],"mappings":";;;AAuCA,SAAgB,cAAc,MAAwC;AACpE,QAAO,KAAK,SAAS;;AAGvB,SAAgB,UAAa,KAAoC;AAC/D,QAAO,cAAc,IAAI,KAAK;;AAGhC,SAAgB,oBACd,GACmC;AACnC,QAAO,cAAc,EAAE,IAAI;;AAG7B,SAAgB,gBACd,GACkC;AAClC,QAAO,cAAc,EAAE,IAAI,KAAK;;AAGlC,SAAgB,cAAiB,KAA6B;AAC5D,KAAI,CAAC,UAAU,IAAI,CAAE,OAAM,IAAI,MAAM,yBAAyB,IAAI,KAAK,KAAK,GAAG;AAC/E,QAAO;;AAiBT,SAAgB,eACd,MACA,IACyB;AACzB,QAAO,SAAS,SACZ,SACA;EACE,GAAG;EACH,MAAM,GAAG,OAAO,KAAK,SAAS,aAAa,KAAK,MAAM,GAAG,KAAK,KAAK;EACpE;;AAGP,SAAgB,kBAAqB,OAA4C;CAC/E,MAAM,0BAAU,IAAI,KAA4B;CAChD,MAAM,iBAAiB,UAAiC;AACtD,UAAQ,MAAM,MAAd;GACE,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK,eACH;GACF,KAAK;GACL,KAAK;AACH,SAAK,MAAM,KAAK,MAAM,QAAS,eAAc,EAAE;AAC/C;GACF,KAAK;AACH,kBAAc,MAAM,QAAQ;AAC5B,SAAK,MAAM,KAAK,MAAM,UAAW,eAAc,EAAE;AACjD;GACF,QACE,0BAAY,MAAM;;;AAGxB,eAAc,MAAM;AACpB,QAAO,CAAC,GAAG,QAAQ,QAAQ,CAAC"}
+{"version":3,"file":"spec.cjs","names":[],"sources":["../../src/pool/spec.ts"],"sourcesContent":["import type { Branded } from \"../branding\";\nimport type { JoinEntry, PColumn, PColumnLazy, PColumnSpec } from \"../drivers\";\nimport { assertNever } from \"../util\";\nimport type { ResultPoolEntry } from \"./entry\";\n\n/** Any object exported into the result pool by the block always have spec attached to it */\nexport type PObjectSpec = {\n  /** PObject kind discriminator */\n  readonly kind: string;\n\n  /** Name is common part of PObject identity */\n  readonly name: string;\n\n  /** Domain is a set of key-value pairs that can be used to identify the object */\n  readonly domain?: Record<string, string>;\n\n  /** Context domain provides additional axis/column identity that is matched\n   * by kinship rules (subset/superset/overlap) rather than exact equality */\n  readonly contextDomain?: Record<string, string>;\n\n  /** Additional information attached to the object */\n  readonly annotations?: Record<string, string>;\n};\n\n/** Stable PObject id */\nexport type PObjectId = Branded<string, \"PColumnId\">;\n\n/**\n * Full PObject representation.\n *\n * @template Data type of the object referencing or describing the \"data\" part of the PObject\n * */\nexport interface PObject<Data> {\n  /** Fully rendered PObjects are assigned a stable identifier. */\n  readonly id: PObjectId;\n\n  /** PObject spec, allowing it to be found among other PObjects */\n  readonly spec: PObjectSpec;\n\n  /** A handle to data object */\n  readonly data: Data;\n}\n\nexport function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec {\n  return spec.kind === \"PColumn\";\n}\n\nexport function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {\n  return isPColumnSpec(obj.spec);\n}\n\nexport function isPColumnSpecResult(\n  r: ResultPoolEntry<PObjectSpec>,\n): r is ResultPoolEntry<PColumnSpec> {\n  return isPColumnSpec(r.obj);\n}\n\nexport function isPColumnResult<T>(\n  r: ResultPoolEntry<PObject<T>>,\n): r is ResultPoolEntry<PColumn<T>> {\n  return isPColumnSpec(r.obj.spec);\n}\n\nexport function ensurePColumn<T>(obj: PObject<T>): PColumn<T> {\n  if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);\n  return obj;\n}\n\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | PColumnLazy<D1>,\n  cb: (d: D1) => D2,\n): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | undefined,\n  cb: (d: D1) => D2,\n): PColumn<D2> | undefined;\nexport function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined {\n  return pObj === undefined\n    ? undefined\n    : {\n        ...pObj,\n        data: cb(typeof pObj.data === \"function\" ? pObj.data() : pObj.data),\n      };\n}\n\nexport function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[] {\n  const columns = new Map<PObjectId, PColumn<D>>();\n  const addAllColumns = (entry: JoinEntry<PColumn<D>>) => {\n    switch (entry.type) {\n      case \"column\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"slicedColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"artificialColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"inlineColumn\":\n        return;\n      case \"full\":\n      case \"inner\":\n        for (const e of entry.entries) addAllColumns(e);\n        return;\n      case \"outer\":\n        addAllColumns(entry.primary);\n        for (const e of entry.secondary) addAllColumns(e);\n        return;\n      default:\n        assertNever(entry);\n    }\n  };\n  addAllColumns(entry);\n  return [...columns.values()];\n}\n"],"mappings":";;;AA2CA,SAAgB,cAAc,MAAwC;AACpE,QAAO,KAAK,SAAS;;AAGvB,SAAgB,UAAa,KAAoC;AAC/D,QAAO,cAAc,IAAI,KAAK;;AAGhC,SAAgB,oBACd,GACmC;AACnC,QAAO,cAAc,EAAE,IAAI;;AAG7B,SAAgB,gBACd,GACkC;AAClC,QAAO,cAAc,EAAE,IAAI,KAAK;;AAGlC,SAAgB,cAAiB,KAA6B;AAC5D,KAAI,CAAC,UAAU,IAAI,CAAE,OAAM,IAAI,MAAM,yBAAyB,IAAI,KAAK,KAAK,GAAG;AAC/E,QAAO;;AAiBT,SAAgB,eACd,MACA,IACyB;AACzB,QAAO,SAAS,SACZ,SACA;EACE,GAAG;EACH,MAAM,GAAG,OAAO,KAAK,SAAS,aAAa,KAAK,MAAM,GAAG,KAAK,KAAK;EACpE;;AAGP,SAAgB,kBAAqB,OAA4C;CAC/E,MAAM,0BAAU,IAAI,KAA4B;CAChD,MAAM,iBAAiB,UAAiC;AACtD,UAAQ,MAAM,MAAd;GACE,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK,eACH;GACF,KAAK;GACL,KAAK;AACH,SAAK,MAAM,KAAK,MAAM,QAAS,eAAc,EAAE;AAC/C;GACF,KAAK;AACH,kBAAc,MAAM,QAAQ;AAC5B,SAAK,MAAM,KAAK,MAAM,UAAW,eAAc,EAAE;AACjD;GACF,QACE,0BAAY,MAAM;;;AAGxB,eAAc,MAAM;AACpB,QAAO,CAAC,GAAG,QAAQ,QAAQ,CAAC"}

package/dist/pool/spec.d.ts

@@ -9,7 +9,10 @@ import "../drivers/index.js";
 type PObjectSpec = {
   /** PObject kind discriminator */readonly kind: string; /** Name is common part of PObject identity */
   readonly name: string; /** Domain is a set of key-value pairs that can be used to identify the object */
-  readonly domain?: Record<string, string>; /** Additional information attached to the object */
+  readonly domain?: Record<string, string>;
+  /** Context domain provides additional axis/column identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>; /** Additional information attached to the object */
   readonly annotations?: Record<string, string>;
 };
 /** Stable PObject id */

package/dist/pool/spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"spec.js","names":[],"sources":["../../src/pool/spec.ts"],"sourcesContent":["import type { Branded } from \"../branding\";\nimport type { JoinEntry, PColumn, PColumnLazy, PColumnSpec } from \"../drivers\";\nimport { assertNever } from \"../util\";\nimport type { ResultPoolEntry } from \"./entry\";\n\n/** Any object exported into the result pool by the block always have spec attached to it */\nexport type PObjectSpec = {\n  /** PObject kind discriminator */\n  readonly kind: string;\n\n  /** Name is common part of PObject identity */\n  readonly name: string;\n\n  /** Domain is a set of key-value pairs that can be used to identify the object */\n  readonly domain?: Record<string, string>;\n\n  /** Additional information attached to the object */\n  readonly annotations?: Record<string, string>;\n};\n\n/** Stable PObject id */\nexport type PObjectId = Branded<string, \"PColumnId\">;\n\n/**\n * Full PObject representation.\n *\n * @template Data type of the object referencing or describing the \"data\" part of the PObject\n * */\nexport interface PObject<Data> {\n  /** Fully rendered PObjects are assigned a stable identifier. */\n  readonly id: PObjectId;\n\n  /** PObject spec, allowing it to be found among other PObjects */\n  readonly spec: PObjectSpec;\n\n  /** A handle to data object */\n  readonly data: Data;\n}\n\nexport function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec {\n  return spec.kind === \"PColumn\";\n}\n\nexport function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {\n  return isPColumnSpec(obj.spec);\n}\n\nexport function isPColumnSpecResult(\n  r: ResultPoolEntry<PObjectSpec>,\n): r is ResultPoolEntry<PColumnSpec> {\n  return isPColumnSpec(r.obj);\n}\n\nexport function isPColumnResult<T>(\n  r: ResultPoolEntry<PObject<T>>,\n): r is ResultPoolEntry<PColumn<T>> {\n  return isPColumnSpec(r.obj.spec);\n}\n\nexport function ensurePColumn<T>(obj: PObject<T>): PColumn<T> {\n  if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);\n  return obj;\n}\n\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | PColumnLazy<D1>,\n  cb: (d: D1) => D2,\n): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | undefined,\n  cb: (d: D1) => D2,\n): PColumn<D2> | undefined;\nexport function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined {\n  return pObj === undefined\n    ? undefined\n    : {\n        ...pObj,\n        data: cb(typeof pObj.data === \"function\" ? pObj.data() : pObj.data),\n      };\n}\n\nexport function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[] {\n  const columns = new Map<PObjectId, PColumn<D>>();\n  const addAllColumns = (entry: JoinEntry<PColumn<D>>) => {\n    switch (entry.type) {\n      case \"column\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"slicedColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"artificialColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"inlineColumn\":\n        return;\n      case \"full\":\n      case \"inner\":\n        for (const e of entry.entries) addAllColumns(e);\n        return;\n      case \"outer\":\n        addAllColumns(entry.primary);\n        for (const e of entry.secondary) addAllColumns(e);\n        return;\n      default:\n        assertNever(entry);\n    }\n  };\n  addAllColumns(entry);\n  return [...columns.values()];\n}\n"],"mappings":";;;AAuCA,SAAgB,cAAc,MAAwC;AACpE,QAAO,KAAK,SAAS;;AAGvB,SAAgB,UAAa,KAAoC;AAC/D,QAAO,cAAc,IAAI,KAAK;;AAGhC,SAAgB,oBACd,GACmC;AACnC,QAAO,cAAc,EAAE,IAAI;;AAG7B,SAAgB,gBACd,GACkC;AAClC,QAAO,cAAc,EAAE,IAAI,KAAK;;AAGlC,SAAgB,cAAiB,KAA6B;AAC5D,KAAI,CAAC,UAAU,IAAI,CAAE,OAAM,IAAI,MAAM,yBAAyB,IAAI,KAAK,KAAK,GAAG;AAC/E,QAAO;;AAiBT,SAAgB,eACd,MACA,IACyB;AACzB,QAAO,SAAS,SACZ,SACA;EACE,GAAG;EACH,MAAM,GAAG,OAAO,KAAK,SAAS,aAAa,KAAK,MAAM,GAAG,KAAK,KAAK;EACpE;;AAGP,SAAgB,kBAAqB,OAA4C;CAC/E,MAAM,0BAAU,IAAI,KAA4B;CAChD,MAAM,iBAAiB,UAAiC;AACtD,UAAQ,MAAM,MAAd;GACE,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK,eACH;GACF,KAAK;GACL,KAAK;AACH,SAAK,MAAM,KAAK,MAAM,QAAS,eAAc,EAAE;AAC/C;GACF,KAAK;AACH,kBAAc,MAAM,QAAQ;AAC5B,SAAK,MAAM,KAAK,MAAM,UAAW,eAAc,EAAE;AACjD;GACF,QACE,aAAY,MAAM;;;AAGxB,eAAc,MAAM;AACpB,QAAO,CAAC,GAAG,QAAQ,QAAQ,CAAC"}
+{"version":3,"file":"spec.js","names":[],"sources":["../../src/pool/spec.ts"],"sourcesContent":["import type { Branded } from \"../branding\";\nimport type { JoinEntry, PColumn, PColumnLazy, PColumnSpec } from \"../drivers\";\nimport { assertNever } from \"../util\";\nimport type { ResultPoolEntry } from \"./entry\";\n\n/** Any object exported into the result pool by the block always have spec attached to it */\nexport type PObjectSpec = {\n  /** PObject kind discriminator */\n  readonly kind: string;\n\n  /** Name is common part of PObject identity */\n  readonly name: string;\n\n  /** Domain is a set of key-value pairs that can be used to identify the object */\n  readonly domain?: Record<string, string>;\n\n  /** Context domain provides additional axis/column identity that is matched\n   * by kinship rules (subset/superset/overlap) rather than exact equality */\n  readonly contextDomain?: Record<string, string>;\n\n  /** Additional information attached to the object */\n  readonly annotations?: Record<string, string>;\n};\n\n/** Stable PObject id */\nexport type PObjectId = Branded<string, \"PColumnId\">;\n\n/**\n * Full PObject representation.\n *\n * @template Data type of the object referencing or describing the \"data\" part of the PObject\n * */\nexport interface PObject<Data> {\n  /** Fully rendered PObjects are assigned a stable identifier. */\n  readonly id: PObjectId;\n\n  /** PObject spec, allowing it to be found among other PObjects */\n  readonly spec: PObjectSpec;\n\n  /** A handle to data object */\n  readonly data: Data;\n}\n\nexport function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec {\n  return spec.kind === \"PColumn\";\n}\n\nexport function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {\n  return isPColumnSpec(obj.spec);\n}\n\nexport function isPColumnSpecResult(\n  r: ResultPoolEntry<PObjectSpec>,\n): r is ResultPoolEntry<PColumnSpec> {\n  return isPColumnSpec(r.obj);\n}\n\nexport function isPColumnResult<T>(\n  r: ResultPoolEntry<PObject<T>>,\n): r is ResultPoolEntry<PColumn<T>> {\n  return isPColumnSpec(r.obj.spec);\n}\n\nexport function ensurePColumn<T>(obj: PObject<T>): PColumn<T> {\n  if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);\n  return obj;\n}\n\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | PColumnLazy<D1>,\n  cb: (d: D1) => D2,\n): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | undefined,\n  cb: (d: D1) => D2,\n): PColumn<D2> | undefined;\nexport function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined {\n  return pObj === undefined\n    ? undefined\n    : {\n        ...pObj,\n        data: cb(typeof pObj.data === \"function\" ? pObj.data() : pObj.data),\n      };\n}\n\nexport function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[] {\n  const columns = new Map<PObjectId, PColumn<D>>();\n  const addAllColumns = (entry: JoinEntry<PColumn<D>>) => {\n    switch (entry.type) {\n      case \"column\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"slicedColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"artificialColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"inlineColumn\":\n        return;\n      case \"full\":\n      case \"inner\":\n        for (const e of entry.entries) addAllColumns(e);\n        return;\n      case \"outer\":\n        addAllColumns(entry.primary);\n        for (const e of entry.secondary) addAllColumns(e);\n        return;\n      default:\n        assertNever(entry);\n    }\n  };\n  addAllColumns(entry);\n  return [...columns.values()];\n}\n"],"mappings":";;;AA2CA,SAAgB,cAAc,MAAwC;AACpE,QAAO,KAAK,SAAS;;AAGvB,SAAgB,UAAa,KAAoC;AAC/D,QAAO,cAAc,IAAI,KAAK;;AAGhC,SAAgB,oBACd,GACmC;AACnC,QAAO,cAAc,EAAE,IAAI;;AAG7B,SAAgB,gBACd,GACkC;AAClC,QAAO,cAAc,EAAE,IAAI,KAAK;;AAGlC,SAAgB,cAAiB,KAA6B;AAC5D,KAAI,CAAC,UAAU,IAAI,CAAE,OAAM,IAAI,MAAM,yBAAyB,IAAI,KAAK,KAAK,GAAG;AAC/E,QAAO;;AAiBT,SAAgB,eACd,MACA,IACyB;AACzB,QAAO,SAAS,SACZ,SACA;EACE,GAAG;EACH,MAAM,GAAG,OAAO,KAAK,SAAS,aAAa,KAAK,MAAM,GAAG,KAAK,KAAK;EACpE;;AAGP,SAAgB,kBAAqB,OAA4C;CAC/E,MAAM,0BAAU,IAAI,KAA4B;CAChD,MAAM,iBAAiB,UAAiC;AACtD,UAAQ,MAAM,MAAd;GACE,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK,eACH;GACF,KAAK;GACL,KAAK;AACH,SAAK,MAAM,KAAK,MAAM,QAAS,eAAc,EAAE;AAC/C;GACF,KAAK;AACH,kBAAc,MAAM,QAAQ;AAC5B,SAAK,MAAM,KAAK,MAAM,UAAW,eAAc,EAAE;AACjD;GACF,QACE,aAAY,MAAM;;;AAGxB,eAAc,MAAM;AACpB,QAAO,CAAC,GAAG,QAAQ,QAAQ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-common",
-  "version": "1.25.2",
+  "version": "1.26.0",
   "description": "Platforma SDK Model",
   "files": [
     "./dist/**/*",
@@ -25,9 +25,9 @@
     "@vitest/coverage-istanbul": "^4.0.18",
     "typescript": "~5.9.3",
     "vitest": "^4.0.18",
-    "@milaboratories/build-configs": "1.5.1",
-    "@milaboratories/ts-builder": "1.2.13",
-    "@milaboratories/ts-configs": "1.2.2"
+    "@milaboratories/ts-configs": "1.2.2",
+    "@milaboratories/build-configs": "1.5.2",
+    "@milaboratories/ts-builder": "1.3.0"
   },
   "scripts": {
     "build": "ts-builder build --target node",

package/src/drivers/pframe/query/query_spec.ts

@@ -54,7 +54,7 @@ type ColumnIdAndSpec = {
  * {
  *   entry: querySpec,
  *   qualifications: [
- *     { axis: { name: 'sample' }, additionalDomains: { ... } }
+ *     { axis: { name: 'sample' }, contextDomain: { ... } }
  *   ]
  * }
  */
@@ -64,7 +64,7 @@ export type SpecQueryJoinEntry<C = PObjectId> = QueryJoinEntry<SpecQuery<C>> & {
     /** Axis selector identifying which axis to qualify */
     axis: SingleAxisSelector;
     /** Additional domain constraints for this axis */
-    additionalDomains: Domain;
+    contextDomain: Domain;
   }[];
 };
 

package/src/drivers/pframe/query/utils.test.ts

@@ -242,8 +242,8 @@ describe("sortSpecQuery", () => {
         {
           entry: pcol("a"),
           qualifications: [
-            { axis: { name: "z" }, additionalDomains: {} },
-            { axis: { name: "a" }, additionalDomains: {} },
+            { axis: { name: "z" }, contextDomain: {} },
+            { axis: { name: "a" }, contextDomain: {} },
           ],
         },
       ],

package/src/drivers/pframe/spec/anchored.ts

@@ -32,16 +32,19 @@ function domainKey(key: string, value: string): string {
  */
 export class AnchoredIdDeriver {
   private readonly domains = new Map<string, string>();
+  private readonly contextDomains = new Map<string, string>();
   private readonly axes = new Map<string, AnchorAxisRefByIdx>();
   /**
    * Domain packs are used to group domain keys that can be anchored to the same anchor
    * This is used to optimize the lookup of domain anchors
    */
   private readonly domainPacks: string[][] = [];
+  private readonly contextDomainPacks: string[][] = [];
   /**
    * Maps domain packs to anchors
    */
   private readonly domainPackToAnchor = new Map<string, string>();
+  private readonly contextDomainPackToAnchor = new Map<string, string>();
 
   /**
    * Creates a new anchor context from a set of anchor column specifications
@@ -68,6 +71,18 @@ export class AnchoredIdDeriver {
           this.domains.set(key, anchorId);
         }
       }
+      if (spec.contextDomain !== undefined) {
+        const contextDomainEntries = Object.entries(spec.contextDomain);
+        contextDomainEntries.sort((a, b) => a[0].localeCompare(b[0]));
+
+        this.contextDomainPackToAnchor.set(JSON.stringify(contextDomainEntries), anchorId);
+        this.contextDomainPacks.push(contextDomainEntries.map(([dKey]) => dKey));
+
+        for (const [dKey, dValue] of contextDomainEntries) {
+          const key = domainKey(dKey, dValue);
+          this.contextDomains.set(key, anchorId);
+        }
+      }
     }
   }
 
@@ -121,6 +136,32 @@ export class AnchoredIdDeriver {
       result.domain[dKey] = anchorId ? { anchor: anchorId } : dValue;
     }
 
+    let skipContextDomains: Set<string> | undefined = undefined;
+    if (spec.contextDomain !== undefined) {
+      outer: for (const contextDomainPack of this.contextDomainPacks) {
+        const dAnchor: string[][] = [];
+        for (const domainKey of contextDomainPack) {
+          const dValue = spec.contextDomain[domainKey];
+          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);
+          else break outer;
+        }
+        const contextDomainAnchor = this.contextDomainPackToAnchor.get(JSON.stringify(dAnchor));
+        if (contextDomainAnchor !== undefined) {
+          result.contextDomainAnchor = contextDomainAnchor;
+          skipContextDomains = new Set(contextDomainPack);
+          break;
+        }
+      }
+    }
+
+    for (const [dKey, dValue] of Object.entries(spec.contextDomain ?? {})) {
+      if (skipContextDomains !== undefined && skipContextDomains.has(dKey)) continue;
+      const key = domainKey(dKey, dValue);
+      const anchorId = this.contextDomains.get(key);
+      result.contextDomain ??= {};
+      result.contextDomain[dKey] = anchorId ? { anchor: anchorId } : dValue;
+    }
+
     result.axes = spec.axesSpec.map((axis) => {
       const key = axisKey(axis);
       const anchorAxisRef = this.axes.get(key);
@@ -239,6 +280,38 @@ export function resolveAnchors(
     result.domain = resolvedDomain;
   }
 
+  if (result.contextDomainAnchor !== undefined) {
+    const anchorSpec = anchors[result.contextDomainAnchor];
+    if (!anchorSpec) throw new Error(`Anchor "${result.contextDomainAnchor}" not found`);
+
+    const anchorContextDomains = anchorSpec.contextDomain || {};
+    result.contextDomain = { ...anchorContextDomains, ...result.contextDomain };
+    delete result.contextDomainAnchor;
+  }
+
+  if (result.contextDomain) {
+    const resolvedContextDomain: Record<string, string> = {};
+    for (const [key, value] of Object.entries(result.contextDomain)) {
+      if (typeof value === "string") {
+        resolvedContextDomain[key] = value;
+      } else {
+        // It's an AnchorDomainRef
+        const anchorSpec = anchors[value.anchor];
+        if (!anchorSpec)
+          throw new Error(`Anchor "${value.anchor}" not found for contextDomain key "${key}"`);
+
+        if (!anchorSpec.contextDomain || anchorSpec.contextDomain[key] === undefined) {
+          if (!ignoreMissingDomains)
+            throw new Error(`Context domain key "${key}" not found in anchor "${value.anchor}"`);
+          continue;
+        }
+
+        resolvedContextDomain[key] = anchorSpec.contextDomain[key];
+      }
+    }
+    result.contextDomain = resolvedContextDomain;
+  }
+
   if (result.axes) result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));
 
   return result as PColumnSelector;

package/src/drivers/pframe/spec/native_id.ts

@@ -10,6 +10,7 @@ export function deriveNativeId(spec: PObjectSpec): NativePObjectId {
     name: spec.name,
   };
   if (spec.domain !== undefined) result.domain = spec.domain;
+  if (spec.contextDomain !== undefined) result.contextDomain = spec.contextDomain;
   if (isPColumnSpec(spec)) result.axesSpec = getAxesId(spec.axesSpec);
   return canonicalize(result) as NativePObjectId;
 }

package/src/drivers/pframe/spec/selectors.ts

@@ -35,6 +35,13 @@ export interface AxisSelector {
    * An axis with additional domain entries not present in this selector will still match.
    */
   domain?: Record<string, string>;
+
+  /**
+   * Optional context domain key-value pairs to match against.
+   * Context domains are matched by kinship rules (subset/superset/overlap) rather than exact equality.
+   * When specified, an axis will match only if it contains all the key-value pairs defined here.
+   */
+  contextDomain?: Record<string, string>;
 }
 
 /** Single axis selector */
@@ -112,6 +119,11 @@ export interface AnchoredPColumnSelector {
   /** Optional domain values to match, can include anchored references, if domainAnchor is specified,
    * interpreted as additional domains to domain from the anchor */
   domain?: Record<string, ADomain>;
+  /** If specified, the context domain values must be anchored to this anchor */
+  contextDomainAnchor?: string;
+  /** Optional context domain values to match, can include anchored references, if contextDomainAnchor is specified,
+   * interpreted as additional context domains to context domain from the anchor */
+  contextDomain?: Record<string, ADomain>;
   /** Optional axes to match, can include anchored references */
   axes?: AAxisSelector[];
   /** When true, allows matching if only a subset of axes match */
@@ -130,6 +142,8 @@ export interface AnchoredPColumnSelector {
 export interface PColumnSelector extends AnchoredPColumnSelector {
   domainAnchor?: never;
   domain?: Record<string, string>;
+  contextDomainAnchor?: never;
+  contextDomain?: Record<string, string>;
   axes?: AxisSelector[];
 }
 
@@ -193,6 +207,13 @@ export function matchAxis(selector: AxisSelector, axis: AxisId): boolean {
       if (axisDomain[key] !== value) return false;
   }
 
+  // Match contextDomain if specified
+  if (selector.contextDomain !== undefined) {
+    const axisContextDomain = axis.contextDomain || {};
+    for (const [key, value] of Object.entries(selector.contextDomain))
+      if (axisContextDomain[key] !== value) return false;
+  }
+
   return true;
 }
 
@@ -227,6 +248,13 @@ export function matchPColumn(pcolumn: PColumnSpec, selector: PColumnSelector): b
       if (columnDomain[key] !== value) return false;
   }
 
+  // Match contextDomain if specified
+  if (selector.contextDomain !== undefined) {
+    const columnContextDomain = pcolumn.contextDomain || {};
+    for (const [key, value] of Object.entries(selector.contextDomain))
+      if (columnContextDomain[key] !== value) return false;
+  }
+
   // Match axes if specified
   if (selector.axes !== undefined) {
     const pcolumnAxes = pcolumn.axesSpec.map(getAxisId);

package/src/drivers/pframe/spec/spec.ts

@@ -312,6 +312,10 @@ export type AxisSpec = {
    * unique identifier */
   readonly domain?: Record<string, string>;
 
+  /** Context domain provides additional axis identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
+
   /** Any additional information attached to the axis that does not affect its
    * identifier */
   readonly annotations?: Record<string, string>;
@@ -421,6 +425,12 @@ function normalizingAxesComparator(
     return domain1 < domain2 ? 1 : -1;
   }
 
+  const contextDomain1 = canonicalizeJson(axis1.contextDomain ?? {});
+  const contextDomain2 = canonicalizeJson(axis2.contextDomain ?? {});
+  if (contextDomain1 !== contextDomain2) {
+    return contextDomain1 < contextDomain2 ? 1 : -1;
+  }
+
   const parents1 = canonicalizeAxisWithParents(axis1);
   const parents2 = canonicalizeAxisWithParents(axis2);
 
@@ -592,6 +602,10 @@ export type PUniversalColumnSpec = PObjectSpec & {
    * unique identifier */
   readonly domain?: Record<string, string>;
 
+  /** Context domain provides additional column identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
+
   /** Any additional information attached to the column that does not affect its
    * identifier */
   readonly annotations?: Record<string, string>;
@@ -635,6 +649,10 @@ export type PColumnSpecId = {
    * unique identifier */
   readonly domain?: Record<string, string>;
 
+  /** Context domain provides additional column identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
+
   /** A list of zero-based indices of parent axes from the {@link axesSpec} array. */
   readonly parentAxes?: number[];
 
@@ -648,6 +666,7 @@ export function getPColumnSpecId(spec: PColumnSpec): PColumnSpecId {
     valueType: spec.valueType,
     name: spec.name,
     domain: spec.domain,
+    contextDomain: spec.contextDomain,
     parentAxes: spec.parentAxes,
     axesId: getAxesId(spec.axesSpec),
   };
@@ -695,6 +714,10 @@ export interface AxisId {
   /** Adds auxiliary information to the axis or column name and type to form a
    * unique identifier */
   readonly domain?: Record<string, string>;
+
+  /** Context domain provides additional axis identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
 }
 
 /** Array of axis ids */
@@ -702,11 +725,14 @@ export type AxesId = AxisId[];
 
 /** Extracts axis ids from axis spec */
 export function getAxisId(spec: AxisSpec): AxisId {
-  const { type, name, domain } = spec;
-  const result = { type, name };
+  const { type, name, domain, contextDomain } = spec;
+  const result: AxisId = { type, name };
   if (domain && Object.entries(domain).length > 0) {
     Object.assign(result, { domain });
   }
+  if (contextDomain && Object.entries(contextDomain).length > 0) {
+    Object.assign(result, { contextDomain });
+  }
   return result;
 }
 
@@ -732,7 +758,11 @@ function matchDomain(query?: Record<string, string>, target?: Record<string, str
 
 /** Returns whether "match" axis id is compatible with the "query" */
 export function matchAxisId(query: AxisId, target: AxisId): boolean {
-  return query.name === target.name && matchDomain(query.domain, target.domain);
+  return (
+    query.name === target.name &&
+    matchDomain(query.domain, target.domain) &&
+    matchDomain(query.contextDomain, target.contextDomain)
+  );
 }
 
 export function getTypeFromPColumnOrAxisSpec(spec: PColumnSpec | AxisSpec): ValueType {

package/src/flags/block_flags.ts

@@ -16,12 +16,13 @@ export type BlockCodeFeatureFlags = Record<`supports${string}`, boolean | number
  */
 export type BlockCodeKnownFeatureFlags = {
   readonly supportsLazyState?: boolean;
+  readonly supportsPframeQueryRanking?: boolean;
   readonly requiresModelAPIVersion?: number;
   readonly requiresUIAPIVersion?: number;
   readonly requiresCreatePTable?: number;
 };
 
-export const AllSupportsFeatureFlags = ["supportsLazyState"] as const;
+export const AllSupportsFeatureFlags = ["supportsLazyState", "supportsPframeQueryRanking"] as const;
 
 export const AllRequiresFeatureFlags = [
   "requiresUIAPIVersion",

package/src/pool/query.ts

@@ -80,6 +80,12 @@ export function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSp
                 (axisSpec.domain !== undefined &&
                   Object.entries(matcher.domain).every(
                     ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,
+                  ))) &&
+              (matcher.contextDomain === undefined ||
+                Object.keys(matcher.contextDomain).length === 0 ||
+                (axisSpec.contextDomain !== undefined &&
+                  Object.entries(matcher.contextDomain).every(
+                    ([key, value]) => axisSpec.contextDomain![key] === value,
                   ))),
           ),
         )

package/src/pool/spec.ts

@@ -14,6 +14,10 @@ export type PObjectSpec = {
   /** Domain is a set of key-value pairs that can be used to identify the object */
   readonly domain?: Record<string, string>;
 
+  /** Context domain provides additional axis/column identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
+
   /** Additional information attached to the object */
   readonly annotations?: Record<string, string>;
 };