@platforma-sdk/model 1.79.27 → 1.80.2

package/dist/columns/column_recipes/column_overrided_recipe.cjs

@@ -0,0 +1,101 @@
+const require_leaf_rebrand = require("./leaf_rebrand.cjs");
+const require_index = require("./index.cjs");
+let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
+//#region src/columns/column_recipes/column_overrided_recipe.ts
+/**
+* Recipe wrapper that overlays {@link SpecOverrides} on top of any other
+* recipe. The id is `ColumnOverriddenKey { source: inner.id, specOverrides }`.
+*
+* Flat-merge invariant: `inner` is never another {@link ColumnOverriddenRecipe}.
+* Repeated overrides go through {@link wrap} / {@link withSpecs}, which merge
+* `specOverrides` at the current level and keep wrapper depth constant.
+*
+* This invariant matches the one enforced inside `unwrapOverrides` from
+* pl-model-common: it explicitly throws on a nested override-wrap.
+*/
+var ColumnOverriddenRecipe = class ColumnOverriddenRecipe {
+	inner;
+	overrides;
+	/**
+	* Wrap any recipe with overrides. If `inner` is already a
+	* {@link ColumnOverriddenRecipe}, merges `overrides` into the existing ones
+	* and returns a new Overridden sharing the original `inner`. No
+	* `Overridden<Overridden<X>>` is produced.
+	*/
+	static wrap(col, overrides) {
+		if (col instanceof ColumnOverriddenRecipe) return new ColumnOverriddenRecipe(col.inner, (0, _milaboratories_pl_model_common.mergeSpecOverrides)(col.overrides, overrides));
+		return new ColumnOverriddenRecipe(col, overrides);
+	}
+	/**
+	* Static counterpart to {@link wrap}: returns the resolution status of a
+	* {@link ColumnOverriddenKey} without constructing the recipe. Overrides
+	* do not add references — status collapses to the source's status.
+	*/
+	static getStatusByKey(key, opts = {}) {
+		return require_index.ColumnRecipe.getStatus(key.source, opts);
+	}
+	id;
+	specCache;
+	queryCache;
+	dataStatusCache;
+	constructor(inner, overrides) {
+		this.inner = inner;
+		this.overrides = overrides;
+		this.id = (0, _milaboratories_pl_model_common.createColumnOverriddenId)({
+			source: inner.id,
+			specOverrides: overrides
+		});
+	}
+	/** Wrapped recipe — exposed so external walkers can descend. */
+	getInner() {
+		return this.inner;
+	}
+	/**
+	* `inner` owns all references; overrides are a pure spec patch and do not
+	* introduce new column refs.
+	*/
+	getReferencedIds() {
+		return this.inner.getReferencedIds();
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: this.inner.getDataStatus() };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Take the inner spec and overlay our overrides. `applySpecOverrides`
+	* extracts the overrides from `this.id` itself.
+	*/
+	getSpec() {
+		if (this.specCache === void 0) this.specCache = { value: (0, _milaboratories_pl_model_common.applySpecOverrides)(this.inner.getSpec(), this.id) };
+		return this.specCache.value;
+	}
+	/**
+	* Emit a client-side `specOverride` node wrapping the inner query.
+	*
+	* This is a structural-but-collapsible node: it carries the override
+	* patch through the query tree so consumers see the full recipe shape,
+	* but it is collapsed at the host boundary (`resolvePColumn`) before
+	* the query reaches pframe-engine. The engine never sees this node.
+	*
+	* Overrides do not change query topology — they are a pure spec patch.
+	*/
+	getQuery() {
+		if (this.queryCache === void 0) this.queryCache = { value: {
+			type: "specOverride",
+			input: require_leaf_rebrand.rebrandLeafId(this.inner.getQuery(), this.inner.id, this.id),
+			override: this.overrides
+		} };
+		return this.queryCache.value;
+	}
+	/**
+	* Flat merge: new overrides merge with existing ones; `inner` is unchanged.
+	* The result is an Overridden of the same depth.
+	*/
+	withSpecs(overrides) {
+		return ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+};
+//#endregion
+exports.ColumnOverriddenRecipe = ColumnOverriddenRecipe;
+
+//# sourceMappingURL=column_overrided_recipe.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"column_overrided_recipe.cjs","names":["ColumnRecipe","rebrandLeafId"],"sources":["../../../src/columns/column_recipes/column_overrided_recipe.ts"],"sourcesContent":["import {\n  applySpecOverrides,\n  createColumnOverriddenId,\n  mergeSpecOverrides,\n  type ColumnOverriddenId,\n  type ColumnOverriddenKey,\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 { Column } from \"../column\";\nimport { rebrandLeafId } from \"./leaf_rebrand\";\n\n/**\n * A recipe whose id is not an Overridden wrap — valid `source` for Overridden.\n * Mirrors the spec-level invariant on {@link ColumnOverriddenKey.source}.\n */\ntype NonOverriddenColumn = Column<Exclude<ColumnUniversalId, ColumnOverriddenId>>;\n\n/**\n * Recipe wrapper that overlays {@link SpecOverrides} on top of any other\n * recipe. The id is `ColumnOverriddenKey { source: inner.id, specOverrides }`.\n *\n * Flat-merge invariant: `inner` is never another {@link ColumnOverriddenRecipe}.\n * Repeated overrides go through {@link wrap} / {@link withSpecs}, which merge\n * `specOverrides` at the current level and keep wrapper depth constant.\n *\n * This invariant matches the one enforced inside `unwrapOverrides` from\n * pl-model-common: it explicitly throws on a nested override-wrap.\n */\nexport class ColumnOverriddenRecipe implements Column<ColumnOverriddenId> {\n  /**\n   * Wrap any recipe with overrides. If `inner` is already a\n   * {@link ColumnOverriddenRecipe}, merges `overrides` into the existing ones\n   * and returns a new Overridden sharing the original `inner`. No\n   * `Overridden<Overridden<X>>` is produced.\n   */\n  static wrap(col: Column, overrides: SpecOverrides): ColumnOverriddenRecipe {\n    if (col instanceof ColumnOverriddenRecipe) {\n      return new ColumnOverriddenRecipe(col.inner, mergeSpecOverrides(col.overrides, overrides));\n    }\n    // `inner` is not an Overridden wrap (the `instanceof` branch above handles\n    // that). Narrow the id union here so the constructor parameter stays\n    // honest with `ColumnOverriddenKey.source`.\n    return new ColumnOverriddenRecipe(col as NonOverriddenColumn, overrides);\n  }\n\n  /**\n   * Static counterpart to {@link wrap}: returns the resolution status of a\n   * {@link ColumnOverriddenKey} without constructing the recipe. Overrides\n   * do not add references — status collapses to the source's status.\n   */\n  static getStatusByKey(\n    key: ColumnOverriddenKey,\n    opts: { ctx?: GlobalCfgRenderCtx } = {},\n  ): ColumnResolutionStatus {\n    return ColumnRecipe.getStatus(key.source, opts);\n  }\n\n  readonly id: ColumnOverriddenId;\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: NonOverriddenColumn,\n    private readonly overrides: SpecOverrides,\n  ) {\n    this.id = createColumnOverriddenId({\n      source: inner.id,\n      specOverrides: overrides,\n    });\n  }\n\n  /** Wrapped recipe — exposed so external walkers can descend. */\n  getInner(): Column {\n    return this.inner;\n  }\n\n  /**\n   * `inner` owns all references; overrides are a pure spec patch and do not\n   * introduce new column refs.\n   */\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   * Take the inner spec and overlay our overrides. `applySpecOverrides`\n   * extracts the overrides from `this.id` itself.\n   */\n  getSpec(): PColumnSpec {\n    if (this.specCache === undefined) {\n      this.specCache = { value: applySpecOverrides(this.inner.getSpec(), this.id) };\n    }\n    return this.specCache.value;\n  }\n\n  /**\n   * Emit a client-side `specOverride` node wrapping the inner query.\n   *\n   * This is a structural-but-collapsible node: it carries the override\n   * patch through the query tree so consumers see the full recipe shape,\n   * but it is collapsed at the host boundary (`resolvePColumn`) before\n   * the query reaches pframe-engine. The engine never sees this node.\n   *\n   * Overrides do not change query topology — they are a pure spec patch.\n   */\n  getQuery(): SpecQuery {\n    if (this.queryCache === undefined) {\n      // Rebrand the inner column leaf to this.id (rich Overridden id) so\n      // filter/sort references emitted with this recipe's id match the\n      // leaf the engine sees. The specOverride node still wraps the leaf\n      // and is collapsed at the host boundary into a spec patch on the\n      // resolved PColumn.\n      this.queryCache = {\n        value: {\n          type: \"specOverride\",\n          input: rebrandLeafId(this.inner.getQuery(), this.inner.id, this.id),\n          override: this.overrides,\n        },\n      };\n    }\n    return this.queryCache.value;\n  }\n\n  /**\n   * Flat merge: new overrides merge with existing ones; `inner` is unchanged.\n   * The result is an Overridden of the same depth.\n   */\n  withSpecs(overrides: SpecOverrides): Column {\n    return ColumnOverriddenRecipe.wrap(this, overrides);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmCA,IAAa,yBAAb,MAAa,uBAA6D;CAmCrD;CACA;;;;;;;CA7BnB,OAAO,KAAK,KAAa,WAAkD;EACzE,IAAI,eAAe,wBACjB,OAAO,IAAI,uBAAuB,IAAI,QAAA,GAAA,gCAAA,mBAAA,CAA0B,IAAI,WAAW,SAAS,CAAC;EAK3F,OAAO,IAAI,uBAAuB,KAA4B,SAAS;CACzE;;;;;;CAOA,OAAO,eACL,KACA,OAAqC,CAAC,GACd;EACxB,OAAOA,cAAAA,aAAa,UAAU,IAAI,QAAQ,IAAI;CAChD;CAEA;CACA;CACA;CACA;CAEA,YACE,OACA,WACA;EAFiB,KAAA,QAAA;EACA,KAAA,YAAA;EAEjB,KAAK,MAAA,GAAA,gCAAA,yBAAA,CAA8B;GACjC,QAAQ,MAAM;GACd,eAAe;EACjB,CAAC;CACH;;CAGA,WAAmB;EACjB,OAAO,KAAK;CACd;;;;;CAMA,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;;;;;CAMA,UAAuB;EACrB,IAAI,KAAK,cAAc,KAAA,GACrB,KAAK,YAAY,EAAE,QAAA,GAAA,gCAAA,mBAAA,CAA0B,KAAK,MAAM,QAAQ,GAAG,KAAK,EAAE,EAAE;EAE9E,OAAO,KAAK,UAAU;CACxB;;;;;;;;;;;CAYA,WAAsB;EACpB,IAAI,KAAK,eAAe,KAAA,GAMtB,KAAK,aAAa,EAChB,OAAO;GACL,MAAM;GACN,OAAOC,qBAAAA,cAAc,KAAK,MAAM,SAAS,GAAG,KAAK,MAAM,IAAI,KAAK,EAAE;GAClE,UAAU,KAAK;EACjB,EACF;EAEF,OAAO,KAAK,WAAW;CACzB;;;;;CAMA,UAAU,WAAkC;EAC1C,OAAO,uBAAuB,KAAK,MAAM,SAAS;CACpD;AACF"}

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

@@ -0,0 +1,73 @@
+import { GlobalCfgRenderCtx } from "../../render/internal.js";
+import { ColumnFieldStatus, ColumnResolutionStatus } from "./types.js";
+import { Column } from "../column.js";
+import { ColumnOverriddenId, ColumnOverriddenKey, PColumnSpec, PObjectId, SpecOverrides, SpecQuery } from "@milaboratories/pl-model-common";
+
+//#region src/columns/column_recipes/column_overrided_recipe.d.ts
+/**
+ * Recipe wrapper that overlays {@link SpecOverrides} on top of any other
+ * recipe. The id is `ColumnOverriddenKey { source: inner.id, specOverrides }`.
+ *
+ * Flat-merge invariant: `inner` is never another {@link ColumnOverriddenRecipe}.
+ * Repeated overrides go through {@link wrap} / {@link withSpecs}, which merge
+ * `specOverrides` at the current level and keep wrapper depth constant.
+ *
+ * This invariant matches the one enforced inside `unwrapOverrides` from
+ * pl-model-common: it explicitly throws on a nested override-wrap.
+ */
+declare class ColumnOverriddenRecipe implements Column<ColumnOverriddenId> {
+  private readonly inner;
+  private readonly overrides;
+  /**
+   * Wrap any recipe with overrides. If `inner` is already a
+   * {@link ColumnOverriddenRecipe}, merges `overrides` into the existing ones
+   * and returns a new Overridden sharing the original `inner`. No
+   * `Overridden<Overridden<X>>` is produced.
+   */
+  static wrap(col: Column, overrides: SpecOverrides): ColumnOverriddenRecipe;
+  /**
+   * Static counterpart to {@link wrap}: returns the resolution status of a
+   * {@link ColumnOverriddenKey} without constructing the recipe. Overrides
+   * do not add references — status collapses to the source's status.
+   */
+  static getStatusByKey(key: ColumnOverriddenKey, opts?: {
+    ctx?: GlobalCfgRenderCtx;
+  }): ColumnResolutionStatus;
+  readonly id: ColumnOverriddenId;
+  private specCache?;
+  private queryCache?;
+  private dataStatusCache?;
+  private constructor();
+  /** Wrapped recipe — exposed so external walkers can descend. */
+  getInner(): Column;
+  /**
+   * `inner` owns all references; overrides are a pure spec patch and do not
+   * introduce new column refs.
+   */
+  getReferencedIds(): PObjectId[];
+  getDataStatus(): ColumnFieldStatus;
+  /**
+   * Take the inner spec and overlay our overrides. `applySpecOverrides`
+   * extracts the overrides from `this.id` itself.
+   */
+  getSpec(): PColumnSpec;
+  /**
+   * Emit a client-side `specOverride` node wrapping the inner query.
+   *
+   * This is a structural-but-collapsible node: it carries the override
+   * patch through the query tree so consumers see the full recipe shape,
+   * but it is collapsed at the host boundary (`resolvePColumn`) before
+   * the query reaches pframe-engine. The engine never sees this node.
+   *
+   * Overrides do not change query topology — they are a pure spec patch.
+   */
+  getQuery(): SpecQuery;
+  /**
+   * Flat merge: new overrides merge with existing ones; `inner` is unchanged.
+   * The result is an Overridden of the same depth.
+   */
+  withSpecs(overrides: SpecOverrides): Column;
+}
+//#endregion
+export { ColumnOverriddenRecipe };
+//# sourceMappingURL=column_overrided_recipe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"column_overrided_recipe.d.ts","names":[],"sources":["../../../src/columns/column_recipes/column_overrided_recipe.ts"],"mappings":";;;;;;;;AAmCA;;;;;;;;;cAAa,sBAAA,YAAkC,MAAA,CAAO,kBAAA;EAAA,iBAmCjC,KAAA;EAAA,iBACA,SAAA;EAiBC;;;;;;EAAA,OA9Cb,IAAA,CAAK,GAAA,EAAK,MAAA,EAAQ,SAAA,EAAW,aAAA,GAAgB,sBAAA;EAPD;;;;;EAAA,OAsB5C,cAAA,CACL,GAAA,EAAK,mBAAA,EACL,IAAA;IAAQ,GAAA,GAAM,kBAAA;EAAA,IACb,sBAAA;EAAA,SAIM,EAAA,EAAI,kBAAA;EAAA,QACL,SAAA;EAAA,QACA,UAAA;EAAA,QACA,eAAA;EAAA,QAED,WAAA;EAXA;EAsBP,QAAA,IAAY,MAAA;EArBF;;;;EA6BV,gBAAA,IAAoB,SAAA;EAIpB,aAAA,IAAiB,iBAAA;EA3BT;;;;EAsCR,OAAA,IAAW,WAAA;EAvBC;;;;;;;;;;EAwCZ,QAAA,IAAY,SAAA;EAsBF;;;AAAiC;EAA3C,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,MAAA;AAAA"}

package/dist/columns/column_recipes/column_overrided_recipe.js

@@ -0,0 +1,101 @@
+import { rebrandLeafId } from "./leaf_rebrand.js";
+import { ColumnRecipe } from "./index.js";
+import { applySpecOverrides, createColumnOverriddenId, mergeSpecOverrides } from "@milaboratories/pl-model-common";
+//#region src/columns/column_recipes/column_overrided_recipe.ts
+/**
+* Recipe wrapper that overlays {@link SpecOverrides} on top of any other
+* recipe. The id is `ColumnOverriddenKey { source: inner.id, specOverrides }`.
+*
+* Flat-merge invariant: `inner` is never another {@link ColumnOverriddenRecipe}.
+* Repeated overrides go through {@link wrap} / {@link withSpecs}, which merge
+* `specOverrides` at the current level and keep wrapper depth constant.
+*
+* This invariant matches the one enforced inside `unwrapOverrides` from
+* pl-model-common: it explicitly throws on a nested override-wrap.
+*/
+var ColumnOverriddenRecipe = class ColumnOverriddenRecipe {
+	inner;
+	overrides;
+	/**
+	* Wrap any recipe with overrides. If `inner` is already a
+	* {@link ColumnOverriddenRecipe}, merges `overrides` into the existing ones
+	* and returns a new Overridden sharing the original `inner`. No
+	* `Overridden<Overridden<X>>` is produced.
+	*/
+	static wrap(col, overrides) {
+		if (col instanceof ColumnOverriddenRecipe) return new ColumnOverriddenRecipe(col.inner, mergeSpecOverrides(col.overrides, overrides));
+		return new ColumnOverriddenRecipe(col, overrides);
+	}
+	/**
+	* Static counterpart to {@link wrap}: returns the resolution status of a
+	* {@link ColumnOverriddenKey} without constructing the recipe. Overrides
+	* do not add references — status collapses to the source's status.
+	*/
+	static getStatusByKey(key, opts = {}) {
+		return ColumnRecipe.getStatus(key.source, opts);
+	}
+	id;
+	specCache;
+	queryCache;
+	dataStatusCache;
+	constructor(inner, overrides) {
+		this.inner = inner;
+		this.overrides = overrides;
+		this.id = createColumnOverriddenId({
+			source: inner.id,
+			specOverrides: overrides
+		});
+	}
+	/** Wrapped recipe — exposed so external walkers can descend. */
+	getInner() {
+		return this.inner;
+	}
+	/**
+	* `inner` owns all references; overrides are a pure spec patch and do not
+	* introduce new column refs.
+	*/
+	getReferencedIds() {
+		return this.inner.getReferencedIds();
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: this.inner.getDataStatus() };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Take the inner spec and overlay our overrides. `applySpecOverrides`
+	* extracts the overrides from `this.id` itself.
+	*/
+	getSpec() {
+		if (this.specCache === void 0) this.specCache = { value: applySpecOverrides(this.inner.getSpec(), this.id) };
+		return this.specCache.value;
+	}
+	/**
+	* Emit a client-side `specOverride` node wrapping the inner query.
+	*
+	* This is a structural-but-collapsible node: it carries the override
+	* patch through the query tree so consumers see the full recipe shape,
+	* but it is collapsed at the host boundary (`resolvePColumn`) before
+	* the query reaches pframe-engine. The engine never sees this node.
+	*
+	* Overrides do not change query topology — they are a pure spec patch.
+	*/
+	getQuery() {
+		if (this.queryCache === void 0) this.queryCache = { value: {
+			type: "specOverride",
+			input: rebrandLeafId(this.inner.getQuery(), this.inner.id, this.id),
+			override: this.overrides
+		} };
+		return this.queryCache.value;
+	}
+	/**
+	* Flat merge: new overrides merge with existing ones; `inner` is unchanged.
+	* The result is an Overridden of the same depth.
+	*/
+	withSpecs(overrides) {
+		return ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+};
+//#endregion
+export { ColumnOverriddenRecipe };
+
+//# sourceMappingURL=column_overrided_recipe.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"column_overrided_recipe.js","names":[],"sources":["../../../src/columns/column_recipes/column_overrided_recipe.ts"],"sourcesContent":["import {\n  applySpecOverrides,\n  createColumnOverriddenId,\n  mergeSpecOverrides,\n  type ColumnOverriddenId,\n  type ColumnOverriddenKey,\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 { Column } from \"../column\";\nimport { rebrandLeafId } from \"./leaf_rebrand\";\n\n/**\n * A recipe whose id is not an Overridden wrap — valid `source` for Overridden.\n * Mirrors the spec-level invariant on {@link ColumnOverriddenKey.source}.\n */\ntype NonOverriddenColumn = Column<Exclude<ColumnUniversalId, ColumnOverriddenId>>;\n\n/**\n * Recipe wrapper that overlays {@link SpecOverrides} on top of any other\n * recipe. The id is `ColumnOverriddenKey { source: inner.id, specOverrides }`.\n *\n * Flat-merge invariant: `inner` is never another {@link ColumnOverriddenRecipe}.\n * Repeated overrides go through {@link wrap} / {@link withSpecs}, which merge\n * `specOverrides` at the current level and keep wrapper depth constant.\n *\n * This invariant matches the one enforced inside `unwrapOverrides` from\n * pl-model-common: it explicitly throws on a nested override-wrap.\n */\nexport class ColumnOverriddenRecipe implements Column<ColumnOverriddenId> {\n  /**\n   * Wrap any recipe with overrides. If `inner` is already a\n   * {@link ColumnOverriddenRecipe}, merges `overrides` into the existing ones\n   * and returns a new Overridden sharing the original `inner`. No\n   * `Overridden<Overridden<X>>` is produced.\n   */\n  static wrap(col: Column, overrides: SpecOverrides): ColumnOverriddenRecipe {\n    if (col instanceof ColumnOverriddenRecipe) {\n      return new ColumnOverriddenRecipe(col.inner, mergeSpecOverrides(col.overrides, overrides));\n    }\n    // `inner` is not an Overridden wrap (the `instanceof` branch above handles\n    // that). Narrow the id union here so the constructor parameter stays\n    // honest with `ColumnOverriddenKey.source`.\n    return new ColumnOverriddenRecipe(col as NonOverriddenColumn, overrides);\n  }\n\n  /**\n   * Static counterpart to {@link wrap}: returns the resolution status of a\n   * {@link ColumnOverriddenKey} without constructing the recipe. Overrides\n   * do not add references — status collapses to the source's status.\n   */\n  static getStatusByKey(\n    key: ColumnOverriddenKey,\n    opts: { ctx?: GlobalCfgRenderCtx } = {},\n  ): ColumnResolutionStatus {\n    return ColumnRecipe.getStatus(key.source, opts);\n  }\n\n  readonly id: ColumnOverriddenId;\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: NonOverriddenColumn,\n    private readonly overrides: SpecOverrides,\n  ) {\n    this.id = createColumnOverriddenId({\n      source: inner.id,\n      specOverrides: overrides,\n    });\n  }\n\n  /** Wrapped recipe — exposed so external walkers can descend. */\n  getInner(): Column {\n    return this.inner;\n  }\n\n  /**\n   * `inner` owns all references; overrides are a pure spec patch and do not\n   * introduce new column refs.\n   */\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   * Take the inner spec and overlay our overrides. `applySpecOverrides`\n   * extracts the overrides from `this.id` itself.\n   */\n  getSpec(): PColumnSpec {\n    if (this.specCache === undefined) {\n      this.specCache = { value: applySpecOverrides(this.inner.getSpec(), this.id) };\n    }\n    return this.specCache.value;\n  }\n\n  /**\n   * Emit a client-side `specOverride` node wrapping the inner query.\n   *\n   * This is a structural-but-collapsible node: it carries the override\n   * patch through the query tree so consumers see the full recipe shape,\n   * but it is collapsed at the host boundary (`resolvePColumn`) before\n   * the query reaches pframe-engine. The engine never sees this node.\n   *\n   * Overrides do not change query topology — they are a pure spec patch.\n   */\n  getQuery(): SpecQuery {\n    if (this.queryCache === undefined) {\n      // Rebrand the inner column leaf to this.id (rich Overridden id) so\n      // filter/sort references emitted with this recipe's id match the\n      // leaf the engine sees. The specOverride node still wraps the leaf\n      // and is collapsed at the host boundary into a spec patch on the\n      // resolved PColumn.\n      this.queryCache = {\n        value: {\n          type: \"specOverride\",\n          input: rebrandLeafId(this.inner.getQuery(), this.inner.id, this.id),\n          override: this.overrides,\n        },\n      };\n    }\n    return this.queryCache.value;\n  }\n\n  /**\n   * Flat merge: new overrides merge with existing ones; `inner` is unchanged.\n   * The result is an Overridden of the same depth.\n   */\n  withSpecs(overrides: SpecOverrides): Column {\n    return ColumnOverriddenRecipe.wrap(this, overrides);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmCA,IAAa,yBAAb,MAAa,uBAA6D;CAmCrD;CACA;;;;;;;CA7BnB,OAAO,KAAK,KAAa,WAAkD;EACzE,IAAI,eAAe,wBACjB,OAAO,IAAI,uBAAuB,IAAI,OAAO,mBAAmB,IAAI,WAAW,SAAS,CAAC;EAK3F,OAAO,IAAI,uBAAuB,KAA4B,SAAS;CACzE;;;;;;CAOA,OAAO,eACL,KACA,OAAqC,CAAC,GACd;EACxB,OAAO,aAAa,UAAU,IAAI,QAAQ,IAAI;CAChD;CAEA;CACA;CACA;CACA;CAEA,YACE,OACA,WACA;EAFiB,KAAA,QAAA;EACA,KAAA,YAAA;EAEjB,KAAK,KAAK,yBAAyB;GACjC,QAAQ,MAAM;GACd,eAAe;EACjB,CAAC;CACH;;CAGA,WAAmB;EACjB,OAAO,KAAK;CACd;;;;;CAMA,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;;;;;CAMA,UAAuB;EACrB,IAAI,KAAK,cAAc,KAAA,GACrB,KAAK,YAAY,EAAE,OAAO,mBAAmB,KAAK,MAAM,QAAQ,GAAG,KAAK,EAAE,EAAE;EAE9E,OAAO,KAAK,UAAU;CACxB;;;;;;;;;;;CAYA,WAAsB;EACpB,IAAI,KAAK,eAAe,KAAA,GAMtB,KAAK,aAAa,EAChB,OAAO;GACL,MAAM;GACN,OAAO,cAAc,KAAK,MAAM,SAAS,GAAG,KAAK,MAAM,IAAI,KAAK,EAAE;GAClE,UAAU,KAAK;EACjB,EACF;EAEF,OAAO,KAAK,WAAW;CACzB;;;;;CAMA,UAAU,WAAkC;EAC1C,OAAO,uBAAuB,KAAK,MAAM,SAAS;CACpD;AACF"}

package/dist/columns/column_recipes/index.cjs

@@ -0,0 +1,72 @@
+const require_column_discovered_recipe = require("./column_discovered_recipe.cjs");
+const require_column_filtered_recipe = require("./column_filtered_recipe.cjs");
+const require_column_overrided_recipe = require("./column_overrided_recipe.cjs");
+const require_column_lazy = require("../column_lazy.cjs");
+let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
+//#region src/columns/column_recipes/index.ts
+/**
+* Build a `ColumnRecipe` from a stringified id. Dispatches to the matching
+* concrete recipe variant based on the id's encoding and recurses on
+* wrappers' inner `source`:
+*
+*   - bare {@link PObjectId} (non-JSON)               → `ColumnLazy.fromId`
+*   - `ColumnDiscoveredKey`                          → {@link ColumnDiscoveredRecipe}
+*   - `ColumnOverriddenKey { source, specOverrides }` → recurse on `source`,
+*                                                       then {@link ColumnOverriddenRecipe.wrap}
+*   - `ColumnFilteredKey { source, axisFilters }`     → recurse on `source`,
+*                                                       then {@link ColumnFilteredRecipe.wrap}
+*
+* Returns `undefined` for unsupported variants (e.g. AnchoredPColumnId,
+* which needs an anchor map to resolve) or when a nested source itself
+* cannot be built.
+*/
+function ColumnRecipeBuild(id, opts = {}) {
+	const parsed = (0, _milaboratories_pl_model_common.parseColumnIdSafely)(id);
+	if ((0, _milaboratories_pl_model_common.isPObjectKey)(parsed)) return require_column_lazy.ColumnLazyImpl.fromId(id, opts);
+	if ((0, _milaboratories_pl_model_common.isColumnDiscoveredKey)(parsed)) return require_column_discovered_recipe.ColumnDiscoveredRecipe.fromKey(parsed, opts);
+	if ((0, _milaboratories_pl_model_common.isColumnOverriddenKey)(parsed)) {
+		const inner = ColumnRecipe(parsed.source, opts);
+		if (inner === void 0) return void 0;
+		return require_column_overrided_recipe.ColumnOverriddenRecipe.wrap(inner, parsed.specOverrides);
+	}
+	if ((0, _milaboratories_pl_model_common.isColumnFilteredKey)(parsed)) {
+		if (typeof parsed.source !== "string") throw new Error(`Unsupported ColumnRecipe id variant: filtered column with non-string source (${JSON.stringify(parsed.source)})`);
+		const inner = ColumnRecipe(parsed.source, opts);
+		if (inner === void 0) return void 0;
+		return require_column_filtered_recipe.ColumnFilteredRecipe.wrap(inner, parsed.axisFilters);
+	}
+	throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);
+}
+/**
+* Resolution status counterpart to {@link ColumnRecipeBuild}. Dispatches on
+* the parsed id shape to the matching `getStatusBy*` static — never
+* constructs the recipe. Use this at boundaries (resolver, filter/sort
+* targets) to throw early on `absent` instead of silently producing an empty
+* recipe via {@link ColumnRecipeBuild}.
+*/
+function ColumnRecipeGetStatus(id, opts = {}) {
+	const parsed = (0, _milaboratories_pl_model_common.parseColumnIdSafely)(id);
+	if ((0, _milaboratories_pl_model_common.isPObjectKey)(parsed)) return require_column_lazy.ColumnLazyImpl.getStatusById(id, opts);
+	if ((0, _milaboratories_pl_model_common.isColumnDiscoveredKey)(parsed)) return require_column_discovered_recipe.ColumnDiscoveredRecipe.getStatusByKey(parsed, opts);
+	if ((0, _milaboratories_pl_model_common.isColumnOverriddenKey)(parsed)) return require_column_overrided_recipe.ColumnOverriddenRecipe.getStatusByKey(parsed, opts);
+	if ((0, _milaboratories_pl_model_common.isColumnFilteredKey)(parsed)) return require_column_filtered_recipe.ColumnFilteredRecipe.getStatusByKey(parsed, opts);
+	throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);
+}
+const ColumnRecipe = Object.assign(ColumnRecipeBuild, { getStatus: ColumnRecipeGetStatus });
+/**
+* Type-guard for any recipe class — leaf {@link ColumnLazyImpl} or any of the
+* wrapper recipes ({@link ColumnDiscoveredRecipe}, {@link ColumnFilteredRecipe},
+* {@link ColumnOverriddenRecipe}). Use when a value may be a raw id, a `PColumn`,
+* or a recipe and you want to branch on the recipe case.
+*/
+function isColumnRecipe(value) {
+	return value instanceof require_column_lazy.ColumnLazyImpl || value instanceof require_column_discovered_recipe.ColumnDiscoveredRecipe || value instanceof require_column_filtered_recipe.ColumnFilteredRecipe || value instanceof require_column_overrided_recipe.ColumnOverriddenRecipe;
+}
+//#endregion
+exports.ColumnDiscoveredRecipe = require_column_discovered_recipe.ColumnDiscoveredRecipe;
+exports.ColumnFilteredRecipe = require_column_filtered_recipe.ColumnFilteredRecipe;
+exports.ColumnOverriddenRecipe = require_column_overrided_recipe.ColumnOverriddenRecipe;
+exports.ColumnRecipe = ColumnRecipe;
+exports.isColumnRecipe = isColumnRecipe;
+
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["ColumnLazyImpl","ColumnDiscoveredRecipe","ColumnOverriddenRecipe","ColumnFilteredRecipe"],"sources":["../../../src/columns/column_recipes/index.ts"],"sourcesContent":["import {\n  isColumnDiscoveredKey,\n  isColumnOverriddenKey,\n  parseColumnIdSafely,\n  type ColumnUniversalId,\n  type PObjectId,\n  isPObjectKey,\n  isColumnFilteredKey,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx } from \"../../render/internal\";\nimport { ColumnLazyImpl } from \"../column_lazy\";\nimport { ColumnDiscoveredRecipe } from \"./column_discovered_recipe\";\nimport { ColumnFilteredRecipe } from \"./column_filtered_recipe\";\nimport { ColumnOverriddenRecipe } from \"./column_overrided_recipe\";\nimport type {\n  ColumnRecipe as ColumnRecipeBase,\n  ColumnRecipeId,\n  ColumnResolutionStatus,\n} from \"./types\";\n\nexport type { ColumnFieldStatus, ColumnRecipeId, ColumnResolutionStatus, SpecQuery } from \"./types\";\nexport { ColumnAbsentError } from \"../column_lazy\";\nexport { ColumnDiscoveredRecipe } from \"./column_discovered_recipe\";\nexport { ColumnFilteredRecipe } from \"./column_filtered_recipe\";\nexport { ColumnOverriddenRecipe } from \"./column_overrided_recipe\";\n\n// Re-declare the interface locally so the name can merge with the dispatcher\n// value declared below: a single name `ColumnRecipe` resolves to the\n// interface in type position and to the factory function (`Object.assign`d\n// with `.getStatus`) in value position.\n// (Type-only re-exports do not participate in TS declaration merging.)\nexport interface ColumnRecipe<\n  ID extends ColumnRecipeId = ColumnRecipeId,\n> extends ColumnRecipeBase<ID> {}\n\n/**\n * Build a `ColumnRecipe` from a stringified id. Dispatches to the matching\n * concrete recipe variant based on the id's encoding and recurses on\n * wrappers' inner `source`:\n *\n *   - bare {@link PObjectId} (non-JSON)               → `ColumnLazy.fromId`\n *   - `ColumnDiscoveredKey`                          → {@link ColumnDiscoveredRecipe}\n *   - `ColumnOverriddenKey { source, specOverrides }` → recurse on `source`,\n *                                                       then {@link ColumnOverriddenRecipe.wrap}\n *   - `ColumnFilteredKey { source, axisFilters }`     → recurse on `source`,\n *                                                       then {@link ColumnFilteredRecipe.wrap}\n *\n * Returns `undefined` for unsupported variants (e.g. AnchoredPColumnId,\n * which needs an anchor map to resolve) or when a nested source itself\n * cannot be built.\n */\nfunction ColumnRecipeBuild(\n  id: ColumnUniversalId,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): undefined | ColumnRecipe {\n  const parsed = parseColumnIdSafely(id);\n\n  if (isPObjectKey(parsed)) {\n    return ColumnLazyImpl.fromId(id as PObjectId, opts);\n  }\n\n  if (isColumnDiscoveredKey(parsed)) {\n    return ColumnDiscoveredRecipe.fromKey(parsed, opts);\n  }\n\n  if (isColumnOverriddenKey(parsed)) {\n    const inner = ColumnRecipe(parsed.source, opts);\n    if (inner === undefined) return undefined;\n    return ColumnOverriddenRecipe.wrap(inner, parsed.specOverrides);\n  }\n\n  if (isColumnFilteredKey(parsed)) {\n    // ColumnFilteredKey.source is a stringified ColumnUniversalId (leaf or\n    // any nested wrapper). Legacy `FilteredPColumnId` with an AnchoredPColumnId\n    // (object) source is not supported here — guard against it explicitly.\n    if (typeof parsed.source !== \"string\") {\n      throw new Error(\n        `Unsupported ColumnRecipe id variant: filtered column with non-string source (${JSON.stringify(parsed.source)})`,\n      );\n    }\n    const inner = ColumnRecipe(parsed.source, opts);\n    if (inner === undefined) return undefined;\n    return ColumnFilteredRecipe.wrap(inner, parsed.axisFilters);\n  }\n\n  throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);\n}\n\n/**\n * Resolution status counterpart to {@link ColumnRecipeBuild}. Dispatches on\n * the parsed id shape to the matching `getStatusBy*` static — never\n * constructs the recipe. Use this at boundaries (resolver, filter/sort\n * targets) to throw early on `absent` instead of silently producing an empty\n * recipe via {@link ColumnRecipeBuild}.\n */\nfunction ColumnRecipeGetStatus(\n  id: ColumnUniversalId,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): ColumnResolutionStatus {\n  const parsed = parseColumnIdSafely(id);\n  if (isPObjectKey(parsed)) return ColumnLazyImpl.getStatusById(id as PObjectId, opts);\n  if (isColumnDiscoveredKey(parsed)) return ColumnDiscoveredRecipe.getStatusByKey(parsed, opts);\n  if (isColumnOverriddenKey(parsed)) return ColumnOverriddenRecipe.getStatusByKey(parsed, opts);\n  if (isColumnFilteredKey(parsed)) return ColumnFilteredRecipe.getStatusByKey(parsed, opts);\n  throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);\n}\n\nexport const ColumnRecipe: typeof ColumnRecipeBuild & {\n  readonly getStatus: typeof ColumnRecipeGetStatus;\n} = Object.assign(ColumnRecipeBuild, {\n  getStatus: ColumnRecipeGetStatus,\n});\n\n/**\n * Type-guard for any recipe class — leaf {@link ColumnLazyImpl} or any of the\n * wrapper recipes ({@link ColumnDiscoveredRecipe}, {@link ColumnFilteredRecipe},\n * {@link ColumnOverriddenRecipe}). Use when a value may be a raw id, a `PColumn`,\n * or a recipe and you want to branch on the recipe case.\n */\nexport function isColumnRecipe(value: unknown): value is ColumnRecipe {\n  return (\n    value instanceof ColumnLazyImpl ||\n    value instanceof ColumnDiscoveredRecipe ||\n    value instanceof ColumnFilteredRecipe ||\n    value instanceof ColumnOverriddenRecipe\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAS,kBACP,IACA,OAAqC,CAAC,GACZ;CAC1B,MAAM,UAAA,GAAA,gCAAA,oBAAA,CAA6B,EAAE;CAErC,KAAA,GAAA,gCAAA,aAAA,CAAiB,MAAM,GACrB,OAAOA,oBAAAA,eAAe,OAAO,IAAiB,IAAI;CAGpD,KAAA,GAAA,gCAAA,sBAAA,CAA0B,MAAM,GAC9B,OAAOC,iCAAAA,uBAAuB,QAAQ,QAAQ,IAAI;CAGpD,KAAA,GAAA,gCAAA,sBAAA,CAA0B,MAAM,GAAG;EACjC,MAAM,QAAQ,aAAa,OAAO,QAAQ,IAAI;EAC9C,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;EAChC,OAAOC,gCAAAA,uBAAuB,KAAK,OAAO,OAAO,aAAa;CAChE;CAEA,KAAA,GAAA,gCAAA,oBAAA,CAAwB,MAAM,GAAG;EAI/B,IAAI,OAAO,OAAO,WAAW,UAC3B,MAAM,IAAI,MACR,gFAAgF,KAAK,UAAU,OAAO,MAAM,EAAE,EAChH;EAEF,MAAM,QAAQ,aAAa,OAAO,QAAQ,IAAI;EAC9C,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;EAChC,OAAOC,+BAAAA,qBAAqB,KAAK,OAAO,OAAO,WAAW;CAC5D;CAEA,MAAM,IAAI,MAAM,wCAAwC,IAAI;AAC9D;;;;;;;;AASA,SAAS,sBACP,IACA,OAAqC,CAAC,GACd;CACxB,MAAM,UAAA,GAAA,gCAAA,oBAAA,CAA6B,EAAE;CACrC,KAAA,GAAA,gCAAA,aAAA,CAAiB,MAAM,GAAG,OAAOH,oBAAAA,eAAe,cAAc,IAAiB,IAAI;CACnF,KAAA,GAAA,gCAAA,sBAAA,CAA0B,MAAM,GAAG,OAAOC,iCAAAA,uBAAuB,eAAe,QAAQ,IAAI;CAC5F,KAAA,GAAA,gCAAA,sBAAA,CAA0B,MAAM,GAAG,OAAOC,gCAAAA,uBAAuB,eAAe,QAAQ,IAAI;CAC5F,KAAA,GAAA,gCAAA,oBAAA,CAAwB,MAAM,GAAG,OAAOC,+BAAAA,qBAAqB,eAAe,QAAQ,IAAI;CACxF,MAAM,IAAI,MAAM,wCAAwC,IAAI;AAC9D;AAEA,MAAa,eAET,OAAO,OAAO,mBAAmB,EACnC,WAAW,sBACb,CAAC;;;;;;;AAQD,SAAgB,eAAe,OAAuC;CACpE,OACE,iBAAiBH,oBAAAA,kBACjB,iBAAiBC,iCAAAA,0BACjB,iBAAiBE,+BAAAA,wBACjB,iBAAiBD,gCAAAA;AAErB"}

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

