@platforma-sdk/model 1.79.27 → 1.80.2

package/dist/columns/column_recipes/column_discovered_recipe.js

@@ -0,0 +1,180 @@
+import { Column } from "../column.js";
+import { rebrandLeafId } from "./leaf_rebrand.js";
+import { ColumnRecipe } from "./index.js";
+import { ColumnOverriddenRecipe } from "./column_overrided_recipe.js";
+import { distillColumnDiscoveredKey, extractPObjectId, stringifyColumnDiscoveredId } from "@milaboratories/pl-model-common";
+import { throwError } from "@milaboratories/helpers";
+//#region src/columns/column_recipes/column_discovered_recipe.ts
+/**
+* Recipe for columns identified by a {@link ColumnDiscoveredKey}: a base
+* column + a `path` of linkers + qualifications.
+*
+* Specifics:
+*  - References more than one column (`column` + each `path[i].column`);
+*    {@link getDataStatus} aggregates across the whole set.
+*  - {@link getQuery} assembles the {@link SpecQuery} locally
+*    ({@link buildSpecQuery}) — the hit is inlined as its own recipe's query
+*    tree, linkers fold inside-out into nested `linkerJoin` nodes.
+*  - {@link getSpec} passes through to the hit column's own spec: the linker
+*    chain only enables co-indexing and does not remap the hit's `axesSpec`, so
+*    no engine round-trip is needed (mirrors the Discovered branch of
+*    `reconstructSpecFromId` on the host side).
+*/
+var ColumnDiscoveredRecipe = class ColumnDiscoveredRecipe {
+	key;
+	columns;
+	/**
+	* Validate the key + resolve every referenced column via
+	* {@link ColumnLazy.fromId} (which itself checks the leaf accessor reports
+	* `hasData()`). Returns `undefined` if the key is malformed or any
+	* referenced column is not yet spec-resolvable.
+	*
+	* Spec JSON is deserialized lazily on first {@link getSpec}/{@link getQuery}.
+	*/
+	static fromKey(key, opts = {}) {
+		const distilled = distillColumnDiscoveredKey(key);
+		const columns = {};
+		for (const uniId of referencedUniIdsOf(distilled)) {
+			const recipe = Column(uniId, opts);
+			if (recipe === void 0) return void 0;
+			columns[uniId] = recipe;
+		}
+		return new ColumnDiscoveredRecipe(distilled, columns);
+	}
+	/**
+	* Static counterpart to {@link fromKey}: returns the resolution status of
+	* a {@link ColumnDiscoveredKey} without constructing the recipe. Worst-wins
+	* across every referenced {@link ColumnUniversalId} (hit + path linkers),
+	* each resolved via the top-level {@link ColumnRecipe.getStatus} dispatcher.
+	*/
+	static getStatusByKey(key, opts = {}) {
+		const distilled = distillColumnDiscoveredKey(key);
+		let worst = "present";
+		for (const uniId of referencedUniIdsOf(distilled)) {
+			const s = ColumnRecipe.getStatus(uniId, opts);
+			if (s === "absent") return "absent";
+			if (s === "resolving") worst = "resolving";
+		}
+		return worst;
+	}
+	id;
+	specCache;
+	queryCache;
+	dataStatusCache;
+	constructor(key, columns) {
+		this.key = key;
+		this.columns = columns;
+		this.id = stringifyColumnDiscoveredId(this.key);
+	}
+	/**
+	* Universal id of the hit column (excluding path/qualifications on top).
+	* May itself be a wrapped id (Overridden / Filtered / nested Discovered) —
+	* preserves projections applied to the underlying column.
+	*/
+	getHitId() {
+		return this.key.column;
+	}
+	/**
+	* Axis qualifications attached to the hit column itself — applied to the
+	* outer-join entry that wraps this column at the consumer boundary.
+	*/
+	getColumnQualifications() {
+		return this.key.columnQualifications ?? [];
+	}
+	/**
+	* Per-primary-column qualifications applied to the primary anchors on
+	* this group's side. Keyed by the external primary column id.
+	*/
+	getQueriesQualifications() {
+		return this.key.queriesQualifications ?? {};
+	}
+	/**
+	* Leaf {@link PObjectId}s the recipe physically depends on: hit column +
+	* each linker in `path`, with any projection wrappers unwrapped down to
+	* their underlying storage column. Used to track real-data dependencies
+	* (e.g. {@link getDataStatus}), not projected identities.
+	*/
+	getReferencedIds() {
+		return [...new Set([...referencedUniIdsOf(this.key)].map((uniId) => extractPObjectId(uniId)))];
+	}
+	/**
+	* Final spec of a discovered hit is just the hit column's own spec: the
+	* linker chain only enables co-indexing, it does not remap the hit's
+	* `axesSpec`, and axis qualifications live on the outer join entry (see
+	* {@link buildSpecQuery}), not in the spec. So pass through to the hit
+	* recipe's `getSpec()` — no engine round-trip needed. This mirrors the
+	* Discovered branch of `reconstructSpecFromId` on the host side.
+	*/
+	getSpec() {
+		if (this.specCache === void 0) {
+			const hit = this.columns[this.key.column] ?? throwError(`ColumnDiscoveredRecipe.getSpec: missing column ${this.key.column}`);
+			this.specCache = { value: hit.getSpec() };
+		}
+		return this.specCache.value;
+	}
+	/** IR for building the final spec — see {@link buildSpecQuery}. */
+	getQuery() {
+		if (this.queryCache === void 0) this.queryCache = { value: this.buildSpecQuery() };
+		return this.queryCache.value;
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: Object.values(this.columns).reduce((worst, lazy) => {
+			const s = lazy.getDataStatus();
+			if (s === "absent" || worst === "absent") return "absent";
+			if (s === "resolving") return "resolving";
+			return worst;
+		}, "present") };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Discovered + overrides → Overridden<Discovered>. Delegates to the
+	* flat-merge factory of ColumnOverriddenRecipe; subsequent `withSpecs`
+	* calls merge at the Overridden level (one wrapper, no nesting).
+	*/
+	withSpecs(overrides) {
+		return ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+	/**
+	* Assembles the SpecQuery for this discovered hit by folding `key.path`
+	* around the hit column.
+	*
+	* The hit (innermost) is built by inlining `columns[key.column].getQuery()`
+	* — recursing into the hit's own recipe — so wrapping layers on the hit
+	* (Overridden / Filtered / nested Discovered) appear in the produced tree.
+	* The previous `pframeSpec.buildQuery` path was a flat
+	* {@link PObjectId}-only call and could not express that.
+	*
+	* Linkers stay as plain column references on the linker side of
+	* `linkerJoin` (the spec node has no slot for a query-side linker); the
+	* linker's recipe id is used directly. The frame registered in
+	* {@link getSpec} carries each recipe's final spec under that same id, so
+	* the engine resolves linker axes from the post-projection spec.
+	*
+	* Path ordering matches {@link ColumnDiscoveredKey.path}: `path[0]` is
+	* outermost, `path[N-1]` is closest to the hit. We fold from the inside
+	* out — innermost wrap first — so the result lines up with that convention.
+	*
+	* `columnQualifications` / `queriesQualifications` are not emitted here —
+	* qualifications live on a {@link SpecQueryJoinEntry} wrapper (lost on
+	* unwrapping to {@link SpecQuery}). External consumers apply them at the
+	* outer join via {@link getColumnQualifications} / {@link getQueriesQualifications}.
+	*/
+	buildSpecQuery() {
+		const hitRecipe = this.columns[this.key.column] ?? throwError(`ColumnDiscoveredRecipe.buildSpecQuery: missing column ${this.key.column}`);
+		let query = rebrandLeafId(hitRecipe.getQuery(), hitRecipe.id, this.id);
+		const path = this.key.path ?? [];
+		for (let i = path.length - 1; i >= 0; i--) query = {
+			type: "linkerJoin",
+			linker: (this.columns[path[i].column] ?? throwError(`ColumnDiscoveredRecipe.buildSpecQuery: missing linker column ${path[i].column}`)).getQuery(),
+			secondary: [{ entry: query }]
+		};
+		return query;
+	}
+};
+function referencedUniIdsOf(key) {
+	return /* @__PURE__ */ new Set([key.column, ...(key.path ?? []).map((item) => item.column)]);
+}
+//#endregion
+export { ColumnDiscoveredRecipe };
+
+//# sourceMappingURL=column_discovered_recipe.js.map

package/dist/columns/column_recipes/column_discovered_recipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column_discovered_recipe.js","names":[],"sources":["../../../src/columns/column_recipes/column_discovered_recipe.ts"],"sourcesContent":["import {\n  distillColumnDiscoveredKey,\n  extractPObjectId,\n  stringifyColumnDiscoveredId,\n  type AxisQualification,\n  type ColumnDiscoveredId,\n  type ColumnDiscoveredKey,\n  type ColumnUniversalId,\n  type PColumnSpec,\n  type PObjectId,\n  type SpecOverrides,\n  type SpecQuery,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx } from \"../../render/internal\";\nimport type { ColumnFieldStatus, ColumnResolutionStatus } from \"./types\";\nimport { ColumnRecipe } from \"./index\";\nimport { ColumnOverriddenRecipe } from \"./column_overrided_recipe\";\nimport { Column } from \"../column\";\nimport { rebrandLeafId } from \"./leaf_rebrand\";\nimport { throwError } from \"@milaboratories/helpers\";\n\n/**\n * Recipe for columns identified by a {@link ColumnDiscoveredKey}: a base\n * column + a `path` of linkers + qualifications.\n *\n * Specifics:\n *  - References more than one column (`column` + each `path[i].column`);\n *    {@link getDataStatus} aggregates across the whole set.\n *  - {@link getQuery} assembles the {@link SpecQuery} locally\n *    ({@link buildSpecQuery}) — the hit is inlined as its own recipe's query\n *    tree, linkers fold inside-out into nested `linkerJoin` nodes.\n *  - {@link getSpec} passes through to the hit column's own spec: the linker\n *    chain only enables co-indexing and does not remap the hit's `axesSpec`, so\n *    no engine round-trip is needed (mirrors the Discovered branch of\n *    `reconstructSpecFromId` on the host side).\n */\nexport class ColumnDiscoveredRecipe implements ColumnRecipe<ColumnDiscoveredId> {\n  /**\n   * Validate the key + resolve every referenced column via\n   * {@link ColumnLazy.fromId} (which itself checks the leaf accessor reports\n   * `hasData()`). Returns `undefined` if the key is malformed or any\n   * referenced column is not yet spec-resolvable.\n   *\n   * Spec JSON is deserialized lazily on first {@link getSpec}/{@link getQuery}.\n   */\n  static fromKey(\n    key: ColumnDiscoveredKey,\n    opts: { ctx?: GlobalCfgRenderCtx } = {},\n  ): undefined | ColumnDiscoveredRecipe {\n    const distilled = distillColumnDiscoveredKey(key);\n    const columns: Record<ColumnUniversalId, Column> = {};\n    for (const uniId of referencedUniIdsOf(distilled)) {\n      const recipe = Column(uniId, opts);\n      if (recipe === undefined) return undefined;\n      columns[uniId] = recipe;\n    }\n    return new ColumnDiscoveredRecipe(distilled, columns);\n  }\n\n  /**\n   * Static counterpart to {@link fromKey}: returns the resolution status of\n   * a {@link ColumnDiscoveredKey} without constructing the recipe. Worst-wins\n   * across every referenced {@link ColumnUniversalId} (hit + path linkers),\n   * each resolved via the top-level {@link ColumnRecipe.getStatus} dispatcher.\n   */\n  static getStatusByKey(\n    key: ColumnDiscoveredKey,\n    opts: { ctx?: GlobalCfgRenderCtx } = {},\n  ): ColumnResolutionStatus {\n    const distilled = distillColumnDiscoveredKey(key);\n    let worst: ColumnResolutionStatus = \"present\";\n    for (const uniId of referencedUniIdsOf(distilled)) {\n      const s = ColumnRecipe.getStatus(uniId, opts);\n      if (s === \"absent\") return \"absent\";\n      if (s === \"resolving\") worst = \"resolving\";\n    }\n    return worst;\n  }\n\n  readonly id: ColumnDiscoveredId;\n  private specCache?: { readonly value: PColumnSpec };\n  private queryCache?: { readonly value: SpecQuery };\n  private dataStatusCache?: { readonly value: ColumnFieldStatus };\n\n  private constructor(\n    private readonly key: ColumnDiscoveredKey,\n    private readonly columns: Record<ColumnUniversalId, ColumnRecipe>,\n  ) {\n    this.id = stringifyColumnDiscoveredId(this.key);\n  }\n\n  /**\n   * Universal id of the hit column (excluding path/qualifications on top).\n   * May itself be a wrapped id (Overridden / Filtered / nested Discovered) —\n   * preserves projections applied to the underlying column.\n   */\n  getHitId(): ColumnUniversalId {\n    return this.key.column;\n  }\n\n  /**\n   * Axis qualifications attached to the hit column itself — applied to the\n   * outer-join entry that wraps this column at the consumer boundary.\n   */\n  getColumnQualifications(): readonly AxisQualification[] {\n    return this.key.columnQualifications ?? [];\n  }\n\n  /**\n   * Per-primary-column qualifications applied to the primary anchors on\n   * this group's side. Keyed by the external primary column id.\n   */\n  getQueriesQualifications(): Readonly<Record<PObjectId, AxisQualification[]>> {\n    return this.key.queriesQualifications ?? {};\n  }\n\n  /**\n   * Leaf {@link PObjectId}s the recipe physically depends on: hit column +\n   * each linker in `path`, with any projection wrappers unwrapped down to\n   * their underlying storage column. Used to track real-data dependencies\n   * (e.g. {@link getDataStatus}), not projected identities.\n   */\n  getReferencedIds(): PObjectId[] {\n    return [...new Set([...referencedUniIdsOf(this.key)].map((uniId) => extractPObjectId(uniId)))];\n  }\n\n  /**\n   * Final spec of a discovered hit is just the hit column's own spec: the\n   * linker chain only enables co-indexing, it does not remap the hit's\n   * `axesSpec`, and axis qualifications live on the outer join entry (see\n   * {@link buildSpecQuery}), not in the spec. So pass through to the hit\n   * recipe's `getSpec()` — no engine round-trip needed. This mirrors the\n   * Discovered branch of `reconstructSpecFromId` on the host side.\n   */\n  getSpec(): PColumnSpec {\n    if (this.specCache === undefined) {\n      const hit =\n        this.columns[this.key.column] ??\n        throwError(`ColumnDiscoveredRecipe.getSpec: missing column ${this.key.column}`);\n      this.specCache = { value: hit.getSpec() };\n    }\n    return this.specCache.value;\n  }\n\n  /** IR for building the final spec — see {@link buildSpecQuery}. */\n  getQuery(): SpecQuery {\n    if (this.queryCache === undefined) {\n      this.queryCache = { value: this.buildSpecQuery() };\n    }\n    return this.queryCache.value;\n  }\n\n  getDataStatus(): ColumnFieldStatus {\n    if (this.dataStatusCache === undefined) {\n      this.dataStatusCache = {\n        value: Object.values(this.columns).reduce<ColumnFieldStatus>((worst, lazy) => {\n          const s = lazy.getDataStatus();\n          if (s === \"absent\" || worst === \"absent\") return \"absent\";\n          if (s === \"resolving\") return \"resolving\";\n          return worst;\n        }, \"present\"),\n      };\n    }\n    return this.dataStatusCache.value;\n  }\n\n  /**\n   * Discovered + overrides → Overridden<Discovered>. Delegates to the\n   * flat-merge factory of ColumnOverriddenRecipe; subsequent `withSpecs`\n   * calls merge at the Overridden level (one wrapper, no nesting).\n   */\n  withSpecs(overrides: SpecOverrides): ColumnRecipe {\n    return ColumnOverriddenRecipe.wrap(this, overrides);\n  }\n\n  /**\n   * Assembles the SpecQuery for this discovered hit by folding `key.path`\n   * around the hit column.\n   *\n   * The hit (innermost) is built by inlining `columns[key.column].getQuery()`\n   * — recursing into the hit's own recipe — so wrapping layers on the hit\n   * (Overridden / Filtered / nested Discovered) appear in the produced tree.\n   * The previous `pframeSpec.buildQuery` path was a flat\n   * {@link PObjectId}-only call and could not express that.\n   *\n   * Linkers stay as plain column references on the linker side of\n   * `linkerJoin` (the spec node has no slot for a query-side linker); the\n   * linker's recipe id is used directly. The frame registered in\n   * {@link getSpec} carries each recipe's final spec under that same id, so\n   * the engine resolves linker axes from the post-projection spec.\n   *\n   * Path ordering matches {@link ColumnDiscoveredKey.path}: `path[0]` is\n   * outermost, `path[N-1]` is closest to the hit. We fold from the inside\n   * out — innermost wrap first — so the result lines up with that convention.\n   *\n   * `columnQualifications` / `queriesQualifications` are not emitted here —\n   * qualifications live on a {@link SpecQueryJoinEntry} wrapper (lost on\n   * unwrapping to {@link SpecQuery}). External consumers apply them at the\n   * outer join via {@link getColumnQualifications} / {@link getQueriesQualifications}.\n   */\n  private buildSpecQuery(): SpecQuery {\n    // Preserve the inner hit recipe's full query tree — it may carry\n    // wrappers (specOverride / sliceAxes / nested linkerJoin) that the\n    // host needs to apply correctly. We only rebrand the terminal column\n    // leaf to this.id so two variants of the same physical hit reached via\n    // different linker chains stay distinct columns in the engine output.\n    const hitRecipe =\n      this.columns[this.key.column] ??\n      throwError(`ColumnDiscoveredRecipe.buildSpecQuery: missing column ${this.key.column}`);\n    let query: SpecQuery = rebrandLeafId(hitRecipe.getQuery(), hitRecipe.id, this.id);\n    const path = this.key.path ?? [];\n\n    for (let i = path.length - 1; i >= 0; i--) {\n      const linker =\n        this.columns[path[i].column] ??\n        throwError(\n          `ColumnDiscoveredRecipe.buildSpecQuery: missing linker column ${path[i].column}`,\n        );\n      query = {\n        type: \"linkerJoin\",\n        linker: linker.getQuery(),\n        secondary: [{ entry: query }],\n      };\n    }\n    return query;\n  }\n}\n\nfunction referencedUniIdsOf(key: ColumnDiscoveredKey): Set<ColumnUniversalId> {\n  return new Set<ColumnUniversalId>([key.column, ...(key.path ?? []).map((item) => item.column)]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAoCA,IAAa,yBAAb,MAAa,uBAAmE;CAiD3D;CACA;;;;;;;;;CAzCnB,OAAO,QACL,KACA,OAAqC,CAAC,GACF;EACpC,MAAM,YAAY,2BAA2B,GAAG;EAChD,MAAM,UAA6C,CAAC;EACpD,KAAK,MAAM,SAAS,mBAAmB,SAAS,GAAG;GACjD,MAAM,SAAS,OAAO,OAAO,IAAI;GACjC,IAAI,WAAW,KAAA,GAAW,OAAO,KAAA;GACjC,QAAQ,SAAS;EACnB;EACA,OAAO,IAAI,uBAAuB,WAAW,OAAO;CACtD;;;;;;;CAQA,OAAO,eACL,KACA,OAAqC,CAAC,GACd;EACxB,MAAM,YAAY,2BAA2B,GAAG;EAChD,IAAI,QAAgC;EACpC,KAAK,MAAM,SAAS,mBAAmB,SAAS,GAAG;GACjD,MAAM,IAAI,aAAa,UAAU,OAAO,IAAI;GAC5C,IAAI,MAAM,UAAU,OAAO;GAC3B,IAAI,MAAM,aAAa,QAAQ;EACjC;EACA,OAAO;CACT;CAEA;CACA;CACA;CACA;CAEA,YACE,KACA,SACA;EAFiB,KAAA,MAAA;EACA,KAAA,UAAA;EAEjB,KAAK,KAAK,4BAA4B,KAAK,GAAG;CAChD;;;;;;CAOA,WAA8B;EAC5B,OAAO,KAAK,IAAI;CAClB;;;;;CAMA,0BAAwD;EACtD,OAAO,KAAK,IAAI,wBAAwB,CAAC;CAC3C;;;;;CAMA,2BAA6E;EAC3E,OAAO,KAAK,IAAI,yBAAyB,CAAC;CAC5C;;;;;;;CAQA,mBAAgC;EAC9B,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,mBAAmB,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,UAAU,iBAAiB,KAAK,CAAC,CAAC,CAAC;CAC/F;;;;;;;;;CAUA,UAAuB;EACrB,IAAI,KAAK,cAAc,KAAA,GAAW;GAChC,MAAM,MACJ,KAAK,QAAQ,KAAK,IAAI,WACtB,WAAW,kDAAkD,KAAK,IAAI,QAAQ;GAChF,KAAK,YAAY,EAAE,OAAO,IAAI,QAAQ,EAAE;EAC1C;EACA,OAAO,KAAK,UAAU;CACxB;;CAGA,WAAsB;EACpB,IAAI,KAAK,eAAe,KAAA,GACtB,KAAK,aAAa,EAAE,OAAO,KAAK,eAAe,EAAE;EAEnD,OAAO,KAAK,WAAW;CACzB;CAEA,gBAAmC;EACjC,IAAI,KAAK,oBAAoB,KAAA,GAC3B,KAAK,kBAAkB,EACrB,OAAO,OAAO,OAAO,KAAK,OAAO,CAAC,CAAC,QAA2B,OAAO,SAAS;GAC5E,MAAM,IAAI,KAAK,cAAc;GAC7B,IAAI,MAAM,YAAY,UAAU,UAAU,OAAO;GACjD,IAAI,MAAM,aAAa,OAAO;GAC9B,OAAO;EACT,GAAG,SAAS,EACd;EAEF,OAAO,KAAK,gBAAgB;CAC9B;;;;;;CAOA,UAAU,WAAwC;EAChD,OAAO,uBAAuB,KAAK,MAAM,SAAS;CACpD;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BA,iBAAoC;EAMlC,MAAM,YACJ,KAAK,QAAQ,KAAK,IAAI,WACtB,WAAW,yDAAyD,KAAK,IAAI,QAAQ;EACvF,IAAI,QAAmB,cAAc,UAAU,SAAS,GAAG,UAAU,IAAI,KAAK,EAAE;EAChF,MAAM,OAAO,KAAK,IAAI,QAAQ,CAAC;EAE/B,KAAK,IAAI,IAAI,KAAK,SAAS,GAAG,KAAK,GAAG,KAMpC,QAAQ;GACN,MAAM;GACN,SANA,KAAK,QAAQ,KAAK,EAAE,CAAC,WACrB,WACE,gEAAgE,KAAK,EAAE,CAAC,QAC1E,EAAA,CAGe,SAAS;GACxB,WAAW,CAAC,EAAE,OAAO,MAAM,CAAC;EAC9B;EAEF,OAAO;CACT;AACF;AAEA,SAAS,mBAAmB,KAAkD;CAC5E,uBAAO,IAAI,IAAuB,CAAC,IAAI,QAAQ,IAAI,IAAI,QAAQ,CAAC,EAAA,CAAG,KAAK,SAAS,KAAK,MAAM,CAAC,CAAC;AAChG"}