@@ -0,0 +1,52 @@
+import { GlobalCfgRenderCtx } from "../../render/internal.js";
+import { ColumnFieldStatus, ColumnRecipe as ColumnRecipe$1, ColumnRecipeId, ColumnResolutionStatus, SpecQuery as SpecQuery$1 } from "./types.js";
+import { ColumnAbsentError } from "../column_lazy.js";
+import { ColumnDiscoveredRecipe } from "./column_discovered_recipe.js";
+import { ColumnFilteredRecipe } from "./column_filtered_recipe.js";
+import { ColumnOverriddenRecipe } from "./column_overrided_recipe.js";
+import { ColumnUniversalId } from "@milaboratories/pl-model-common";
+
+//#region src/columns/column_recipes/index.d.ts
+interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> extends ColumnRecipe$1<ID> {}
+/**
+ * Build a `ColumnRecipe` from a stringified id. Dispatches to the matching
+ * concrete recipe variant based on the id's encoding and recurses on
+ * wrappers' inner `source`:
+ *
+ *   - bare {@link PObjectId} (non-JSON)               → `ColumnLazy.fromId`
+ *   - `ColumnDiscoveredKey`                          → {@link ColumnDiscoveredRecipe}
+ *   - `ColumnOverriddenKey { source, specOverrides }` → recurse on `source`,
+ *                                                       then {@link ColumnOverriddenRecipe.wrap}
+ *   - `ColumnFilteredKey { source, axisFilters }`     → recurse on `source`,
+ *                                                       then {@link ColumnFilteredRecipe.wrap}
+ *
+ * Returns `undefined` for unsupported variants (e.g. AnchoredPColumnId,
+ * which needs an anchor map to resolve) or when a nested source itself
+ * cannot be built.
+ */
+declare function ColumnRecipeBuild(id: ColumnUniversalId, opts?: {
+  ctx?: GlobalCfgRenderCtx;
+}): undefined | ColumnRecipe;
+/**
+ * Resolution status counterpart to {@link ColumnRecipeBuild}. Dispatches on
+ * the parsed id shape to the matching `getStatusBy*` static — never
+ * constructs the recipe. Use this at boundaries (resolver, filter/sort
+ * targets) to throw early on `absent` instead of silently producing an empty
+ * recipe via {@link ColumnRecipeBuild}.
+ */
+declare function ColumnRecipeGetStatus(id: ColumnUniversalId, opts?: {
+  ctx?: GlobalCfgRenderCtx;
+}): ColumnResolutionStatus;
+declare const ColumnRecipe: typeof ColumnRecipeBuild & {
+  readonly getStatus: typeof ColumnRecipeGetStatus;
+};
+/**
+ * Type-guard for any recipe class — leaf {@link ColumnLazyImpl} or any of the
+ * wrapper recipes ({@link ColumnDiscoveredRecipe}, {@link ColumnFilteredRecipe},
+ * {@link ColumnOverriddenRecipe}). Use when a value may be a raw id, a `PColumn`,
+ * or a recipe and you want to branch on the recipe case.
+ */
+declare function isColumnRecipe(value: unknown): value is ColumnRecipe;
+//#endregion
+export { ColumnDiscoveredRecipe, ColumnFilteredRecipe, ColumnOverriddenRecipe, ColumnRecipe, type ColumnRecipeId, type SpecQuery$1 as SpecQuery, isColumnRecipe };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/columns/column_recipes/index.ts"],"mappings":";;;;;;;;;UA+BiB,YAAA,YACJ,cAAA,GAAiB,cAAA,UACpB,cAAA,CAAiB,EAAA;;;;;;;;;;;;;;;AAAE;AAAI;iBAkBxB,iBAAA,CACP,EAAA,EAAI,iBAAA,EACJ,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,gBACD,YAAA;;;;;;;;iBAyCN,qBAAA,CACP,EAAA,EAAI,iBAAA,EACJ,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,IACb,sBAAA;AAAA,cASU,YAAA,SAAqB,iBAAA;EAAA,SACvB,SAAA,SAAkB,qBAAqB;AAAA;;;;;;;iBAWlC,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,YAAY"}

package/dist/columns/column_recipes/index.js

@@ -0,0 +1,68 @@
+import { ColumnDiscoveredRecipe } from "./column_discovered_recipe.js";
+import { ColumnFilteredRecipe } from "./column_filtered_recipe.js";
+import { ColumnOverriddenRecipe } from "./column_overrided_recipe.js";
+import { ColumnLazyImpl } from "../column_lazy.js";
+import { isColumnDiscoveredKey, isColumnFilteredKey, isColumnOverriddenKey, isPObjectKey, parseColumnIdSafely } from "@milaboratories/pl-model-common";
+//#region src/columns/column_recipes/index.ts
+/**
+* Build a `ColumnRecipe` from a stringified id. Dispatches to the matching
+* concrete recipe variant based on the id's encoding and recurses on
+* wrappers' inner `source`:
+*
+*   - bare {@link PObjectId} (non-JSON)               → `ColumnLazy.fromId`
+*   - `ColumnDiscoveredKey`                          → {@link ColumnDiscoveredRecipe}
+*   - `ColumnOverriddenKey { source, specOverrides }` → recurse on `source`,
+*                                                       then {@link ColumnOverriddenRecipe.wrap}
+*   - `ColumnFilteredKey { source, axisFilters }`     → recurse on `source`,
+*                                                       then {@link ColumnFilteredRecipe.wrap}
+*
+* Returns `undefined` for unsupported variants (e.g. AnchoredPColumnId,
+* which needs an anchor map to resolve) or when a nested source itself
+* cannot be built.
+*/
+function ColumnRecipeBuild(id, opts = {}) {
+	const parsed = parseColumnIdSafely(id);
+	if (isPObjectKey(parsed)) return ColumnLazyImpl.fromId(id, opts);
+	if (isColumnDiscoveredKey(parsed)) return ColumnDiscoveredRecipe.fromKey(parsed, opts);
+	if (isColumnOverriddenKey(parsed)) {
+		const inner = ColumnRecipe(parsed.source, opts);
+		if (inner === void 0) return void 0;
+		return ColumnOverriddenRecipe.wrap(inner, parsed.specOverrides);
+	}
+	if (isColumnFilteredKey(parsed)) {
+		if (typeof parsed.source !== "string") throw new Error(`Unsupported ColumnRecipe id variant: filtered column with non-string source (${JSON.stringify(parsed.source)})`);
+		const inner = ColumnRecipe(parsed.source, opts);
+		if (inner === void 0) return void 0;
+		return ColumnFilteredRecipe.wrap(inner, parsed.axisFilters);
+	}
+	throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);
+}
+/**
+* Resolution status counterpart to {@link ColumnRecipeBuild}. Dispatches on
+* the parsed id shape to the matching `getStatusBy*` static — never
+* constructs the recipe. Use this at boundaries (resolver, filter/sort
+* targets) to throw early on `absent` instead of silently producing an empty
+* recipe via {@link ColumnRecipeBuild}.
+*/
+function ColumnRecipeGetStatus(id, opts = {}) {
+	const parsed = parseColumnIdSafely(id);
+	if (isPObjectKey(parsed)) return ColumnLazyImpl.getStatusById(id, opts);
+	if (isColumnDiscoveredKey(parsed)) return ColumnDiscoveredRecipe.getStatusByKey(parsed, opts);
+	if (isColumnOverriddenKey(parsed)) return ColumnOverriddenRecipe.getStatusByKey(parsed, opts);
+	if (isColumnFilteredKey(parsed)) return ColumnFilteredRecipe.getStatusByKey(parsed, opts);
+	throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);
+}
+const ColumnRecipe = Object.assign(ColumnRecipeBuild, { getStatus: ColumnRecipeGetStatus });
+/**
+* Type-guard for any recipe class — leaf {@link ColumnLazyImpl} or any of the
+* wrapper recipes ({@link ColumnDiscoveredRecipe}, {@link ColumnFilteredRecipe},
+* {@link ColumnOverriddenRecipe}). Use when a value may be a raw id, a `PColumn`,
+* or a recipe and you want to branch on the recipe case.
+*/
+function isColumnRecipe(value) {
+	return value instanceof ColumnLazyImpl || value instanceof ColumnDiscoveredRecipe || value instanceof ColumnFilteredRecipe || value instanceof ColumnOverriddenRecipe;
+}
+//#endregion
+export { ColumnDiscoveredRecipe, ColumnFilteredRecipe, ColumnOverriddenRecipe, ColumnRecipe, isColumnRecipe };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/columns/column_recipes/index.ts"],"sourcesContent":["import {\n  isColumnDiscoveredKey,\n  isColumnOverriddenKey,\n  parseColumnIdSafely,\n  type ColumnUniversalId,\n  type PObjectId,\n  isPObjectKey,\n  isColumnFilteredKey,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx } from \"../../render/internal\";\nimport { ColumnLazyImpl } from \"../column_lazy\";\nimport { ColumnDiscoveredRecipe } from \"./column_discovered_recipe\";\nimport { ColumnFilteredRecipe } from \"./column_filtered_recipe\";\nimport { ColumnOverriddenRecipe } from \"./column_overrided_recipe\";\nimport type {\n  ColumnRecipe as ColumnRecipeBase,\n  ColumnRecipeId,\n  ColumnResolutionStatus,\n} from \"./types\";\n\nexport type { ColumnFieldStatus, ColumnRecipeId, ColumnResolutionStatus, SpecQuery } from \"./types\";\nexport { ColumnAbsentError } from \"../column_lazy\";\nexport { ColumnDiscoveredRecipe } from \"./column_discovered_recipe\";\nexport { ColumnFilteredRecipe } from \"./column_filtered_recipe\";\nexport { ColumnOverriddenRecipe } from \"./column_overrided_recipe\";\n\n// Re-declare the interface locally so the name can merge with the dispatcher\n// value declared below: a single name `ColumnRecipe` resolves to the\n// interface in type position and to the factory function (`Object.assign`d\n// with `.getStatus`) in value position.\n// (Type-only re-exports do not participate in TS declaration merging.)\nexport interface ColumnRecipe<\n  ID extends ColumnRecipeId = ColumnRecipeId,\n> extends ColumnRecipeBase<ID> {}\n\n/**\n * Build a `ColumnRecipe` from a stringified id. Dispatches to the matching\n * concrete recipe variant based on the id's encoding and recurses on\n * wrappers' inner `source`:\n *\n *   - bare {@link PObjectId} (non-JSON)               → `ColumnLazy.fromId`\n *   - `ColumnDiscoveredKey`                          → {@link ColumnDiscoveredRecipe}\n *   - `ColumnOverriddenKey { source, specOverrides }` → recurse on `source`,\n *                                                       then {@link ColumnOverriddenRecipe.wrap}\n *   - `ColumnFilteredKey { source, axisFilters }`     → recurse on `source`,\n *                                                       then {@link ColumnFilteredRecipe.wrap}\n *\n * Returns `undefined` for unsupported variants (e.g. AnchoredPColumnId,\n * which needs an anchor map to resolve) or when a nested source itself\n * cannot be built.\n */\nfunction ColumnRecipeBuild(\n  id: ColumnUniversalId,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): undefined | ColumnRecipe {\n  const parsed = parseColumnIdSafely(id);\n\n  if (isPObjectKey(parsed)) {\n    return ColumnLazyImpl.fromId(id as PObjectId, opts);\n  }\n\n  if (isColumnDiscoveredKey(parsed)) {\n    return ColumnDiscoveredRecipe.fromKey(parsed, opts);\n  }\n\n  if (isColumnOverriddenKey(parsed)) {\n    const inner = ColumnRecipe(parsed.source, opts);\n    if (inner === undefined) return undefined;\n    return ColumnOverriddenRecipe.wrap(inner, parsed.specOverrides);\n  }\n\n  if (isColumnFilteredKey(parsed)) {\n    // ColumnFilteredKey.source is a stringified ColumnUniversalId (leaf or\n    // any nested wrapper). Legacy `FilteredPColumnId` with an AnchoredPColumnId\n    // (object) source is not supported here — guard against it explicitly.\n    if (typeof parsed.source !== \"string\") {\n      throw new Error(\n        `Unsupported ColumnRecipe id variant: filtered column with non-string source (${JSON.stringify(parsed.source)})`,\n      );\n    }\n    const inner = ColumnRecipe(parsed.source, opts);\n    if (inner === undefined) return undefined;\n    return ColumnFilteredRecipe.wrap(inner, parsed.axisFilters);\n  }\n\n  throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);\n}\n\n/**\n * Resolution status counterpart to {@link ColumnRecipeBuild}. Dispatches on\n * the parsed id shape to the matching `getStatusBy*` static — never\n * constructs the recipe. Use this at boundaries (resolver, filter/sort\n * targets) to throw early on `absent` instead of silently producing an empty\n * recipe via {@link ColumnRecipeBuild}.\n */\nfunction ColumnRecipeGetStatus(\n  id: ColumnUniversalId,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): ColumnResolutionStatus {\n  const parsed = parseColumnIdSafely(id);\n  if (isPObjectKey(parsed)) return ColumnLazyImpl.getStatusById(id as PObjectId, opts);\n  if (isColumnDiscoveredKey(parsed)) return ColumnDiscoveredRecipe.getStatusByKey(parsed, opts);\n  if (isColumnOverriddenKey(parsed)) return ColumnOverriddenRecipe.getStatusByKey(parsed, opts);\n  if (isColumnFilteredKey(parsed)) return ColumnFilteredRecipe.getStatusByKey(parsed, opts);\n  throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);\n}\n\nexport const ColumnRecipe: typeof ColumnRecipeBuild & {\n  readonly getStatus: typeof ColumnRecipeGetStatus;\n} = Object.assign(ColumnRecipeBuild, {\n  getStatus: ColumnRecipeGetStatus,\n});\n\n/**\n * Type-guard for any recipe class — leaf {@link ColumnLazyImpl} or any of the\n * wrapper recipes ({@link ColumnDiscoveredRecipe}, {@link ColumnFilteredRecipe},\n * {@link ColumnOverriddenRecipe}). Use when a value may be a raw id, a `PColumn`,\n * or a recipe and you want to branch on the recipe case.\n */\nexport function isColumnRecipe(value: unknown): value is ColumnRecipe {\n  return (\n    value instanceof ColumnLazyImpl ||\n    value instanceof ColumnDiscoveredRecipe ||\n    value instanceof ColumnFilteredRecipe ||\n    value instanceof ColumnOverriddenRecipe\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAS,kBACP,IACA,OAAqC,CAAC,GACZ;CAC1B,MAAM,SAAS,oBAAoB,EAAE;CAErC,IAAI,aAAa,MAAM,GACrB,OAAO,eAAe,OAAO,IAAiB,IAAI;CAGpD,IAAI,sBAAsB,MAAM,GAC9B,OAAO,uBAAuB,QAAQ,QAAQ,IAAI;CAGpD,IAAI,sBAAsB,MAAM,GAAG;EACjC,MAAM,QAAQ,aAAa,OAAO,QAAQ,IAAI;EAC9C,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;EAChC,OAAO,uBAAuB,KAAK,OAAO,OAAO,aAAa;CAChE;CAEA,IAAI,oBAAoB,MAAM,GAAG;EAI/B,IAAI,OAAO,OAAO,WAAW,UAC3B,MAAM,IAAI,MACR,gFAAgF,KAAK,UAAU,OAAO,MAAM,EAAE,EAChH;EAEF,MAAM,QAAQ,aAAa,OAAO,QAAQ,IAAI;EAC9C,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;EAChC,OAAO,qBAAqB,KAAK,OAAO,OAAO,WAAW;CAC5D;CAEA,MAAM,IAAI,MAAM,wCAAwC,IAAI;AAC9D;;;;;;;;AASA,SAAS,sBACP,IACA,OAAqC,CAAC,GACd;CACxB,MAAM,SAAS,oBAAoB,EAAE;CACrC,IAAI,aAAa,MAAM,GAAG,OAAO,eAAe,cAAc,IAAiB,IAAI;CACnF,IAAI,sBAAsB,MAAM,GAAG,OAAO,uBAAuB,eAAe,QAAQ,IAAI;CAC5F,IAAI,sBAAsB,MAAM,GAAG,OAAO,uBAAuB,eAAe,QAAQ,IAAI;CAC5F,IAAI,oBAAoB,MAAM,GAAG,OAAO,qBAAqB,eAAe,QAAQ,IAAI;CACxF,MAAM,IAAI,MAAM,wCAAwC,IAAI;AAC9D;AAEA,MAAa,eAET,OAAO,OAAO,mBAAmB,EACnC,WAAW,sBACb,CAAC;;;;;;;AAQD,SAAgB,eAAe,OAAuC;CACpE,OACE,iBAAiB,kBACjB,iBAAiB,0BACjB,iBAAiB,wBACjB,iBAAiB;AAErB"}