package/dist/columns/column_recipes/column_filtered_recipe.cjs

@@ -0,0 +1,133 @@
+const require_leaf_rebrand = require("./leaf_rebrand.cjs");
+const require_index = require("./index.cjs");
+const require_column_overrided_recipe = require("./column_overrided_recipe.cjs");
+let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
+//#region src/columns/column_recipes/column_filtered_recipe.ts
+/**
+* Recipe wrapper that fixes the values of selected axes of an inner recipe
+* (axis slicing). The id is `FilteredPColumnId { source: inner.id,
+* axisFilters }`.
+*
+* Flat-merge invariant: `inner` is never another {@link ColumnFilteredRecipe}.
+* Repeated {@link wrap} concatenates `axisFilters` at the current level.
+*
+* Layering: `withSpecs` on a Filtered recipe yields
+* `Overridden<Filtered<inner>>` — Overridden is always the outermost layer.
+* The reverse layering (`Filtered<Overridden<...>>`) is not reachable via
+* the public interface.
+*/
+var ColumnFilteredRecipe = class ColumnFilteredRecipe {
+	inner;
+	axisFilters;
+	/**
+	* Wrap any recipe with axis filters. If `inner` is already a
+	* {@link ColumnFilteredRecipe}, concatenates `axisFilters` and returns a
+	* new Filtered sharing the original `inner`.
+	*
+	* Validates every axis index against `inner.getSpec().axesSpec` at
+	* construction — throws on an out-of-range index. After {@link wrap}, the
+	* recipe is guaranteed to be spec-complete.
+	*
+	* Order semantics: new filters are appended after existing ones, preserving
+	* their relative order. AND composition is otherwise commutative; order
+	* only affects canonicalize/equality.
+	*/
+	static wrap(col, axisFilters) {
+		const combined = col instanceof ColumnFilteredRecipe ? [...col.axisFilters, ...axisFilters] : axisFilters;
+		const base = col instanceof ColumnFilteredRecipe ? col.inner : col;
+		if (combined.length === 0) throw new Error("ColumnFilteredRecipe.wrap: at least one axis filter must be provided");
+		const innerSpec = base.getSpec();
+		const fixed = /* @__PURE__ */ new Set();
+		for (const [idx] of combined) {
+			if (innerSpec.axesSpec[idx] === void 0) throw new Error(`ColumnFilteredRecipe.wrap: axis index ${idx} out of range (inner has ${innerSpec.axesSpec.length} axes)`);
+			fixed.add(idx);
+		}
+		if (fixed.size >= innerSpec.axesSpec.length) throw new Error(`ColumnFilteredRecipe.wrap: filters fix all ${innerSpec.axesSpec.length} axes — at least one axis must remain`);
+		return new ColumnFilteredRecipe(base, combined);
+	}
+	/**
+	* Static counterpart to {@link wrap}: returns the resolution status of a
+	* {@link ColumnFilteredKey} without constructing the recipe. Axis filters
+	* do not add references — status collapses to the source's status.
+	*/
+	static getStatusByKey(key, opts = {}) {
+		if (typeof key.source !== "string") throw new Error("ColumnFilteredRecipe.getStatusByKey: filtered column with non-string source");
+		return require_index.ColumnRecipe.getStatus(key.source, opts);
+	}
+	id;
+	specCache;
+	queryCache;
+	dataStatusCache;
+	constructor(inner, axisFilters) {
+		this.inner = inner;
+		this.axisFilters = axisFilters;
+		this.id = (0, _milaboratories_pl_model_common.stringifyColumnFilteredId)({
+			source: inner.id,
+			axisFilters
+		});
+	}
+	/** Wrapped recipe — exposed so external walkers can descend. */
+	getInner() {
+		return this.inner;
+	}
+	/** Axis filters do not introduce references to other columns. */
+	getReferencedIds() {
+		return this.inner.getReferencedIds();
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: this.inner.getDataStatus() };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Final spec — the inner spec with fixed axes removed. Indices in
+	* `axisFilters` are positional against `inner.getSpec().axesSpec` and were
+	* validated at {@link wrap} time.
+	*/
+	getSpec() {
+		if (this.specCache === void 0) this.specCache = { value: (0, _milaboratories_pl_model_common.applyAxisFilters)(this.inner.getSpec(), this.axisFilters) };
+		return this.specCache.value;
+	}
+	/**
+	* Wraps the inner query in `SpecQuerySliceAxes`. Index→selector resolution
+	* goes through the inner spec — guaranteed available since {@link wrap}
+	* validated all indices at construction.
+	*/
+	getQuery() {
+		if (this.queryCache === void 0) {
+			const innerQuery = this.inner.getQuery();
+			if (this.axisFilters.length === 0) this.queryCache = { value: require_leaf_rebrand.rebrandLeafId(innerQuery, this.inner.id, this.id) };
+			else {
+				const innerSpec = this.inner.getSpec();
+				this.queryCache = { value: {
+					type: "sliceAxes",
+					input: require_leaf_rebrand.rebrandLeafId(innerQuery, this.inner.id, this.id),
+					axisFilters: this.axisFilters.map(([idx, value]) => ({
+						axisSelector: toAxisSelector(innerSpec.axesSpec[idx]),
+						constant: value
+					}))
+				} };
+			}
+		}
+		return this.queryCache.value;
+	}
+	/**
+	* Filtered + overrides → Overridden<Filtered>. Overridden is always the
+	* outermost layer.
+	*/
+	withSpecs(overrides) {
+		return require_column_overrided_recipe.ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+};
+function toAxisSelector(axis) {
+	const selector = {
+		name: axis.name,
+		type: axis.type
+	};
+	if (axis.domain !== void 0 && Object.keys(axis.domain).length > 0) selector.domain = axis.domain;
+	if (axis.contextDomain !== void 0 && Object.keys(axis.contextDomain).length > 0) selector.contextDomain = axis.contextDomain;
+	return selector;
+}
+//#endregion
+exports.ColumnFilteredRecipe = ColumnFilteredRecipe;
+
+//# sourceMappingURL=column_filtered_recipe.cjs.map

package/dist/columns/column_recipes/column_filtered_recipe.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"column_filtered_recipe.cjs","names":["ColumnRecipe","rebrandLeafId","ColumnOverriddenRecipe"],"sources":["../../../src/columns/column_recipes/column_filtered_recipe.ts"],"sourcesContent":["import {\n  applyAxisFilters,\n  stringifyColumnFilteredId,\n  type AxisFilterByIdx,\n  type AxisSpec,\n  type ColumnFilteredId,\n  type ColumnFilteredKey,\n  type PColumnSpec,\n  type PObjectId,\n  type SingleAxisSelector,\n  type SpecOverrides,\n  type SpecQuery,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx } from \"../../render/internal\";\nimport type { ColumnFieldStatus, ColumnResolutionStatus } from \"./types\";\nimport { ColumnRecipe } from \"./index\";\nimport { ColumnOverriddenRecipe } from \"./column_overrided_recipe\";\nimport { rebrandLeafId } from \"./leaf_rebrand\";\n\n/**\n * Recipe wrapper that fixes the values of selected axes of an inner recipe\n * (axis slicing). The id is `FilteredPColumnId { source: inner.id,\n * axisFilters }`.\n *\n * Flat-merge invariant: `inner` is never another {@link ColumnFilteredRecipe}.\n * Repeated {@link wrap} concatenates `axisFilters` at the current level.\n *\n * Layering: `withSpecs` on a Filtered recipe yields\n * `Overridden<Filtered<inner>>` — Overridden is always the outermost layer.\n * The reverse layering (`Filtered<Overridden<...>>`) is not reachable via\n * the public interface.\n */\nexport class ColumnFilteredRecipe implements ColumnRecipe<ColumnFilteredId> {\n  /**\n   * Wrap any recipe with axis filters. If `inner` is already a\n   * {@link ColumnFilteredRecipe}, concatenates `axisFilters` and returns a\n   * new Filtered sharing the original `inner`.\n   *\n   * Validates every axis index against `inner.getSpec().axesSpec` at\n   * construction — throws on an out-of-range index. After {@link wrap}, the\n   * recipe is guaranteed to be spec-complete.\n   *\n   * Order semantics: new filters are appended after existing ones, preserving\n   * their relative order. AND composition is otherwise commutative; order\n   * only affects canonicalize/equality.\n   */\n  static wrap(col: ColumnRecipe, axisFilters: AxisFilterByIdx[]): ColumnFilteredRecipe {\n    const combined =\n      col instanceof ColumnFilteredRecipe ? [...col.axisFilters, ...axisFilters] : axisFilters;\n    const base = col instanceof ColumnFilteredRecipe ? col.inner : col;\n\n    if (combined.length === 0) {\n      throw new Error(\"ColumnFilteredRecipe.wrap: at least one axis filter must be provided\");\n    }\n\n    const innerSpec = base.getSpec();\n    const fixed = new Set<number>();\n    for (const [idx] of combined) {\n      if (innerSpec.axesSpec[idx] === undefined) {\n        throw new Error(\n          `ColumnFilteredRecipe.wrap: axis index ${idx} out of range (inner has ${innerSpec.axesSpec.length} axes)`,\n        );\n      }\n      fixed.add(idx);\n    }\n    if (fixed.size >= innerSpec.axesSpec.length) {\n      throw new Error(\n        `ColumnFilteredRecipe.wrap: filters fix all ${innerSpec.axesSpec.length} axes — at least one axis must remain`,\n      );\n    }\n\n    return new ColumnFilteredRecipe(base, combined);\n  }\n\n  /**\n   * Static counterpart to {@link wrap}: returns the resolution status of a\n   * {@link ColumnFilteredKey} without constructing the recipe. Axis filters\n   * do not add references — status collapses to the source's status.\n   */\n  static getStatusByKey(\n    key: ColumnFilteredKey,\n    opts: { ctx?: GlobalCfgRenderCtx } = {},\n  ): ColumnResolutionStatus {\n    if (typeof key.source !== \"string\") {\n      throw new Error(\n        \"ColumnFilteredRecipe.getStatusByKey: filtered column with non-string source\",\n      );\n    }\n    return ColumnRecipe.getStatus(key.source, opts);\n  }\n\n  readonly id: ColumnFilteredId;\n  private specCache?: { readonly value: PColumnSpec };\n  private queryCache?: { readonly value: SpecQuery };\n  private dataStatusCache?: { readonly value: ColumnFieldStatus };\n\n  private constructor(\n    private readonly inner: ColumnRecipe,\n    private readonly axisFilters: AxisFilterByIdx[],\n  ) {\n    this.id = stringifyColumnFilteredId({\n      source: inner.id,\n      axisFilters,\n    });\n  }\n\n  /** Wrapped recipe — exposed so external walkers can descend. */\n  getInner(): ColumnRecipe {\n    return this.inner;\n  }\n\n  /** Axis filters do not introduce references to other columns. */\n  getReferencedIds(): PObjectId[] {\n    return this.inner.getReferencedIds();\n  }\n\n  getDataStatus(): ColumnFieldStatus {\n    if (this.dataStatusCache === undefined) {\n      this.dataStatusCache = { value: this.inner.getDataStatus() };\n    }\n    return this.dataStatusCache.value;\n  }\n\n  /**\n   * Final spec — the inner spec with fixed axes removed. Indices in\n   * `axisFilters` are positional against `inner.getSpec().axesSpec` and were\n   * validated at {@link wrap} time.\n   */\n  getSpec(): PColumnSpec {\n    if (this.specCache === undefined) {\n      this.specCache = { value: applyAxisFilters(this.inner.getSpec(), this.axisFilters) };\n    }\n    return this.specCache.value;\n  }\n\n  /**\n   * Wraps the inner query in `SpecQuerySliceAxes`. Index→selector resolution\n   * goes through the inner spec — guaranteed available since {@link wrap}\n   * validated all indices at construction.\n   */\n  getQuery(): SpecQuery {\n    if (this.queryCache === undefined) {\n      const innerQuery = this.inner.getQuery();\n      if (this.axisFilters.length === 0) {\n        // Pass-through (no filters): rebrand the inner leaf to this.id so\n        // wrappers in the chain don't reintroduce the inner's id at the\n        // leaf — keeps the resolver/leaf-id contract uniform.\n        this.queryCache = { value: rebrandLeafId(innerQuery, this.inner.id, this.id) };\n      } else {\n        const innerSpec = this.inner.getSpec();\n        this.queryCache = {\n          value: {\n            type: \"sliceAxes\",\n            input: rebrandLeafId(innerQuery, this.inner.id, this.id),\n            axisFilters: this.axisFilters.map(([idx, value]) => ({\n              axisSelector: toAxisSelector(innerSpec.axesSpec[idx]),\n              constant: value,\n            })),\n          },\n        };\n      }\n    }\n    return this.queryCache.value;\n  }\n\n  /**\n   * Filtered + overrides → Overridden<Filtered>. Overridden is always the\n   * outermost layer.\n   */\n  withSpecs(overrides: SpecOverrides): ColumnRecipe {\n    return ColumnOverriddenRecipe.wrap(this, overrides);\n  }\n}\n\nfunction toAxisSelector(axis: AxisSpec): SingleAxisSelector {\n  const selector: SingleAxisSelector = { name: axis.name, type: axis.type };\n  if (axis.domain !== undefined && Object.keys(axis.domain).length > 0) {\n    selector.domain = axis.domain;\n  }\n  if (axis.contextDomain !== undefined && Object.keys(axis.contextDomain).length > 0) {\n    selector.contextDomain = axis.contextDomain;\n  }\n  return selector;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgCA,IAAa,uBAAb,MAAa,qBAA+D;CAiEvD;CACA;;;;;;;;;;;;;;CApDnB,OAAO,KAAK,KAAmB,aAAsD;EACnF,MAAM,WACJ,eAAe,uBAAuB,CAAC,GAAG,IAAI,aAAa,GAAG,WAAW,IAAI;EAC/E,MAAM,OAAO,eAAe,uBAAuB,IAAI,QAAQ;EAE/D,IAAI,SAAS,WAAW,GACtB,MAAM,IAAI,MAAM,sEAAsE;EAGxF,MAAM,YAAY,KAAK,QAAQ;EAC/B,MAAM,wBAAQ,IAAI,IAAY;EAC9B,KAAK,MAAM,CAAC,QAAQ,UAAU;GAC5B,IAAI,UAAU,SAAS,SAAS,KAAA,GAC9B,MAAM,IAAI,MACR,yCAAyC,IAAI,2BAA2B,UAAU,SAAS,OAAO,OACpG;GAEF,MAAM,IAAI,GAAG;EACf;EACA,IAAI,MAAM,QAAQ,UAAU,SAAS,QACnC,MAAM,IAAI,MACR,8CAA8C,UAAU,SAAS,OAAO,sCAC1E;EAGF,OAAO,IAAI,qBAAqB,MAAM,QAAQ;CAChD;;;;;;CAOA,OAAO,eACL,KACA,OAAqC,CAAC,GACd;EACxB,IAAI,OAAO,IAAI,WAAW,UACxB,MAAM,IAAI,MACR,6EACF;EAEF,OAAOA,cAAAA,aAAa,UAAU,IAAI,QAAQ,IAAI;CAChD;CAEA;CACA;CACA;CACA;CAEA,YACE,OACA,aACA;EAFiB,KAAA,QAAA;EACA,KAAA,cAAA;EAEjB,KAAK,MAAA,GAAA,gCAAA,0BAAA,CAA+B;GAClC,QAAQ,MAAM;GACd;EACF,CAAC;CACH;;CAGA,WAAyB;EACvB,OAAO,KAAK;CACd;;CAGA,mBAAgC;EAC9B,OAAO,KAAK,MAAM,iBAAiB;CACrC;CAEA,gBAAmC;EACjC,IAAI,KAAK,oBAAoB,KAAA,GAC3B,KAAK,kBAAkB,EAAE,OAAO,KAAK,MAAM,cAAc,EAAE;EAE7D,OAAO,KAAK,gBAAgB;CAC9B;;;;;;CAOA,UAAuB;EACrB,IAAI,KAAK,cAAc,KAAA,GACrB,KAAK,YAAY,EAAE,QAAA,GAAA,gCAAA,iBAAA,CAAwB,KAAK,MAAM,QAAQ,GAAG,KAAK,WAAW,EAAE;EAErF,OAAO,KAAK,UAAU;CACxB;;;;;;CAOA,WAAsB;EACpB,IAAI,KAAK,eAAe,KAAA,GAAW;GACjC,MAAM,aAAa,KAAK,MAAM,SAAS;GACvC,IAAI,KAAK,YAAY,WAAW,GAI9B,KAAK,aAAa,EAAE,OAAOC,qBAAAA,cAAc,YAAY,KAAK,MAAM,IAAI,KAAK,EAAE,EAAE;QACxE;IACL,MAAM,YAAY,KAAK,MAAM,QAAQ;IACrC,KAAK,aAAa,EAChB,OAAO;KACL,MAAM;KACN,OAAOA,qBAAAA,cAAc,YAAY,KAAK,MAAM,IAAI,KAAK,EAAE;KACvD,aAAa,KAAK,YAAY,KAAK,CAAC,KAAK,YAAY;MACnD,cAAc,eAAe,UAAU,SAAS,IAAI;MACpD,UAAU;KACZ,EAAE;IACJ,EACF;GACF;EACF;EACA,OAAO,KAAK,WAAW;CACzB;;;;;CAMA,UAAU,WAAwC;EAChD,OAAOC,gCAAAA,uBAAuB,KAAK,MAAM,SAAS;CACpD;AACF;AAEA,SAAS,eAAe,MAAoC;CAC1D,MAAM,WAA+B;EAAE,MAAM,KAAK;EAAM,MAAM,KAAK;CAAK;CACxE,IAAI,KAAK,WAAW,KAAA,KAAa,OAAO,KAAK,KAAK,MAAM,CAAC,CAAC,SAAS,GACjE,SAAS,SAAS,KAAK;CAEzB,IAAI,KAAK,kBAAkB,KAAA,KAAa,OAAO,KAAK,KAAK,aAAa,CAAC,CAAC,SAAS,GAC/E,SAAS,gBAAgB,KAAK;CAEhC,OAAO;AACT"}

package/dist/columns/column_recipes/column_filtered_recipe.d.ts

@@ -0,0 +1,75 @@
+import { GlobalCfgRenderCtx } from "../../render/internal.js";
+import { ColumnFieldStatus, ColumnResolutionStatus } from "./types.js";
+import { ColumnRecipe } from "./index.js";
+import { AxisFilterByIdx, ColumnFilteredId, ColumnFilteredKey, PColumnSpec, PObjectId, SpecOverrides, SpecQuery } from "@milaboratories/pl-model-common";
+
+//#region src/columns/column_recipes/column_filtered_recipe.d.ts
+/**
+ * Recipe wrapper that fixes the values of selected axes of an inner recipe
+ * (axis slicing). The id is `FilteredPColumnId { source: inner.id,
+ * axisFilters }`.
+ *
+ * Flat-merge invariant: `inner` is never another {@link ColumnFilteredRecipe}.
+ * Repeated {@link wrap} concatenates `axisFilters` at the current level.
+ *
+ * Layering: `withSpecs` on a Filtered recipe yields
+ * `Overridden<Filtered<inner>>` — Overridden is always the outermost layer.
+ * The reverse layering (`Filtered<Overridden<...>>`) is not reachable via
+ * the public interface.
+ */
+declare class ColumnFilteredRecipe implements ColumnRecipe<ColumnFilteredId> {
+  private readonly inner;
+  private readonly axisFilters;
+  /**
+   * Wrap any recipe with axis filters. If `inner` is already a
+   * {@link ColumnFilteredRecipe}, concatenates `axisFilters` and returns a
+   * new Filtered sharing the original `inner`.
+   *
+   * Validates every axis index against `inner.getSpec().axesSpec` at
+   * construction — throws on an out-of-range index. After {@link wrap}, the
+   * recipe is guaranteed to be spec-complete.
+   *
+   * Order semantics: new filters are appended after existing ones, preserving
+   * their relative order. AND composition is otherwise commutative; order
+   * only affects canonicalize/equality.
+   */
+  static wrap(col: ColumnRecipe, axisFilters: AxisFilterByIdx[]): ColumnFilteredRecipe;
+  /**
+   * Static counterpart to {@link wrap}: returns the resolution status of a
+   * {@link ColumnFilteredKey} without constructing the recipe. Axis filters
+   * do not add references — status collapses to the source's status.
+   */
+  static getStatusByKey(key: ColumnFilteredKey, opts?: {
+    ctx?: GlobalCfgRenderCtx;
+  }): ColumnResolutionStatus;
+  readonly id: ColumnFilteredId;
+  private specCache?;
+  private queryCache?;
+  private dataStatusCache?;
+  private constructor();
+  /** Wrapped recipe — exposed so external walkers can descend. */
+  getInner(): ColumnRecipe;
+  /** Axis filters do not introduce references to other columns. */
+  getReferencedIds(): PObjectId[];
+  getDataStatus(): ColumnFieldStatus;
+  /**
+   * Final spec — the inner spec with fixed axes removed. Indices in
+   * `axisFilters` are positional against `inner.getSpec().axesSpec` and were
+   * validated at {@link wrap} time.
+   */
+  getSpec(): PColumnSpec;
+  /**
+   * Wraps the inner query in `SpecQuerySliceAxes`. Index→selector resolution
+   * goes through the inner spec — guaranteed available since {@link wrap}
+   * validated all indices at construction.
+   */
+  getQuery(): SpecQuery;
+  /**
+   * Filtered + overrides → Overridden<Filtered>. Overridden is always the
+   * outermost layer.
+   */
+  withSpecs(overrides: SpecOverrides): ColumnRecipe;
+}
+//#endregion
+export { ColumnFilteredRecipe };
+//# sourceMappingURL=column_filtered_recipe.d.ts.map

package/dist/columns/column_recipes/column_filtered_recipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column_filtered_recipe.d.ts","names":[],"sources":["../../../src/columns/column_recipes/column_filtered_recipe.ts"],"mappings":";;;;;;;;AAgCA;;;;;;;;;;;cAAa,oBAAA,YAAgC,YAAA,CAAa,gBAAA;EAAA,iBAiErC,KAAA;EAAA,iBACA,WAAA;EA8BR;;;;;;;;;;;;;EAAA,OAlFJ,IAAA,CAAK,GAAA,EAAK,YAAA,EAAc,WAAA,EAAa,eAAA,KAAoB,oBAAA;EAApB;;;;;EAAA,OAiCrC,cAAA,CACL,GAAA,EAAK,iBAAA,EACL,IAAA;IAAQ,GAAA,GAAM,kBAAA;EAAA,IACb,sBAAA;EAAA,SASM,EAAA,EAAI,gBAAA;EAAA,QACL,SAAA;EAAA,QACA,UAAA;EAAA,QACA,eAAA;EAAA,QAED,WAAA;EAHC;EAcR,QAAA,IAAY,YAAA;EAXL;EAgBP,gBAAA,IAAoB,SAAA;EAIpB,aAAA,IAAiB,iBAAA;EAJjB;;;;;EAgBA,OAAA,IAAW,WAAA;EAYX;;;;;EAAA,QAAA,IAAY,SAAA;EA6BqC;AAAA;;;EAAjD,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,YAAA;AAAA"}

package/dist/columns/column_recipes/column_filtered_recipe.js

@@ -0,0 +1,133 @@
+import { rebrandLeafId } from "./leaf_rebrand.js";
+import { ColumnRecipe } from "./index.js";
+import { ColumnOverriddenRecipe } from "./column_overrided_recipe.js";
+import { applyAxisFilters, stringifyColumnFilteredId } from "@milaboratories/pl-model-common";
+//#region src/columns/column_recipes/column_filtered_recipe.ts
+/**
+* Recipe wrapper that fixes the values of selected axes of an inner recipe
+* (axis slicing). The id is `FilteredPColumnId { source: inner.id,
+* axisFilters }`.
+*
+* Flat-merge invariant: `inner` is never another {@link ColumnFilteredRecipe}.
+* Repeated {@link wrap} concatenates `axisFilters` at the current level.
+*
+* Layering: `withSpecs` on a Filtered recipe yields
+* `Overridden<Filtered<inner>>` — Overridden is always the outermost layer.
+* The reverse layering (`Filtered<Overridden<...>>`) is not reachable via
+* the public interface.
+*/
+var ColumnFilteredRecipe = class ColumnFilteredRecipe {
+	inner;
+	axisFilters;
+	/**
+	* Wrap any recipe with axis filters. If `inner` is already a
+	* {@link ColumnFilteredRecipe}, concatenates `axisFilters` and returns a
+	* new Filtered sharing the original `inner`.
+	*
+	* Validates every axis index against `inner.getSpec().axesSpec` at
+	* construction — throws on an out-of-range index. After {@link wrap}, the
+	* recipe is guaranteed to be spec-complete.
+	*
+	* Order semantics: new filters are appended after existing ones, preserving
+	* their relative order. AND composition is otherwise commutative; order
+	* only affects canonicalize/equality.
+	*/
+	static wrap(col, axisFilters) {
+		const combined = col instanceof ColumnFilteredRecipe ? [...col.axisFilters, ...axisFilters] : axisFilters;
+		const base = col instanceof ColumnFilteredRecipe ? col.inner : col;
+		if (combined.length === 0) throw new Error("ColumnFilteredRecipe.wrap: at least one axis filter must be provided");
+		const innerSpec = base.getSpec();
+		const fixed = /* @__PURE__ */ new Set();
+		for (const [idx] of combined) {
+			if (innerSpec.axesSpec[idx] === void 0) throw new Error(`ColumnFilteredRecipe.wrap: axis index ${idx} out of range (inner has ${innerSpec.axesSpec.length} axes)`);
+			fixed.add(idx);
+		}
+		if (fixed.size >= innerSpec.axesSpec.length) throw new Error(`ColumnFilteredRecipe.wrap: filters fix all ${innerSpec.axesSpec.length} axes — at least one axis must remain`);
+		return new ColumnFilteredRecipe(base, combined);
+	}
+	/**
+	* Static counterpart to {@link wrap}: returns the resolution status of a
+	* {@link ColumnFilteredKey} without constructing the recipe. Axis filters
+	* do not add references — status collapses to the source's status.
+	*/
+	static getStatusByKey(key, opts = {}) {
+		if (typeof key.source !== "string") throw new Error("ColumnFilteredRecipe.getStatusByKey: filtered column with non-string source");
+		return ColumnRecipe.getStatus(key.source, opts);
+	}
+	id;
+	specCache;
+	queryCache;
+	dataStatusCache;
+	constructor(inner, axisFilters) {
+		this.inner = inner;
+		this.axisFilters = axisFilters;
+		this.id = stringifyColumnFilteredId({
+			source: inner.id,
+			axisFilters
+		});
+	}
+	/** Wrapped recipe — exposed so external walkers can descend. */
+	getInner() {
+		return this.inner;
+	}
+	/** Axis filters do not introduce references to other columns. */
+	getReferencedIds() {
+		return this.inner.getReferencedIds();
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: this.inner.getDataStatus() };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Final spec — the inner spec with fixed axes removed. Indices in
+	* `axisFilters` are positional against `inner.getSpec().axesSpec` and were
+	* validated at {@link wrap} time.
+	*/
+	getSpec() {
+		if (this.specCache === void 0) this.specCache = { value: applyAxisFilters(this.inner.getSpec(), this.axisFilters) };
+		return this.specCache.value;
+	}
+	/**
+	* Wraps the inner query in `SpecQuerySliceAxes`. Index→selector resolution
+	* goes through the inner spec — guaranteed available since {@link wrap}
+	* validated all indices at construction.
+	*/
+	getQuery() {
+		if (this.queryCache === void 0) {
+			const innerQuery = this.inner.getQuery();
+			if (this.axisFilters.length === 0) this.queryCache = { value: rebrandLeafId(innerQuery, this.inner.id, this.id) };
+			else {
+				const innerSpec = this.inner.getSpec();
+				this.queryCache = { value: {
+					type: "sliceAxes",
+					input: rebrandLeafId(innerQuery, this.inner.id, this.id),
+					axisFilters: this.axisFilters.map(([idx, value]) => ({
+						axisSelector: toAxisSelector(innerSpec.axesSpec[idx]),
+						constant: value
+					}))
+				} };
+			}
+		}
+		return this.queryCache.value;
+	}
+	/**
+	* Filtered + overrides → Overridden<Filtered>. Overridden is always the
+	* outermost layer.
+	*/
+	withSpecs(overrides) {
+		return ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+};
+function toAxisSelector(axis) {
+	const selector = {
+		name: axis.name,
+		type: axis.type
+	};
+	if (axis.domain !== void 0 && Object.keys(axis.domain).length > 0) selector.domain = axis.domain;
+	if (axis.contextDomain !== void 0 && Object.keys(axis.contextDomain).length > 0) selector.contextDomain = axis.contextDomain;
+	return selector;
+}
+//#endregion
+export { ColumnFilteredRecipe };
+
+//# sourceMappingURL=column_filtered_recipe.js.map

package/dist/columns/column_recipes/column_filtered_recipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column_filtered_recipe.js","names":[],"sources":["../../../src/columns/column_recipes/column_filtered_recipe.ts"],"sourcesContent":["import {\n  applyAxisFilters,\n  stringifyColumnFilteredId,\n  type AxisFilterByIdx,\n  type AxisSpec,\n  type ColumnFilteredId,\n  type ColumnFilteredKey,\n  type PColumnSpec,\n  type PObjectId,\n  type SingleAxisSelector,\n  type SpecOverrides,\n  type SpecQuery,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx } from \"../../render/internal\";\nimport type { ColumnFieldStatus, ColumnResolutionStatus } from \"./types\";\nimport { ColumnRecipe } from \"./index\";\nimport { ColumnOverriddenRecipe } from \"./column_overrided_recipe\";\nimport { rebrandLeafId } from \"./leaf_rebrand\";\n\n/**\n * Recipe wrapper that fixes the values of selected axes of an inner recipe\n * (axis slicing). The id is `FilteredPColumnId { source: inner.id,\n * axisFilters }`.\n *\n * Flat-merge invariant: `inner` is never another {@link ColumnFilteredRecipe}.\n * Repeated {@link wrap} concatenates `axisFilters` at the current level.\n *\n * Layering: `withSpecs` on a Filtered recipe yields\n * `Overridden<Filtered<inner>>` — Overridden is always the outermost layer.\n * The reverse layering (`Filtered<Overridden<...>>`) is not reachable via\n * the public interface.\n */\nexport class ColumnFilteredRecipe implements ColumnRecipe<ColumnFilteredId> {\n  /**\n   * Wrap any recipe with axis filters. If `inner` is already a\n   * {@link ColumnFilteredRecipe}, concatenates `axisFilters` and returns a\n   * new Filtered sharing the original `inner`.\n   *\n   * Validates every axis index against `inner.getSpec().axesSpec` at\n   * construction — throws on an out-of-range index. After {@link wrap}, the\n   * recipe is guaranteed to be spec-complete.\n   *\n   * Order semantics: new filters are appended after existing ones, preserving\n   * their relative order. AND composition is otherwise commutative; order\n   * only affects canonicalize/equality.\n   */\n  static wrap(col: ColumnRecipe, axisFilters: AxisFilterByIdx[]): ColumnFilteredRecipe {\n    const combined =\n      col instanceof ColumnFilteredRecipe ? [...col.axisFilters, ...axisFilters] : axisFilters;\n    const base = col instanceof ColumnFilteredRecipe ? col.inner : col;\n\n    if (combined.length === 0) {\n      throw new Error(\"ColumnFilteredRecipe.wrap: at least one axis filter must be provided\");\n    }\n\n    const innerSpec = base.getSpec();\n    const fixed = new Set<number>();\n    for (const [idx] of combined) {\n      if (innerSpec.axesSpec[idx] === undefined) {\n        throw new Error(\n          `ColumnFilteredRecipe.wrap: axis index ${idx} out of range (inner has ${innerSpec.axesSpec.length} axes)`,\n        );\n      }\n      fixed.add(idx);\n    }\n    if (fixed.size >= innerSpec.axesSpec.length) {\n      throw new Error(\n        `ColumnFilteredRecipe.wrap: filters fix all ${innerSpec.axesSpec.length} axes — at least one axis must remain`,\n      );\n    }\n\n    return new ColumnFilteredRecipe(base, combined);\n  }\n\n  /**\n   * Static counterpart to {@link wrap}: returns the resolution status of a\n   * {@link ColumnFilteredKey} without constructing the recipe. Axis filters\n   * do not add references — status collapses to the source's status.\n   */\n  static getStatusByKey(\n    key: ColumnFilteredKey,\n    opts: { ctx?: GlobalCfgRenderCtx } = {},\n  ): ColumnResolutionStatus {\n    if (typeof key.source !== \"string\") {\n      throw new Error(\n        \"ColumnFilteredRecipe.getStatusByKey: filtered column with non-string source\",\n      );\n    }\n    return ColumnRecipe.getStatus(key.source, opts);\n  }\n\n  readonly id: ColumnFilteredId;\n  private specCache?: { readonly value: PColumnSpec };\n  private queryCache?: { readonly value: SpecQuery };\n  private dataStatusCache?: { readonly value: ColumnFieldStatus };\n\n  private constructor(\n    private readonly inner: ColumnRecipe,\n    private readonly axisFilters: AxisFilterByIdx[],\n  ) {\n    this.id = stringifyColumnFilteredId({\n      source: inner.id,\n      axisFilters,\n    });\n  }\n\n  /** Wrapped recipe — exposed so external walkers can descend. */\n  getInner(): ColumnRecipe {\n    return this.inner;\n  }\n\n  /** Axis filters do not introduce references to other columns. */\n  getReferencedIds(): PObjectId[] {\n    return this.inner.getReferencedIds();\n  }\n\n  getDataStatus(): ColumnFieldStatus {\n    if (this.dataStatusCache === undefined) {\n      this.dataStatusCache = { value: this.inner.getDataStatus() };\n    }\n    return this.dataStatusCache.value;\n  }\n\n  /**\n   * Final spec — the inner spec with fixed axes removed. Indices in\n   * `axisFilters` are positional against `inner.getSpec().axesSpec` and were\n   * validated at {@link wrap} time.\n   */\n  getSpec(): PColumnSpec {\n    if (this.specCache === undefined) {\n      this.specCache = { value: applyAxisFilters(this.inner.getSpec(), this.axisFilters) };\n    }\n    return this.specCache.value;\n  }\n\n  /**\n   * Wraps the inner query in `SpecQuerySliceAxes`. Index→selector resolution\n   * goes through the inner spec — guaranteed available since {@link wrap}\n   * validated all indices at construction.\n   */\n  getQuery(): SpecQuery {\n    if (this.queryCache === undefined) {\n      const innerQuery = this.inner.getQuery();\n      if (this.axisFilters.length === 0) {\n        // Pass-through (no filters): rebrand the inner leaf to this.id so\n        // wrappers in the chain don't reintroduce the inner's id at the\n        // leaf — keeps the resolver/leaf-id contract uniform.\n        this.queryCache = { value: rebrandLeafId(innerQuery, this.inner.id, this.id) };\n      } else {\n        const innerSpec = this.inner.getSpec();\n        this.queryCache = {\n          value: {\n            type: \"sliceAxes\",\n            input: rebrandLeafId(innerQuery, this.inner.id, this.id),\n            axisFilters: this.axisFilters.map(([idx, value]) => ({\n              axisSelector: toAxisSelector(innerSpec.axesSpec[idx]),\n              constant: value,\n            })),\n          },\n        };\n      }\n    }\n    return this.queryCache.value;\n  }\n\n  /**\n   * Filtered + overrides → Overridden<Filtered>. Overridden is always the\n   * outermost layer.\n   */\n  withSpecs(overrides: SpecOverrides): ColumnRecipe {\n    return ColumnOverriddenRecipe.wrap(this, overrides);\n  }\n}\n\nfunction toAxisSelector(axis: AxisSpec): SingleAxisSelector {\n  const selector: SingleAxisSelector = { name: axis.name, type: axis.type };\n  if (axis.domain !== undefined && Object.keys(axis.domain).length > 0) {\n    selector.domain = axis.domain;\n  }\n  if (axis.contextDomain !== undefined && Object.keys(axis.contextDomain).length > 0) {\n    selector.contextDomain = axis.contextDomain;\n  }\n  return selector;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgCA,IAAa,uBAAb,MAAa,qBAA+D;CAiEvD;CACA;;;;;;;;;;;;;;CApDnB,OAAO,KAAK,KAAmB,aAAsD;EACnF,MAAM,WACJ,eAAe,uBAAuB,CAAC,GAAG,IAAI,aAAa,GAAG,WAAW,IAAI;EAC/E,MAAM,OAAO,eAAe,uBAAuB,IAAI,QAAQ;EAE/D,IAAI,SAAS,WAAW,GACtB,MAAM,IAAI,MAAM,sEAAsE;EAGxF,MAAM,YAAY,KAAK,QAAQ;EAC/B,MAAM,wBAAQ,IAAI,IAAY;EAC9B,KAAK,MAAM,CAAC,QAAQ,UAAU;GAC5B,IAAI,UAAU,SAAS,SAAS,KAAA,GAC9B,MAAM,IAAI,MACR,yCAAyC,IAAI,2BAA2B,UAAU,SAAS,OAAO,OACpG;GAEF,MAAM,IAAI,GAAG;EACf;EACA,IAAI,MAAM,QAAQ,UAAU,SAAS,QACnC,MAAM,IAAI,MACR,8CAA8C,UAAU,SAAS,OAAO,sCAC1E;EAGF,OAAO,IAAI,qBAAqB,MAAM,QAAQ;CAChD;;;;;;CAOA,OAAO,eACL,KACA,OAAqC,CAAC,GACd;EACxB,IAAI,OAAO,IAAI,WAAW,UACxB,MAAM,IAAI,MACR,6EACF;EAEF,OAAO,aAAa,UAAU,IAAI,QAAQ,IAAI;CAChD;CAEA;CACA;CACA;CACA;CAEA,YACE,OACA,aACA;EAFiB,KAAA,QAAA;EACA,KAAA,cAAA;EAEjB,KAAK,KAAK,0BAA0B;GAClC,QAAQ,MAAM;GACd;EACF,CAAC;CACH;;CAGA,WAAyB;EACvB,OAAO,KAAK;CACd;;CAGA,mBAAgC;EAC9B,OAAO,KAAK,MAAM,iBAAiB;CACrC;CAEA,gBAAmC;EACjC,IAAI,KAAK,oBAAoB,KAAA,GAC3B,KAAK,kBAAkB,EAAE,OAAO,KAAK,MAAM,cAAc,EAAE;EAE7D,OAAO,KAAK,gBAAgB;CAC9B;;;;;;CAOA,UAAuB;EACrB,IAAI,KAAK,cAAc,KAAA,GACrB,KAAK,YAAY,EAAE,OAAO,iBAAiB,KAAK,MAAM,QAAQ,GAAG,KAAK,WAAW,EAAE;EAErF,OAAO,KAAK,UAAU;CACxB;;;;;;CAOA,WAAsB;EACpB,IAAI,KAAK,eAAe,KAAA,GAAW;GACjC,MAAM,aAAa,KAAK,MAAM,SAAS;GACvC,IAAI,KAAK,YAAY,WAAW,GAI9B,KAAK,aAAa,EAAE,OAAO,cAAc,YAAY,KAAK,MAAM,IAAI,KAAK,EAAE,EAAE;QACxE;IACL,MAAM,YAAY,KAAK,MAAM,QAAQ;IACrC,KAAK,aAAa,EAChB,OAAO;KACL,MAAM;KACN,OAAO,cAAc,YAAY,KAAK,MAAM,IAAI,KAAK,EAAE;KACvD,aAAa,KAAK,YAAY,KAAK,CAAC,KAAK,YAAY;MACnD,cAAc,eAAe,UAAU,SAAS,IAAI;MACpD,UAAU;KACZ,EAAE;IACJ,EACF;GACF;EACF;EACA,OAAO,KAAK,WAAW;CACzB;;;;;CAMA,UAAU,WAAwC;EAChD,OAAO,uBAAuB,KAAK,MAAM,SAAS;CACpD;AACF;AAEA,SAAS,eAAe,MAAoC;CAC1D,MAAM,WAA+B;EAAE,MAAM,KAAK;EAAM,MAAM,KAAK;CAAK;CACxE,IAAI,KAAK,WAAW,KAAA,KAAa,OAAO,KAAK,KAAK,MAAM,CAAC,CAAC,SAAS,GACjE,SAAS,SAAS,KAAK;CAEzB,IAAI,KAAK,kBAAkB,KAAA,KAAa,OAAO,KAAK,KAAK,aAAa,CAAC,CAAC,SAAS,GAC/E,SAAS,gBAAgB,KAAK;CAEhC,OAAO;AACT"}