package/dist/columns/column_recipes/leaf_rebrand.cjs

@@ -0,0 +1,22 @@
+let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
+//#region src/columns/column_recipes/leaf_rebrand.ts
+/**
+* Replace every column leaf whose id equals `fromId` with `toId`, leaving
+* other column refs (linkers, sub-anchors) intact. Wrapper recipes
+* (Overridden / Filtered) and Discovered use this to lift their own id onto
+* the hit leaf, so per-variant uniqueness propagates to the engine and
+* resolver-emitted ids match leaves in the emitted SpecQuery.
+*
+* Generic over all SpecQuery node shapes — including `linkerJoin`, which
+* occurs when a wrapper sits over a {@link ColumnDiscoveredRecipe}: only
+* the deepest hit leaf carries `fromId`, every linker leaf has a different
+* id and is left untouched.
+*/
+function rebrandLeafId(node, fromId, toId) {
+	if (fromId === toId) return node;
+	return (0, _milaboratories_pl_model_common.mapSpecQueryColumns)(node, { column: (id) => id === fromId ? toId : id });
+}
+//#endregion
+exports.rebrandLeafId = rebrandLeafId;
+
+//# sourceMappingURL=leaf_rebrand.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"leaf_rebrand.cjs","names":[],"sources":["../../../src/columns/column_recipes/leaf_rebrand.ts"],"sourcesContent":["import {\n  mapSpecQueryColumns,\n  type ColumnUniversalId,\n  type SpecQuery,\n} from \"@milaboratories/pl-model-common\";\n\n/**\n * Replace every column leaf whose id equals `fromId` with `toId`, leaving\n * other column refs (linkers, sub-anchors) intact. Wrapper recipes\n * (Overridden / Filtered) and Discovered use this to lift their own id onto\n * the hit leaf, so per-variant uniqueness propagates to the engine and\n * resolver-emitted ids match leaves in the emitted SpecQuery.\n *\n * Generic over all SpecQuery node shapes — including `linkerJoin`, which\n * occurs when a wrapper sits over a {@link ColumnDiscoveredRecipe}: only\n * the deepest hit leaf carries `fromId`, every linker leaf has a different\n * id and is left untouched.\n */\nexport function rebrandLeafId(\n  node: SpecQuery,\n  fromId: ColumnUniversalId,\n  toId: ColumnUniversalId,\n): SpecQuery {\n  if (fromId === toId) return node;\n  return mapSpecQueryColumns(node, {\n    column: (id) => (id === fromId ? toId : id),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAkBA,SAAgB,cACd,MACA,QACA,MACW;CACX,IAAI,WAAW,MAAM,OAAO;CAC5B,QAAA,GAAA,gCAAA,oBAAA,CAA2B,MAAM,EAC/B,SAAS,OAAQ,OAAO,SAAS,OAAO,GAC1C,CAAC;AACH"}

package/dist/columns/column_recipes/leaf_rebrand.js

@@ -0,0 +1,22 @@
+import { mapSpecQueryColumns } from "@milaboratories/pl-model-common";
+//#region src/columns/column_recipes/leaf_rebrand.ts
+/**
+* Replace every column leaf whose id equals `fromId` with `toId`, leaving
+* other column refs (linkers, sub-anchors) intact. Wrapper recipes
+* (Overridden / Filtered) and Discovered use this to lift their own id onto
+* the hit leaf, so per-variant uniqueness propagates to the engine and
+* resolver-emitted ids match leaves in the emitted SpecQuery.
+*
+* Generic over all SpecQuery node shapes — including `linkerJoin`, which
+* occurs when a wrapper sits over a {@link ColumnDiscoveredRecipe}: only
+* the deepest hit leaf carries `fromId`, every linker leaf has a different
+* id and is left untouched.
+*/
+function rebrandLeafId(node, fromId, toId) {
+	if (fromId === toId) return node;
+	return mapSpecQueryColumns(node, { column: (id) => id === fromId ? toId : id });
+}
+//#endregion
+export { rebrandLeafId };
+
+//# sourceMappingURL=leaf_rebrand.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"leaf_rebrand.js","names":[],"sources":["../../../src/columns/column_recipes/leaf_rebrand.ts"],"sourcesContent":["import {\n  mapSpecQueryColumns,\n  type ColumnUniversalId,\n  type SpecQuery,\n} from \"@milaboratories/pl-model-common\";\n\n/**\n * Replace every column leaf whose id equals `fromId` with `toId`, leaving\n * other column refs (linkers, sub-anchors) intact. Wrapper recipes\n * (Overridden / Filtered) and Discovered use this to lift their own id onto\n * the hit leaf, so per-variant uniqueness propagates to the engine and\n * resolver-emitted ids match leaves in the emitted SpecQuery.\n *\n * Generic over all SpecQuery node shapes — including `linkerJoin`, which\n * occurs when a wrapper sits over a {@link ColumnDiscoveredRecipe}: only\n * the deepest hit leaf carries `fromId`, every linker leaf has a different\n * id and is left untouched.\n */\nexport function rebrandLeafId(\n  node: SpecQuery,\n  fromId: ColumnUniversalId,\n  toId: ColumnUniversalId,\n): SpecQuery {\n  if (fromId === toId) return node;\n  return mapSpecQueryColumns(node, {\n    column: (id) => (id === fromId ? toId : id),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAkBA,SAAgB,cACd,MACA,QACA,MACW;CACX,IAAI,WAAW,MAAM,OAAO;CAC5B,OAAO,oBAAoB,MAAM,EAC/B,SAAS,OAAQ,OAAO,SAAS,OAAO,GAC1C,CAAC;AACH"}