@platforma-sdk/model 1.80.17 → 1.81.1

package/dist/columns/column.cjs

@@ -1,25 +1,28 @@
+const require_column_discovered_recipe = require("./column_recipes/column_discovered_recipe.cjs");
+const require_column_filtered_recipe = require("./column_recipes/column_filtered_recipe.cjs");
 const require_index = require("./column_recipes/index.cjs");
-const require_column_lazy = require("./column_lazy.cjs");
+const require_column_overrided_recipe = require("./column_recipes/column_overrided_recipe.cjs");
+const require_data_column = require("./data_column.cjs");
 //#region src/columns/column.ts
 /**
 * Unified entry point — routes between the two top-level dispatchers:
 *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}
-*   - object source (`PlRef` / `LeafEntry` / `PColumn` / `ColumnLazy`) → {@link ColumnLazy}
+*   - object source (`PlRef` / `LeafEntry` / `PColumn` / `DataColumnRecipe`) → {@link DataColumnRecipe}
 *
-* `ColumnLazy` is itself a `ColumnRecipe<PObjectId>`, so the return type is
+* `DataColumnRecipe` is itself a `ColumnRecipe<PObjectId>`, so the return type is
 * the common `ColumnRecipe`.
 */
 function Column(source, opts) {
 	if (typeof source === "string") return require_index.ColumnRecipe(source, opts);
-	return require_column_lazy.ColumnLazy(source, opts);
+	return require_data_column.DataColumn(source, opts);
 }
 /**
 * Type-guard for the `Column` type — currently aliased to `ColumnRecipe`, so
 * this is equivalent to {@link isColumnRecipe}. Kept as a separate export to
-* mirror the `Column` / `ColumnRecipe` / `ColumnLazy` factory triple.
+* mirror the `Column` / `ColumnRecipe` / `DataColumnRecipe` factory triple.
 */
 function isColumn(value) {
-	return require_index.isColumnRecipe(value);
+	return value instanceof require_data_column.DataColumnImpl || value instanceof require_column_filtered_recipe.ColumnFilteredRecipe || value instanceof require_column_discovered_recipe.ColumnDiscoveredRecipe || value instanceof require_column_overrided_recipe.ColumnOverriddenRecipe;
 }
 //#endregion
 exports.Column = Column;

package/dist/columns/column.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"column.cjs","names":["ColumnRecipe","ColumnLazy","isColumnRecipe"],"sources":["../../src/columns/column.ts"],"sourcesContent":["import {\n  type ColumnUniversalId,\n  type LeafEntry,\n  type PColumn,\n  type PlRef,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx } from \"../render/internal\";\nimport type { TreeNodeAccessor } from \"../render\";\nimport { ColumnLazy, ColumnLazyImpl, type ColumnLazyData } from \"./column_lazy\";\nimport { ColumnRecipe, ColumnRecipeId, isColumnRecipe } from \"./column_recipes\";\n\nexport type ColumnSource =\n  | PObjectId\n  | ColumnUniversalId\n  | PlRef\n  | LeafEntry<TreeNodeAccessor>\n  | PColumn<ColumnLazyData>\n  | ColumnLazyImpl;\n\n/**\n * Unified entry point — routes between the two top-level dispatchers:\n *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}\n *   - object source (`PlRef` / `LeafEntry` / `PColumn` / `ColumnLazy`) → {@link ColumnLazy}\n *\n * `ColumnLazy` is itself a `ColumnRecipe<PObjectId>`, so the return type is\n * the common `ColumnRecipe`.\n */\nexport function Column(\n  source: ColumnSource,\n  opts?: { ctx?: GlobalCfgRenderCtx },\n): undefined | ColumnRecipe {\n  if (typeof source === \"string\") return ColumnRecipe(source, opts);\n  return ColumnLazy(source, opts);\n}\n\nexport type Column<ID extends ColumnRecipeId = ColumnRecipeId> = ColumnRecipe<ID>;\n\n/**\n * Type-guard for the `Column` type — currently aliased to `ColumnRecipe`, so\n * this is equivalent to {@link isColumnRecipe}. Kept as a separate export to\n * mirror the `Column` / `ColumnRecipe` / `ColumnLazy` factory triple.\n */\nexport function isColumn(value: unknown): value is Column {\n  return isColumnRecipe(value);\n}\n"],"mappings":";;;;;;;;;;;AA4BA,SAAgB,OACd,QACA,MAC0B;CAC1B,IAAI,OAAO,WAAW,UAAU,OAAOA,cAAAA,aAAa,QAAQ,IAAI;CAChE,OAAOC,oBAAAA,WAAW,QAAQ,IAAI;AAChC;;;;;;AASA,SAAgB,SAAS,OAAiC;CACxD,OAAOC,cAAAA,eAAe,KAAK;AAC7B"}
+{"version":3,"file":"column.cjs","names":["ColumnRecipe","DataColumn","DataColumnImpl","ColumnFilteredRecipe","ColumnDiscoveredRecipe","ColumnOverriddenRecipe"],"sources":["../../src/columns/column.ts"],"sourcesContent":["import {\n  type ColumnUniversalId,\n  type LeafEntry,\n  type PColumn,\n  type PlRef,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx } from \"../render/internal\";\nimport type { TreeNodeAccessor } from \"../render\";\nimport { DataColumn, DataColumnRecipe, DataColumnImpl, type ColumnData } from \"./data_column\";\nimport {\n  ColumnDiscoveredRecipe,\n  ColumnFilteredRecipe,\n  ColumnOverriddenRecipe,\n  ColumnRecipe,\n  ColumnRecipeId,\n} from \"./column_recipes\";\n\nexport type ColumnSource =\n  | PObjectId\n  | ColumnUniversalId\n  | PlRef\n  | LeafEntry<TreeNodeAccessor>\n  | PColumn<ColumnData>\n  | DataColumnRecipe<PObjectId>;\n\n/**\n * Unified entry point — routes between the two top-level dispatchers:\n *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}\n *   - object source (`PlRef` / `LeafEntry` / `PColumn` / `DataColumnRecipe`) → {@link DataColumnRecipe}\n *\n * `DataColumnRecipe` is itself a `ColumnRecipe<PObjectId>`, so the return type is\n * the common `ColumnRecipe`.\n */\nexport function Column(\n  source: ColumnSource,\n  opts?: { ctx?: GlobalCfgRenderCtx },\n): undefined | ColumnRecipe {\n  if (typeof source === \"string\") return ColumnRecipe(source, opts);\n  return DataColumn(source, opts);\n}\n\nexport type Column<ID extends ColumnRecipeId = ColumnRecipeId> = ColumnRecipe<ID>;\n\n/**\n * Type-guard for the `Column` type — currently aliased to `ColumnRecipe`, so\n * this is equivalent to {@link isColumnRecipe}. Kept as a separate export to\n * mirror the `Column` / `ColumnRecipe` / `DataColumnRecipe` factory triple.\n */\nexport function isColumn(value: unknown): value is Column {\n  return (\n    value instanceof DataColumnImpl ||\n    value instanceof ColumnFilteredRecipe ||\n    value instanceof ColumnDiscoveredRecipe ||\n    value instanceof ColumnOverriddenRecipe\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;AAkCA,SAAgB,OACd,QACA,MAC0B;CAC1B,IAAI,OAAO,WAAW,UAAU,OAAOA,cAAAA,aAAa,QAAQ,IAAI;CAChE,OAAOC,oBAAAA,WAAW,QAAQ,IAAI;AAChC;;;;;;AASA,SAAgB,SAAS,OAAiC;CACxD,OACE,iBAAiBC,oBAAAA,kBACjB,iBAAiBC,+BAAAA,wBACjB,iBAAiBC,iCAAAA,0BACjB,iBAAiBC,gCAAAA;AAErB"}

package/dist/columns/column.d.ts

@@ -1,18 +1,18 @@
 import { GlobalCfgRenderCtx } from "../render/internal.js";
 import { TreeNodeAccessor } from "../render/accessor.js";
 import { ColumnRecipeId } from "./column_recipes/types.js";
-import { ColumnLazyData, ColumnLazyImpl } from "./column_lazy.js";
+import { ColumnData, DataColumnRecipe } from "./data_column.js";
 import { ColumnRecipe } from "./column_recipes/index.js";
 import { ColumnUniversalId, LeafEntry, PColumn, PObjectId, PlRef } from "@milaboratories/pl-model-common";
 
 //#region src/columns/column.d.ts
-type ColumnSource = PObjectId | ColumnUniversalId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnLazyData> | ColumnLazyImpl;
+type ColumnSource = PObjectId | ColumnUniversalId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnData> | DataColumnRecipe<PObjectId>;
 /**
  * Unified entry point — routes between the two top-level dispatchers:
  *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}
- *   - object source (`PlRef` / `LeafEntry` / `PColumn` / `ColumnLazy`) → {@link ColumnLazy}
+ *   - object source (`PlRef` / `LeafEntry` / `PColumn` / `DataColumnRecipe`) → {@link DataColumnRecipe}
  *
- * `ColumnLazy` is itself a `ColumnRecipe<PObjectId>`, so the return type is
+ * `DataColumnRecipe` is itself a `ColumnRecipe<PObjectId>`, so the return type is
  * the common `ColumnRecipe`.
  */
 declare function Column(source: ColumnSource, opts?: {
@@ -22,7 +22,7 @@ type Column<ID extends ColumnRecipeId = ColumnRecipeId> = ColumnRecipe<ID>;
 /**
  * Type-guard for the `Column` type — currently aliased to `ColumnRecipe`, so
  * this is equivalent to {@link isColumnRecipe}. Kept as a separate export to
- * mirror the `Column` / `ColumnRecipe` / `ColumnLazy` factory triple.
+ * mirror the `Column` / `ColumnRecipe` / `DataColumnRecipe` factory triple.
  */
 declare function isColumn(value: unknown): value is Column;
 //#endregion

package/dist/columns/column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"column.d.ts","names":[],"sources":["../../src/columns/column.ts"],"mappings":";;;;;;;;KAYY,YAAA,GACR,SAAA,GACA,iBAAA,GACA,KAAA,GACA,SAAA,CAAU,gBAAA,IACV,OAAA,CAAQ,cAAA,IACR,cAAA;;;;AANJ;;;;;iBAgBgB,MAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAS,GAAA,GAAM,kBAAA;AAAA,gBACF,YAAA;AAAA,KAKH,MAAA,YAAkB,cAAA,GAAiB,cAAA,IAAkB,YAAA,CAAa,EAAA;;;;;;iBAO9D,QAAA,CAAS,KAAA,YAAiB,KAAA,IAAS,MAAM"}
+{"version":3,"file":"column.d.ts","names":[],"sources":["../../src/columns/column.ts"],"mappings":";;;;;;;;KAkBY,YAAA,GACR,SAAA,GACA,iBAAA,GACA,KAAA,GACA,SAAA,CAAU,gBAAA,IACV,OAAA,CAAQ,UAAA,IACR,gBAAA,CAAiB,SAAA;;;;AANrB;;;;;iBAgBgB,MAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAS,GAAA,GAAM,kBAAA;AAAA,gBACF,YAAA;AAAA,KAKH,MAAA,YAAkB,cAAA,GAAiB,cAAA,IAAkB,YAAA,CAAa,EAAA;;;;;;iBAO9D,QAAA,CAAS,KAAA,YAAiB,KAAA,IAAS,MAAM"}

package/dist/columns/column.js

@@ -1,25 +1,28 @@
-import { ColumnRecipe, isColumnRecipe } from "./column_recipes/index.js";
-import { ColumnLazy } from "./column_lazy.js";
+import { ColumnDiscoveredRecipe } from "./column_recipes/column_discovered_recipe.js";
+import { ColumnFilteredRecipe } from "./column_recipes/column_filtered_recipe.js";
+import { ColumnRecipe } from "./column_recipes/index.js";
+import { ColumnOverriddenRecipe } from "./column_recipes/column_overrided_recipe.js";
+import { DataColumn, DataColumnImpl } from "./data_column.js";
 //#region src/columns/column.ts
 /**
 * Unified entry point — routes between the two top-level dispatchers:
 *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}
-*   - object source (`PlRef` / `LeafEntry` / `PColumn` / `ColumnLazy`) → {@link ColumnLazy}
+*   - object source (`PlRef` / `LeafEntry` / `PColumn` / `DataColumnRecipe`) → {@link DataColumnRecipe}
 *
-* `ColumnLazy` is itself a `ColumnRecipe<PObjectId>`, so the return type is
+* `DataColumnRecipe` is itself a `ColumnRecipe<PObjectId>`, so the return type is
 * the common `ColumnRecipe`.
 */
 function Column(source, opts) {
 	if (typeof source === "string") return ColumnRecipe(source, opts);
-	return ColumnLazy(source, opts);
+	return DataColumn(source, opts);
 }
 /**
 * Type-guard for the `Column` type — currently aliased to `ColumnRecipe`, so
 * this is equivalent to {@link isColumnRecipe}. Kept as a separate export to
-* mirror the `Column` / `ColumnRecipe` / `ColumnLazy` factory triple.
+* mirror the `Column` / `ColumnRecipe` / `DataColumnRecipe` factory triple.
 */
 function isColumn(value) {
-	return isColumnRecipe(value);
+	return value instanceof DataColumnImpl || value instanceof ColumnFilteredRecipe || value instanceof ColumnDiscoveredRecipe || value instanceof ColumnOverriddenRecipe;
 }
 //#endregion
 export { Column, isColumn };

package/dist/columns/column.js.map

@@ -1 +1 @@
-{"version":3,"file":"column.js","names":[],"sources":["../../src/columns/column.ts"],"sourcesContent":["import {\n  type ColumnUniversalId,\n  type LeafEntry,\n  type PColumn,\n  type PlRef,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx } from \"../render/internal\";\nimport type { TreeNodeAccessor } from \"../render\";\nimport { ColumnLazy, ColumnLazyImpl, type ColumnLazyData } from \"./column_lazy\";\nimport { ColumnRecipe, ColumnRecipeId, isColumnRecipe } from \"./column_recipes\";\n\nexport type ColumnSource =\n  | PObjectId\n  | ColumnUniversalId\n  | PlRef\n  | LeafEntry<TreeNodeAccessor>\n  | PColumn<ColumnLazyData>\n  | ColumnLazyImpl;\n\n/**\n * Unified entry point — routes between the two top-level dispatchers:\n *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}\n *   - object source (`PlRef` / `LeafEntry` / `PColumn` / `ColumnLazy`) → {@link ColumnLazy}\n *\n * `ColumnLazy` is itself a `ColumnRecipe<PObjectId>`, so the return type is\n * the common `ColumnRecipe`.\n */\nexport function Column(\n  source: ColumnSource,\n  opts?: { ctx?: GlobalCfgRenderCtx },\n): undefined | ColumnRecipe {\n  if (typeof source === \"string\") return ColumnRecipe(source, opts);\n  return ColumnLazy(source, opts);\n}\n\nexport type Column<ID extends ColumnRecipeId = ColumnRecipeId> = ColumnRecipe<ID>;\n\n/**\n * Type-guard for the `Column` type — currently aliased to `ColumnRecipe`, so\n * this is equivalent to {@link isColumnRecipe}. Kept as a separate export to\n * mirror the `Column` / `ColumnRecipe` / `ColumnLazy` factory triple.\n */\nexport function isColumn(value: unknown): value is Column {\n  return isColumnRecipe(value);\n}\n"],"mappings":";;;;;;;;;;;AA4BA,SAAgB,OACd,QACA,MAC0B;CAC1B,IAAI,OAAO,WAAW,UAAU,OAAO,aAAa,QAAQ,IAAI;CAChE,OAAO,WAAW,QAAQ,IAAI;AAChC;;;;;;AASA,SAAgB,SAAS,OAAiC;CACxD,OAAO,eAAe,KAAK;AAC7B"}
+{"version":3,"file":"column.js","names":[],"sources":["../../src/columns/column.ts"],"sourcesContent":["import {\n  type ColumnUniversalId,\n  type LeafEntry,\n  type PColumn,\n  type PlRef,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx } from \"../render/internal\";\nimport type { TreeNodeAccessor } from \"../render\";\nimport { DataColumn, DataColumnRecipe, DataColumnImpl, type ColumnData } from \"./data_column\";\nimport {\n  ColumnDiscoveredRecipe,\n  ColumnFilteredRecipe,\n  ColumnOverriddenRecipe,\n  ColumnRecipe,\n  ColumnRecipeId,\n} from \"./column_recipes\";\n\nexport type ColumnSource =\n  | PObjectId\n  | ColumnUniversalId\n  | PlRef\n  | LeafEntry<TreeNodeAccessor>\n  | PColumn<ColumnData>\n  | DataColumnRecipe<PObjectId>;\n\n/**\n * Unified entry point — routes between the two top-level dispatchers:\n *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}\n *   - object source (`PlRef` / `LeafEntry` / `PColumn` / `DataColumnRecipe`) → {@link DataColumnRecipe}\n *\n * `DataColumnRecipe` is itself a `ColumnRecipe<PObjectId>`, so the return type is\n * the common `ColumnRecipe`.\n */\nexport function Column(\n  source: ColumnSource,\n  opts?: { ctx?: GlobalCfgRenderCtx },\n): undefined | ColumnRecipe {\n  if (typeof source === \"string\") return ColumnRecipe(source, opts);\n  return DataColumn(source, opts);\n}\n\nexport type Column<ID extends ColumnRecipeId = ColumnRecipeId> = ColumnRecipe<ID>;\n\n/**\n * Type-guard for the `Column` type — currently aliased to `ColumnRecipe`, so\n * this is equivalent to {@link isColumnRecipe}. Kept as a separate export to\n * mirror the `Column` / `ColumnRecipe` / `DataColumnRecipe` factory triple.\n */\nexport function isColumn(value: unknown): value is Column {\n  return (\n    value instanceof DataColumnImpl ||\n    value instanceof ColumnFilteredRecipe ||\n    value instanceof ColumnDiscoveredRecipe ||\n    value instanceof ColumnOverriddenRecipe\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;AAkCA,SAAgB,OACd,QACA,MAC0B;CAC1B,IAAI,OAAO,WAAW,UAAU,OAAO,aAAa,QAAQ,IAAI;CAChE,OAAO,WAAW,QAAQ,IAAI;AAChC;;;;;;AASA,SAAgB,SAAS,OAAiC;CACxD,OACE,iBAAiB,kBACjB,iBAAiB,wBACjB,iBAAiB,0BACjB,iBAAiB;AAErB"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["getCfgRenderCtx","MainAccessorName","ColumnsProvider","TreeNodeAccessor","StagingAccessorName","ArrayColumnsProvider"],"sources":["../../../src/columns/column_providers/index.ts"],"sourcesContent":["import { PColumn, type ColumnEntriesProvider } from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx, PColumnDataUniversal } from \"../../render/internal\";\nimport { getCfgRenderCtx } from \"../../internal\";\nimport { MainAccessorName, StagingAccessorName } from \"../../render/internal\";\nimport { TreeNodeAccessor } from \"../../render/accessor\";\nimport { ColumnLazy } from \"../column_lazy\";\nimport type { ColumnsSource } from \"./types\";\nimport { ArrayColumnsProvider, ColumnsProvider } from \"./providers\";\n\nexport * from \"./types\";\nexport * from \"./providers\";\n\n/**\n * Build the default set of ColumnsProviders for the ambient render ctx:\n *  - `AccessorColumnsProvider` over `outputs` (if present)\n *  - `AccessorColumnsProvider` over `prerun`  (if present)\n *  - `ResultPoolColumnsProvider` over `rawResultPool`\n *\n * Pulls handles directly from the ambient `cfgRenderCtx`. Returns `[]` when\n * called outside a render context.\n *\n * Result is memoised per-ctx (WeakMap → array). Repeated calls within the\n * same render cycle return the same provider triplet — inner providers are\n * also LRU-memoised by their content keys, so even a cache miss here doesn't\n * re-walk the trees.\n */\nexport const _ctxProvidersCache = new WeakMap<\n  GlobalCfgRenderCtx,\n  (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[]\n>();\n\nexport function getCtxProviders(deps?: {\n  ctx?: GlobalCfgRenderCtx;\n}): (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[] {\n  const ctx = deps?.ctx ?? getCfgRenderCtx();\n\n  const cached = _ctxProvidersCache.get(ctx);\n  if (cached !== undefined) return cached;\n\n  const providers: (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[] = [];\n\n  const outputs = ctx.getAccessorHandleByName(MainAccessorName);\n  if (outputs !== undefined) {\n    providers.push(ColumnsProvider(new TreeNodeAccessor(outputs, [MainAccessorName])));\n  }\n\n  const prerun = ctx.getAccessorHandleByName(StagingAccessorName);\n  if (prerun !== undefined) {\n    providers.push(ColumnsProvider(new TreeNodeAccessor(prerun, [StagingAccessorName])));\n  }\n\n  providers.push(ColumnsProvider(ctx.getUpstreamBlockCtx()));\n\n  _ctxProvidersCache.set(ctx, providers);\n  return providers;\n}\n\nexport function isColumnProvider(source: unknown): source is ColumnsProvider {\n  if (typeof source !== \"object\" || source === null) return false;\n  const p = source as ColumnsProvider;\n  return typeof p.getColumns === \"function\" && typeof p.isFinal === \"function\";\n}\n\nexport function toColumnProvider(source: ColumnsSource): ColumnsProvider {\n  if (isColumnArray(source)) return new ArrayColumnsProvider(source.columns, source.isFinal);\n  if (isColumnProvider(source)) return source;\n  if (source instanceof TreeNodeAccessor) return ColumnsProvider(source);\n  throw new Error(\"Unknown ColumnsSource type\");\n}\n\nfunction isColumnArray(source: unknown): source is {\n  readonly columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | ColumnLazy>;\n  readonly isFinal: boolean;\n} {\n  if (typeof source !== \"object\" || source === null) return false;\n  const s = source as { columns?: unknown; isFinal?: unknown };\n  return Array.isArray(s.columns) && typeof s.isFinal === \"boolean\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,MAAa,qCAAqB,IAAI,QAGpC;AAEF,SAAgB,gBAAgB,MAEkC;CAChE,MAAM,MAAM,MAAM,OAAOA,iBAAAA,gBAAgB;CAEzC,MAAM,SAAS,mBAAmB,IAAI,GAAG;CACzC,IAAI,WAAW,KAAA,GAAW,OAAO;CAEjC,MAAM,YAA2E,CAAC;CAElF,MAAM,UAAU,IAAI,wBAAwBC,mBAAAA,gBAAgB;CAC5D,IAAI,YAAY,KAAA,GACd,UAAU,KAAKC,kBAAAA,gBAAgB,IAAIC,iBAAAA,iBAAiB,SAAS,CAACF,mBAAAA,gBAAgB,CAAC,CAAC,CAAC;CAGnF,MAAM,SAAS,IAAI,wBAAwBG,mBAAAA,mBAAmB;CAC9D,IAAI,WAAW,KAAA,GACb,UAAU,KAAKF,kBAAAA,gBAAgB,IAAIC,iBAAAA,iBAAiB,QAAQ,CAACC,mBAAAA,mBAAmB,CAAC,CAAC,CAAC;CAGrF,UAAU,KAAKF,kBAAAA,gBAAgB,IAAI,oBAAoB,CAAC,CAAC;CAEzD,mBAAmB,IAAI,KAAK,SAAS;CACrC,OAAO;AACT;AAEA,SAAgB,iBAAiB,QAA4C;CAC3E,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM,OAAO;CAC1D,MAAM,IAAI;CACV,OAAO,OAAO,EAAE,eAAe,cAAc,OAAO,EAAE,YAAY;AACpE;AAEA,SAAgB,iBAAiB,QAAwC;CACvE,IAAI,cAAc,MAAM,GAAG,OAAO,IAAIG,kBAAAA,qBAAqB,OAAO,SAAS,OAAO,OAAO;CACzF,IAAI,iBAAiB,MAAM,GAAG,OAAO;CACrC,IAAI,kBAAkBF,iBAAAA,kBAAkB,OAAOD,kBAAAA,gBAAgB,MAAM;CACrE,MAAM,IAAI,MAAM,4BAA4B;AAC9C;AAEA,SAAS,cAAc,QAGrB;CACA,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM,OAAO;CAC1D,MAAM,IAAI;CACV,OAAO,MAAM,QAAQ,EAAE,OAAO,KAAK,OAAO,EAAE,YAAY;AAC1D"}
+{"version":3,"file":"index.cjs","names":["getCfgRenderCtx","MainAccessorName","ColumnsProvider","TreeNodeAccessor","StagingAccessorName","ArrayColumnsProvider"],"sources":["../../../src/columns/column_providers/index.ts"],"sourcesContent":["import {\n  PColumn,\n  type ColumnEntriesProvider,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx, PColumnDataUniversal } from \"../../render/internal\";\nimport { getCfgRenderCtx } from \"../../internal\";\nimport { MainAccessorName, StagingAccessorName } from \"../../render/internal\";\nimport { TreeNodeAccessor } from \"../../render/accessor\";\nimport { DataColumnRecipe } from \"../data_column\";\nimport type { ColumnsSource } from \"./types\";\nimport { ArrayColumnsProvider, ColumnsProvider } from \"./providers\";\n\nexport * from \"./types\";\nexport * from \"./providers\";\n\n/**\n * Build the default set of ColumnsProviders for the ambient render ctx:\n *  - `AccessorColumnsProvider` over `outputs` (if present)\n *  - `AccessorColumnsProvider` over `prerun`  (if present)\n *  - `ResultPoolColumnsProvider` over `rawResultPool`\n *\n * Pulls handles directly from the ambient `cfgRenderCtx`. Returns `[]` when\n * called outside a render context.\n *\n * Result is memoised per-ctx (WeakMap → array). Repeated calls within the\n * same render cycle return the same provider triplet — inner providers are\n * also LRU-memoised by their content keys, so even a cache miss here doesn't\n * re-walk the trees.\n */\nexport const _ctxProvidersCache = new WeakMap<\n  GlobalCfgRenderCtx,\n  (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[]\n>();\n\nexport function getCtxProviders(deps?: {\n  ctx?: GlobalCfgRenderCtx;\n}): (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[] {\n  const ctx = deps?.ctx ?? getCfgRenderCtx();\n\n  const cached = _ctxProvidersCache.get(ctx);\n  if (cached !== undefined) return cached;\n\n  const providers: (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[] = [];\n\n  const outputs = ctx.getAccessorHandleByName(MainAccessorName);\n  if (outputs !== undefined) {\n    providers.push(ColumnsProvider(new TreeNodeAccessor(outputs, [MainAccessorName])));\n  }\n\n  const prerun = ctx.getAccessorHandleByName(StagingAccessorName);\n  if (prerun !== undefined) {\n    providers.push(ColumnsProvider(new TreeNodeAccessor(prerun, [StagingAccessorName])));\n  }\n\n  providers.push(ColumnsProvider(ctx.getUpstreamBlockCtx()));\n\n  _ctxProvidersCache.set(ctx, providers);\n  return providers;\n}\n\nexport function isColumnProvider(source: unknown): source is ColumnsProvider {\n  if (typeof source !== \"object\" || source === null) return false;\n  const p = source as ColumnsProvider;\n  return typeof p.getColumns === \"function\" && typeof p.isFinal === \"function\";\n}\n\nexport function toColumnProvider(source: ColumnsSource): ColumnsProvider {\n  if (isColumnArray(source)) return new ArrayColumnsProvider(source.columns, source.isFinal);\n  if (isColumnProvider(source)) return source;\n  if (source instanceof TreeNodeAccessor) return ColumnsProvider(source);\n  throw new Error(\"Unknown ColumnsSource type\");\n}\n\nfunction isColumnArray(source: unknown): source is {\n  readonly columns: ReadonlyArray<\n    PColumn<undefined | PColumnDataUniversal> | DataColumnRecipe<PObjectId>\n  >;\n  readonly isFinal: boolean;\n} {\n  if (typeof source !== \"object\" || source === null) return false;\n  const s = source as { columns?: unknown; isFinal?: unknown };\n  return Array.isArray(s.columns) && typeof s.isFinal === \"boolean\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8BA,MAAa,qCAAqB,IAAI,QAGpC;AAEF,SAAgB,gBAAgB,MAEkC;CAChE,MAAM,MAAM,MAAM,OAAOA,iBAAAA,gBAAgB;CAEzC,MAAM,SAAS,mBAAmB,IAAI,GAAG;CACzC,IAAI,WAAW,KAAA,GAAW,OAAO;CAEjC,MAAM,YAA2E,CAAC;CAElF,MAAM,UAAU,IAAI,wBAAwBC,mBAAAA,gBAAgB;CAC5D,IAAI,YAAY,KAAA,GACd,UAAU,KAAKC,kBAAAA,gBAAgB,IAAIC,iBAAAA,iBAAiB,SAAS,CAACF,mBAAAA,gBAAgB,CAAC,CAAC,CAAC;CAGnF,MAAM,SAAS,IAAI,wBAAwBG,mBAAAA,mBAAmB;CAC9D,IAAI,WAAW,KAAA,GACb,UAAU,KAAKF,kBAAAA,gBAAgB,IAAIC,iBAAAA,iBAAiB,QAAQ,CAACC,mBAAAA,mBAAmB,CAAC,CAAC,CAAC;CAGrF,UAAU,KAAKF,kBAAAA,gBAAgB,IAAI,oBAAoB,CAAC,CAAC;CAEzD,mBAAmB,IAAI,KAAK,SAAS;CACrC,OAAO;AACT;AAEA,SAAgB,iBAAiB,QAA4C;CAC3E,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM,OAAO;CAC1D,MAAM,IAAI;CACV,OAAO,OAAO,EAAE,eAAe,cAAc,OAAO,EAAE,YAAY;AACpE;AAEA,SAAgB,iBAAiB,QAAwC;CACvE,IAAI,cAAc,MAAM,GAAG,OAAO,IAAIG,kBAAAA,qBAAqB,OAAO,SAAS,OAAO,OAAO;CACzF,IAAI,iBAAiB,MAAM,GAAG,OAAO;CACrC,IAAI,kBAAkBF,iBAAAA,kBAAkB,OAAOD,kBAAAA,gBAAgB,MAAM;CACrE,MAAM,IAAI,MAAM,4BAA4B;AAC9C;AAEA,SAAS,cAAc,QAKrB;CACA,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM,OAAO;CAC1D,MAAM,IAAI;CACV,OAAO,MAAM,QAAQ,EAAE,OAAO,KAAK,OAAO,EAAE,YAAY;AAC1D"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/columns/column_providers/index.ts"],"mappings":";;;;;;;AA0BA;;;;;;;;;;;;;;AAAA,cAAa,kBAAA,EAAkB,OAAA,CAAA,kBAAA,GAAA,qBAAA,CAAA,gBAAA,IAAA,eAAA;AAAA,iBAKf,eAAA,CAAgB,IAAA;EAC9B,GAAA,GAAM,kBAAA;AAAA,KACH,qBAAA,CAAsB,gBAAA,IAAoB,eAAA;AAAA,iBAwB/B,gBAAA,CAAiB,MAAA,YAAkB,MAAA,IAAU,eAAe;AAAA,iBAM5D,gBAAA,CAAiB,MAAA,EAAQ,aAAA,GAAgB,eAAe"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/columns/column_providers/index.ts"],"mappings":";;;;;;;AA8BA;;;;;;;;;;;;;;AAAA,cAAa,kBAAA,EAAkB,OAAA,CAAA,kBAAA,GAAA,qBAAA,CAAA,gBAAA,IAAA,eAAA;AAAA,iBAKf,eAAA,CAAgB,IAAA;EAC9B,GAAA,GAAM,kBAAA;AAAA,KACH,qBAAA,CAAsB,gBAAA,IAAoB,eAAA;AAAA,iBAwB/B,gBAAA,CAAiB,MAAA,YAAkB,MAAA,IAAU,eAAe;AAAA,iBAM5D,gBAAA,CAAiB,MAAA,EAAQ,aAAA,GAAgB,eAAe"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/columns/column_providers/index.ts"],"sourcesContent":["import { PColumn, type ColumnEntriesProvider } from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx, PColumnDataUniversal } from \"../../render/internal\";\nimport { getCfgRenderCtx } from \"../../internal\";\nimport { MainAccessorName, StagingAccessorName } from \"../../render/internal\";\nimport { TreeNodeAccessor } from \"../../render/accessor\";\nimport { ColumnLazy } from \"../column_lazy\";\nimport type { ColumnsSource } from \"./types\";\nimport { ArrayColumnsProvider, ColumnsProvider } from \"./providers\";\n\nexport * from \"./types\";\nexport * from \"./providers\";\n\n/**\n * Build the default set of ColumnsProviders for the ambient render ctx:\n *  - `AccessorColumnsProvider` over `outputs` (if present)\n *  - `AccessorColumnsProvider` over `prerun`  (if present)\n *  - `ResultPoolColumnsProvider` over `rawResultPool`\n *\n * Pulls handles directly from the ambient `cfgRenderCtx`. Returns `[]` when\n * called outside a render context.\n *\n * Result is memoised per-ctx (WeakMap → array). Repeated calls within the\n * same render cycle return the same provider triplet — inner providers are\n * also LRU-memoised by their content keys, so even a cache miss here doesn't\n * re-walk the trees.\n */\nexport const _ctxProvidersCache = new WeakMap<\n  GlobalCfgRenderCtx,\n  (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[]\n>();\n\nexport function getCtxProviders(deps?: {\n  ctx?: GlobalCfgRenderCtx;\n}): (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[] {\n  const ctx = deps?.ctx ?? getCfgRenderCtx();\n\n  const cached = _ctxProvidersCache.get(ctx);\n  if (cached !== undefined) return cached;\n\n  const providers: (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[] = [];\n\n  const outputs = ctx.getAccessorHandleByName(MainAccessorName);\n  if (outputs !== undefined) {\n    providers.push(ColumnsProvider(new TreeNodeAccessor(outputs, [MainAccessorName])));\n  }\n\n  const prerun = ctx.getAccessorHandleByName(StagingAccessorName);\n  if (prerun !== undefined) {\n    providers.push(ColumnsProvider(new TreeNodeAccessor(prerun, [StagingAccessorName])));\n  }\n\n  providers.push(ColumnsProvider(ctx.getUpstreamBlockCtx()));\n\n  _ctxProvidersCache.set(ctx, providers);\n  return providers;\n}\n\nexport function isColumnProvider(source: unknown): source is ColumnsProvider {\n  if (typeof source !== \"object\" || source === null) return false;\n  const p = source as ColumnsProvider;\n  return typeof p.getColumns === \"function\" && typeof p.isFinal === \"function\";\n}\n\nexport function toColumnProvider(source: ColumnsSource): ColumnsProvider {\n  if (isColumnArray(source)) return new ArrayColumnsProvider(source.columns, source.isFinal);\n  if (isColumnProvider(source)) return source;\n  if (source instanceof TreeNodeAccessor) return ColumnsProvider(source);\n  throw new Error(\"Unknown ColumnsSource type\");\n}\n\nfunction isColumnArray(source: unknown): source is {\n  readonly columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | ColumnLazy>;\n  readonly isFinal: boolean;\n} {\n  if (typeof source !== \"object\" || source === null) return false;\n  const s = source as { columns?: unknown; isFinal?: unknown };\n  return Array.isArray(s.columns) && typeof s.isFinal === \"boolean\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,MAAa,qCAAqB,IAAI,QAGpC;AAEF,SAAgB,gBAAgB,MAEkC;CAChE,MAAM,MAAM,MAAM,OAAO,gBAAgB;CAEzC,MAAM,SAAS,mBAAmB,IAAI,GAAG;CACzC,IAAI,WAAW,KAAA,GAAW,OAAO;CAEjC,MAAM,YAA2E,CAAC;CAElF,MAAM,UAAU,IAAI,wBAAwB,gBAAgB;CAC5D,IAAI,YAAY,KAAA,GACd,UAAU,KAAK,gBAAgB,IAAI,iBAAiB,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC;CAGnF,MAAM,SAAS,IAAI,wBAAwB,mBAAmB;CAC9D,IAAI,WAAW,KAAA,GACb,UAAU,KAAK,gBAAgB,IAAI,iBAAiB,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC;CAGrF,UAAU,KAAK,gBAAgB,IAAI,oBAAoB,CAAC,CAAC;CAEzD,mBAAmB,IAAI,KAAK,SAAS;CACrC,OAAO;AACT;AAEA,SAAgB,iBAAiB,QAA4C;CAC3E,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM,OAAO;CAC1D,MAAM,IAAI;CACV,OAAO,OAAO,EAAE,eAAe,cAAc,OAAO,EAAE,YAAY;AACpE;AAEA,SAAgB,iBAAiB,QAAwC;CACvE,IAAI,cAAc,MAAM,GAAG,OAAO,IAAI,qBAAqB,OAAO,SAAS,OAAO,OAAO;CACzF,IAAI,iBAAiB,MAAM,GAAG,OAAO;CACrC,IAAI,kBAAkB,kBAAkB,OAAO,gBAAgB,MAAM;CACrE,MAAM,IAAI,MAAM,4BAA4B;AAC9C;AAEA,SAAS,cAAc,QAGrB;CACA,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM,OAAO;CAC1D,MAAM,IAAI;CACV,OAAO,MAAM,QAAQ,EAAE,OAAO,KAAK,OAAO,EAAE,YAAY;AAC1D"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/columns/column_providers/index.ts"],"sourcesContent":["import {\n  PColumn,\n  type ColumnEntriesProvider,\n  type PObjectId,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx, PColumnDataUniversal } from \"../../render/internal\";\nimport { getCfgRenderCtx } from \"../../internal\";\nimport { MainAccessorName, StagingAccessorName } from \"../../render/internal\";\nimport { TreeNodeAccessor } from \"../../render/accessor\";\nimport { DataColumnRecipe } from \"../data_column\";\nimport type { ColumnsSource } from \"./types\";\nimport { ArrayColumnsProvider, ColumnsProvider } from \"./providers\";\n\nexport * from \"./types\";\nexport * from \"./providers\";\n\n/**\n * Build the default set of ColumnsProviders for the ambient render ctx:\n *  - `AccessorColumnsProvider` over `outputs` (if present)\n *  - `AccessorColumnsProvider` over `prerun`  (if present)\n *  - `ResultPoolColumnsProvider` over `rawResultPool`\n *\n * Pulls handles directly from the ambient `cfgRenderCtx`. Returns `[]` when\n * called outside a render context.\n *\n * Result is memoised per-ctx (WeakMap → array). Repeated calls within the\n * same render cycle return the same provider triplet — inner providers are\n * also LRU-memoised by their content keys, so even a cache miss here doesn't\n * re-walk the trees.\n */\nexport const _ctxProvidersCache = new WeakMap<\n  GlobalCfgRenderCtx,\n  (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[]\n>();\n\nexport function getCtxProviders(deps?: {\n  ctx?: GlobalCfgRenderCtx;\n}): (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[] {\n  const ctx = deps?.ctx ?? getCfgRenderCtx();\n\n  const cached = _ctxProvidersCache.get(ctx);\n  if (cached !== undefined) return cached;\n\n  const providers: (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[] = [];\n\n  const outputs = ctx.getAccessorHandleByName(MainAccessorName);\n  if (outputs !== undefined) {\n    providers.push(ColumnsProvider(new TreeNodeAccessor(outputs, [MainAccessorName])));\n  }\n\n  const prerun = ctx.getAccessorHandleByName(StagingAccessorName);\n  if (prerun !== undefined) {\n    providers.push(ColumnsProvider(new TreeNodeAccessor(prerun, [StagingAccessorName])));\n  }\n\n  providers.push(ColumnsProvider(ctx.getUpstreamBlockCtx()));\n\n  _ctxProvidersCache.set(ctx, providers);\n  return providers;\n}\n\nexport function isColumnProvider(source: unknown): source is ColumnsProvider {\n  if (typeof source !== \"object\" || source === null) return false;\n  const p = source as ColumnsProvider;\n  return typeof p.getColumns === \"function\" && typeof p.isFinal === \"function\";\n}\n\nexport function toColumnProvider(source: ColumnsSource): ColumnsProvider {\n  if (isColumnArray(source)) return new ArrayColumnsProvider(source.columns, source.isFinal);\n  if (isColumnProvider(source)) return source;\n  if (source instanceof TreeNodeAccessor) return ColumnsProvider(source);\n  throw new Error(\"Unknown ColumnsSource type\");\n}\n\nfunction isColumnArray(source: unknown): source is {\n  readonly columns: ReadonlyArray<\n    PColumn<undefined | PColumnDataUniversal> | DataColumnRecipe<PObjectId>\n  >;\n  readonly isFinal: boolean;\n} {\n  if (typeof source !== \"object\" || source === null) return false;\n  const s = source as { columns?: unknown; isFinal?: unknown };\n  return Array.isArray(s.columns) && typeof s.isFinal === \"boolean\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8BA,MAAa,qCAAqB,IAAI,QAGpC;AAEF,SAAgB,gBAAgB,MAEkC;CAChE,MAAM,MAAM,MAAM,OAAO,gBAAgB;CAEzC,MAAM,SAAS,mBAAmB,IAAI,GAAG;CACzC,IAAI,WAAW,KAAA,GAAW,OAAO;CAEjC,MAAM,YAA2E,CAAC;CAElF,MAAM,UAAU,IAAI,wBAAwB,gBAAgB;CAC5D,IAAI,YAAY,KAAA,GACd,UAAU,KAAK,gBAAgB,IAAI,iBAAiB,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC;CAGnF,MAAM,SAAS,IAAI,wBAAwB,mBAAmB;CAC9D,IAAI,WAAW,KAAA,GACb,UAAU,KAAK,gBAAgB,IAAI,iBAAiB,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC;CAGrF,UAAU,KAAK,gBAAgB,IAAI,oBAAoB,CAAC,CAAC;CAEzD,mBAAmB,IAAI,KAAK,SAAS;CACrC,OAAO;AACT;AAEA,SAAgB,iBAAiB,QAA4C;CAC3E,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM,OAAO;CAC1D,MAAM,IAAI;CACV,OAAO,OAAO,EAAE,eAAe,cAAc,OAAO,EAAE,YAAY;AACpE;AAEA,SAAgB,iBAAiB,QAAwC;CACvE,IAAI,cAAc,MAAM,GAAG,OAAO,IAAI,qBAAqB,OAAO,SAAS,OAAO,OAAO;CACzF,IAAI,iBAAiB,MAAM,GAAG,OAAO;CACrC,IAAI,kBAAkB,kBAAkB,OAAO,gBAAgB,MAAM;CACrE,MAAM,IAAI,MAAM,4BAA4B;AAC9C;AAEA,SAAS,cAAc,QAKrB;CACA,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM,OAAO;CAC1D,MAAM,IAAI;CACV,OAAO,MAAM,QAAQ,EAAE,OAAO,KAAK,OAAO,EAAE,YAAY;AAC1D"}

package/dist/columns/column_providers/providers.cjs

@@ -1,7 +1,7 @@
 const require_internal = require("../../internal.cjs");
 const require_accessor = require("../../render/accessor.cjs");
 require("../../render/index.cjs");
-const require_column_lazy = require("../column_lazy.cjs");
+const require_data_column = require("../data_column.cjs");
 let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
 let es_toolkit = require("es-toolkit");
 let lru_cache = require("lru-cache");
@@ -62,7 +62,7 @@ var ArrayColumnsProvider = class {
 	columns;
 	constructor(columns, _isFinal) {
 		this._isFinal = _isFinal;
-		this.columns = columns.map((c) => require_column_lazy.ColumnLazyImpl.fromColumn(c));
+		this.columns = columns.map((c) => require_data_column.DataColumn.fromColumn(c));
 	}
 	getColumns() {
 		return this.columns;
@@ -74,7 +74,7 @@ var ArrayColumnsProvider = class {
 /**
 * Sandbox-specific provider over a {@link TreeNodeAccessor} root. Uses the
 * accessor's own `resolvePath` as the canonical root path for id construction,
-* and adds `getColumns()` returning {@link ColumnLazy}s on top of the generic
+* and adds `getColumns()` returning {@link DataColumnRecipe<PObjectId>}s on top of the generic
 * entries index.
 */
 var AccessorColumnsProviderImpl = class extends _milaboratories_pl_model_common.AccessorEntriesProvider {
@@ -84,7 +84,7 @@ var AccessorColumnsProviderImpl = class extends _milaboratories_pl_model_common.
 	}
 	getColumns() {
 		if (this.cachedColumns !== void 0) return this.cachedColumns;
-		return this.cachedColumns = Array.from(this.entries.values()).map((e) => require_column_lazy.ColumnLazyImpl.fromAccessor(e)).filter((v) => !(0, es_toolkit.isNil)(v));
+		return this.cachedColumns = Array.from(this.entries.values()).map((e) => require_data_column.DataColumn.fromAccessor(e)).filter((v) => !(0, es_toolkit.isNil)(v));
 	}
 };
 /**
@@ -106,7 +106,7 @@ var ResultPoolColumnsProviderImpl = class extends _milaboratories_pl_model_commo
 	}
 	getColumns() {
 		if (this.cachedColumns !== void 0) return this.cachedColumns;
-		return this.cachedColumns = Array.from(this.getPObjectEntries().values()).map((e) => require_column_lazy.ColumnLazyImpl.fromAccessor(e)).filter((v) => !(0, es_toolkit.isNil)(v));
+		return this.cachedColumns = Array.from(this.getPObjectEntries().values()).map((e) => require_data_column.DataColumn.fromAccessor(e)).filter((v) => !(0, es_toolkit.isNil)(v));
 	}
 };
 function hashRawPool(rawPool) {

package/dist/columns/column_providers/providers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"providers.cjs","names":["TreeNodeAccessor","LRUCache","getCfgRenderCtx","ColumnLazyImpl","AccessorEntriesProvider","ResultPoolEntriesProvider"],"sources":["../../../src/columns/column_providers/providers.ts"],"sourcesContent":["import {\n  AccessorEntriesProvider,\n  ResultPoolEntriesProvider,\n  type PColumn,\n  type UpstreamBlockCtx,\n} from \"@milaboratories/pl-model-common\";\nimport { AccessorHandle, PColumnDataUniversal, TreeNodeAccessor } from \"../../render\";\nimport { ColumnLazy, ColumnLazyImpl } from \"../column_lazy\";\nimport { getCfgRenderCtx } from \"../../internal\";\nimport { isNil } from \"es-toolkit\";\nimport { LRUCache } from \"lru-cache\";\n\n/**\n * Data source for sandbox column-list builders. Has nothing to say about\n * id-resolution — `ColumnRegistry` (in `@milaboratories/pl-model-common`)\n * consumes the separate `ColumnEntriesProvider` interface for that.\n *\n * Same name as the factory function below — they merge into one TS\n * declaration: `ColumnsProvider` is callable AND the interface type.\n */\nexport interface ColumnsProvider {\n  /** Returns all currently known PColumn columns as lazy views. */\n  getColumns(): ColumnLazy[];\n  /** Whether the provider has finished enumerating all its columns. */\n  isFinal(): boolean;\n}\n\n/**\n * Unified memoised factory dispatching to the right provider flavour by the\n * source shape:\n * - `TreeNodeAccessor` → {@link AccessorColumnsProvider}\n *   (indexed by `root.handle`, walks the accessor tree once per root).\n * - `UpstreamBlockCtx<AccessorHandle>[]` (or omitted — pulled from the\n *   ambient ctx) → {@link ResultPoolColumnsProvider}\n *   (indexed by a content-hash of the block list).\n *\n * Both branches return cached instances within their LRU window, so repeated\n * calls with the same source skip re-walking / re-hashing.\n */\nexport function ColumnsProvider(\n  source?: TreeNodeAccessor | ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>,\n) {\n  if (isNil(source) || Array.isArray(source)) {\n    return ResultPoolColumnsProvider(source);\n  } else if (source instanceof TreeNodeAccessor) {\n    return AccessorColumnsProvider(source);\n  } else {\n    throw new Error(\"Unknown columns provider source\");\n  }\n}\n\n/**\n * Memoised constructor — same `root.handle` returns the same\n * {@link AccessorColumnsProviderImpl}, so `indexAccessorRoot` runs once per\n * accessor root (within the LRU window).\n */\nconst _accessorProviderCache = new LRUCache<AccessorHandle, AccessorColumnsProviderImpl>({\n  max: 64,\n});\nexport function AccessorColumnsProvider(root: TreeNodeAccessor): AccessorColumnsProvider {\n  let provider = _accessorProviderCache.get(root.handle);\n  if (provider === undefined) {\n    provider = new AccessorColumnsProviderImpl(root);\n    _accessorProviderCache.set(root.handle, provider);\n  }\n  return provider;\n}\n\n/**\n * Memoised constructor — same `rawPool` content returns the same\n * {@link ResultPoolColumnsProviderImpl}, so `indexPoolBlock` runs once per\n * pool snapshot (within the LRU window).\n */\nconst _resultPoolProviderCache = new LRUCache<string, ResultPoolColumnsProviderImpl>({ max: 4 });\nexport function ResultPoolColumnsProvider(\n  rawPool: ReadonlyArray<\n    UpstreamBlockCtx<AccessorHandle>\n  > = getCfgRenderCtx().getUpstreamBlockCtx(),\n): ResultPoolColumnsProvider {\n  const key = hashRawPool(rawPool);\n  let provider = _resultPoolProviderCache.get(key);\n  if (provider === undefined) {\n    provider = new ResultPoolColumnsProviderImpl(rawPool);\n    _resultPoolProviderCache.set(key, provider);\n  }\n  return provider;\n}\n\n/**\n * Simple provider wrapping an array of PColumns. Sandbox-only —\n * implements {@link ColumnsProvider} (lazy-view enumeration). It is *not* an\n * id-index source — `ColumnRegistry` does not consume it.\n */\nexport class ArrayColumnsProvider implements ColumnsProvider {\n  private readonly columns: ColumnLazy[];\n\n  constructor(\n    columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | ColumnLazy>,\n    private readonly _isFinal: boolean,\n  ) {\n    this.columns = columns.map((c) => ColumnLazyImpl.fromColumn(c));\n  }\n\n  getColumns(): ColumnLazy[] {\n    return this.columns;\n  }\n\n  isFinal(): boolean {\n    return this._isFinal;\n  }\n}\n\n/**\n * Sandbox-specific provider over a {@link TreeNodeAccessor} root. Uses the\n * accessor's own `resolvePath` as the canonical root path for id construction,\n * and adds `getColumns()` returning {@link ColumnLazy}s on top of the generic\n * entries index.\n */\nexport class AccessorColumnsProviderImpl\n  extends AccessorEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: ColumnLazy[];\n\n  constructor(root: TreeNodeAccessor) {\n    super(root, root.resolvePath);\n  }\n\n  getColumns(): ColumnLazy[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(this.entries.values())\n      .map((e) => ColumnLazyImpl.fromAccessor(e))\n      .filter((v): v is ColumnLazy => !isNil(v)));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type AccessorColumnsProvider = AccessorColumnsProviderImpl;\n\n/**\n * Sandbox-specific result-pool provider. Accepts the raw handle-shaped blocks\n * returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx} and\n * wraps them into {@link TreeNodeAccessor}s, then adds `getColumns()`.\n */\nexport class ResultPoolColumnsProviderImpl\n  extends ResultPoolEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: ColumnLazy[];\n\n  constructor(\n    rawPool: ReadonlyArray<\n      UpstreamBlockCtx<AccessorHandle>\n    > = getCfgRenderCtx().getUpstreamBlockCtx(),\n  ) {\n    const blocks = rawPool.map((b) => ({\n      blockId: b.blockId,\n      prodCtx:\n        b.prodCtx !== undefined\n          ? new TreeNodeAccessor(b.prodCtx, [b.blockId, \"prodCtx\"])\n          : undefined,\n      stagingCtx:\n        b.stagingCtx !== undefined\n          ? new TreeNodeAccessor(b.stagingCtx, [b.blockId, \"stagingCtx\"])\n          : undefined,\n      prodIncomplete: b.prodIncomplete,\n      stagingIncomplete: b.stagingIncomplete,\n    }));\n\n    super(blocks);\n  }\n\n  getColumns(): ColumnLazy[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(this.getPObjectEntries().values())\n      .map((e) => ColumnLazyImpl.fromAccessor(e))\n      .filter((v): v is ColumnLazy => !isNil(v)));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type ResultPoolColumnsProvider = ResultPoolColumnsProviderImpl;\n\nfunction hashRawPool(rawPool: ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>): string {\n  return rawPool\n    .map(\n      (b) =>\n        `${b.blockId}\\x1f${b.prodCtx ?? \"\"}\\x1f${b.stagingCtx ?? \"\"}\\x1f${\n          b.prodIncomplete ? 1 : 0\n        }\\x1f${b.stagingIncomplete ? 1 : 0}`,\n    )\n    .join(\"\\x1e\");\n}\n"],"mappings":"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"}
+{"version":3,"file":"providers.cjs","names":["TreeNodeAccessor","LRUCache","getCfgRenderCtx","DataColumn","AccessorEntriesProvider","ResultPoolEntriesProvider"],"sources":["../../../src/columns/column_providers/providers.ts"],"sourcesContent":["import {\n  AccessorEntriesProvider,\n  ResultPoolEntriesProvider,\n  type PColumn,\n  type PObjectId,\n  type UpstreamBlockCtx,\n} from \"@milaboratories/pl-model-common\";\nimport { AccessorHandle, PColumnDataUniversal, TreeNodeAccessor } from \"../../render\";\nimport { DataColumn, DataColumnRecipe } from \"../data_column\";\nimport { getCfgRenderCtx } from \"../../internal\";\nimport { isNil } from \"es-toolkit\";\nimport { LRUCache } from \"lru-cache\";\n\n/**\n * Data source for sandbox column-list builders. Has nothing to say about\n * id-resolution — `ColumnRegistry` (in `@milaboratories/pl-model-common`)\n * consumes the separate `ColumnEntriesProvider` interface for that.\n *\n * Same name as the factory function below — they merge into one TS\n * declaration: `ColumnsProvider` is callable AND the interface type.\n */\nexport interface ColumnsProvider {\n  /** Returns all currently known PColumn columns as lazy views. */\n  getColumns(): DataColumnRecipe<PObjectId>[];\n  /** Whether the provider has finished enumerating all its columns. */\n  isFinal(): boolean;\n}\n\n/**\n * Unified memoised factory dispatching to the right provider flavour by the\n * source shape:\n * - `TreeNodeAccessor` → {@link AccessorColumnsProvider}\n *   (indexed by `root.handle`, walks the accessor tree once per root).\n * - `UpstreamBlockCtx<AccessorHandle>[]` (or omitted — pulled from the\n *   ambient ctx) → {@link ResultPoolColumnsProvider}\n *   (indexed by a content-hash of the block list).\n *\n * Both branches return cached instances within their LRU window, so repeated\n * calls with the same source skip re-walking / re-hashing.\n */\nexport function ColumnsProvider(\n  source?: TreeNodeAccessor | ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>,\n) {\n  if (isNil(source) || Array.isArray(source)) {\n    return ResultPoolColumnsProvider(source);\n  } else if (source instanceof TreeNodeAccessor) {\n    return AccessorColumnsProvider(source);\n  } else {\n    throw new Error(\"Unknown columns provider source\");\n  }\n}\n\n/**\n * Memoised constructor — same `root.handle` returns the same\n * {@link AccessorColumnsProviderImpl}, so `indexAccessorRoot` runs once per\n * accessor root (within the LRU window).\n */\nconst _accessorProviderCache = new LRUCache<AccessorHandle, AccessorColumnsProviderImpl>({\n  max: 64,\n});\nexport function AccessorColumnsProvider(root: TreeNodeAccessor): AccessorColumnsProvider {\n  let provider = _accessorProviderCache.get(root.handle);\n  if (provider === undefined) {\n    provider = new AccessorColumnsProviderImpl(root);\n    _accessorProviderCache.set(root.handle, provider);\n  }\n  return provider;\n}\n\n/**\n * Memoised constructor — same `rawPool` content returns the same\n * {@link ResultPoolColumnsProviderImpl}, so `indexPoolBlock` runs once per\n * pool snapshot (within the LRU window).\n */\nconst _resultPoolProviderCache = new LRUCache<string, ResultPoolColumnsProviderImpl>({ max: 4 });\nexport function ResultPoolColumnsProvider(\n  rawPool: ReadonlyArray<\n    UpstreamBlockCtx<AccessorHandle>\n  > = getCfgRenderCtx().getUpstreamBlockCtx(),\n): ResultPoolColumnsProvider {\n  const key = hashRawPool(rawPool);\n  let provider = _resultPoolProviderCache.get(key);\n  if (provider === undefined) {\n    provider = new ResultPoolColumnsProviderImpl(rawPool);\n    _resultPoolProviderCache.set(key, provider);\n  }\n  return provider;\n}\n\n/**\n * Simple provider wrapping an array of PColumns. Sandbox-only —\n * implements {@link ColumnsProvider} (lazy-view enumeration). It is *not* an\n * id-index source — `ColumnRegistry` does not consume it.\n */\nexport class ArrayColumnsProvider implements ColumnsProvider {\n  private readonly columns: DataColumnRecipe<PObjectId>[];\n\n  constructor(\n    columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | DataColumnRecipe<PObjectId>>,\n    private readonly _isFinal: boolean,\n  ) {\n    this.columns = columns.map((c) => DataColumn.fromColumn(c));\n  }\n\n  getColumns(): DataColumnRecipe<PObjectId>[] {\n    return this.columns;\n  }\n\n  isFinal(): boolean {\n    return this._isFinal;\n  }\n}\n\n/**\n * Sandbox-specific provider over a {@link TreeNodeAccessor} root. Uses the\n * accessor's own `resolvePath` as the canonical root path for id construction,\n * and adds `getColumns()` returning {@link DataColumnRecipe<PObjectId>}s on top of the generic\n * entries index.\n */\nexport class AccessorColumnsProviderImpl\n  extends AccessorEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: DataColumnRecipe<PObjectId>[];\n\n  constructor(root: TreeNodeAccessor) {\n    super(root, root.resolvePath);\n  }\n\n  getColumns(): DataColumnRecipe<PObjectId>[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(this.entries.values())\n      .map((e) => DataColumn.fromAccessor(e))\n      .filter((v): v is DataColumnRecipe<PObjectId> => !isNil(v)));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type AccessorColumnsProvider = AccessorColumnsProviderImpl;\n\n/**\n * Sandbox-specific result-pool provider. Accepts the raw handle-shaped blocks\n * returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx} and\n * wraps them into {@link TreeNodeAccessor}s, then adds `getColumns()`.\n */\nexport class ResultPoolColumnsProviderImpl\n  extends ResultPoolEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: DataColumnRecipe<PObjectId>[];\n\n  constructor(\n    rawPool: ReadonlyArray<\n      UpstreamBlockCtx<AccessorHandle>\n    > = getCfgRenderCtx().getUpstreamBlockCtx(),\n  ) {\n    const blocks = rawPool.map((b) => ({\n      blockId: b.blockId,\n      prodCtx:\n        b.prodCtx !== undefined\n          ? new TreeNodeAccessor(b.prodCtx, [b.blockId, \"prodCtx\"])\n          : undefined,\n      stagingCtx:\n        b.stagingCtx !== undefined\n          ? new TreeNodeAccessor(b.stagingCtx, [b.blockId, \"stagingCtx\"])\n          : undefined,\n      prodIncomplete: b.prodIncomplete,\n      stagingIncomplete: b.stagingIncomplete,\n    }));\n\n    super(blocks);\n  }\n\n  getColumns(): DataColumnRecipe<PObjectId>[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(this.getPObjectEntries().values())\n      .map((e) => DataColumn.fromAccessor(e))\n      .filter((v): v is DataColumnRecipe<PObjectId> => !isNil(v)));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type ResultPoolColumnsProvider = ResultPoolColumnsProviderImpl;\n\nfunction hashRawPool(rawPool: ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>): string {\n  return rawPool\n    .map(\n      (b) =>\n        `${b.blockId}\\x1f${b.prodCtx ?? \"\"}\\x1f${b.stagingCtx ?? \"\"}\\x1f${\n          b.prodIncomplete ? 1 : 0\n        }\\x1f${b.stagingIncomplete ? 1 : 0}`,\n    )\n    .join(\"\\x1e\");\n}\n"],"mappings":"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"}

package/dist/columns/column_providers/providers.d.ts

@@ -1,7 +1,7 @@
 import { AccessorHandle, PColumnDataUniversal } from "../../render/internal.js";
 import { TreeNodeAccessor } from "../../render/accessor.js";
-import { ColumnLazy } from "../column_lazy.js";
-import { AccessorEntriesProvider, PColumn, ResultPoolEntriesProvider, UpstreamBlockCtx } from "@milaboratories/pl-model-common";
+import { DataColumnRecipe } from "../data_column.js";
+import { AccessorEntriesProvider, PColumn, PObjectId, ResultPoolEntriesProvider, UpstreamBlockCtx } from "@milaboratories/pl-model-common";
 
 //#region src/columns/column_providers/providers.d.ts
 /**
@@ -14,7 +14,7 @@ import { AccessorEntriesProvider, PColumn, ResultPoolEntriesProvider, UpstreamBl
  */
 interface ColumnsProvider {
   /** Returns all currently known PColumn columns as lazy views. */
-  getColumns(): ColumnLazy[];
+  getColumns(): DataColumnRecipe<PObjectId>[];
   /** Whether the provider has finished enumerating all its columns. */
   isFinal(): boolean;
 }
@@ -41,20 +41,20 @@ declare function ResultPoolColumnsProvider(rawPool?: ReadonlyArray<UpstreamBlock
 declare class ArrayColumnsProvider implements ColumnsProvider {
   private readonly _isFinal;
   private readonly columns;
-  constructor(columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | ColumnLazy>, _isFinal: boolean);
-  getColumns(): ColumnLazy[];
+  constructor(columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | DataColumnRecipe<PObjectId>>, _isFinal: boolean);
+  getColumns(): DataColumnRecipe<PObjectId>[];
   isFinal(): boolean;
 }
 /**
  * Sandbox-specific provider over a {@link TreeNodeAccessor} root. Uses the
  * accessor's own `resolvePath` as the canonical root path for id construction,
- * and adds `getColumns()` returning {@link ColumnLazy}s on top of the generic
+ * and adds `getColumns()` returning {@link DataColumnRecipe<PObjectId>}s on top of the generic
  * entries index.
  */
 declare class AccessorColumnsProviderImpl extends AccessorEntriesProvider<TreeNodeAccessor> implements ColumnsProvider {
   private cachedColumns?;
   constructor(root: TreeNodeAccessor);
-  getColumns(): ColumnLazy[];
+  getColumns(): DataColumnRecipe<PObjectId>[];
 }
 /** Public type alias — value of the same name is the memoised factory above. */
 type AccessorColumnsProvider = AccessorColumnsProviderImpl;
@@ -66,7 +66,7 @@ type AccessorColumnsProvider = AccessorColumnsProviderImpl;
 declare class ResultPoolColumnsProviderImpl extends ResultPoolEntriesProvider<TreeNodeAccessor> implements ColumnsProvider {
   private cachedColumns?;
   constructor(rawPool?: ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>);
-  getColumns(): ColumnLazy[];
+  getColumns(): DataColumnRecipe<PObjectId>[];
 }
 /** Public type alias — value of the same name is the memoised factory above. */
 type ResultPoolColumnsProvider = ResultPoolColumnsProviderImpl;

package/dist/columns/column_providers/providers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"providers.d.ts","names":[],"sources":["../../../src/columns/column_providers/providers.ts"],"mappings":";;;;;;;;;;AAoBA;;;;UAAiB,eAAA;EAED;EAAd,UAAA,IAAc,UAAU;EAEjB;EAAP,OAAA;AAAA;;;;;;;;;;;;;iBAec,eAAA,CACd,MAAA,GAAS,gBAAA,GAAmB,aAAA,CAAc,gBAAA,CAAiB,cAAA,KAAgB,6BAAA,GAAA,2BAAA;AAAA,iBAmB7D,uBAAA,CAAwB,IAAA,EAAM,gBAAA,GAAmB,uBAAuB;AAAA,iBAexE,yBAAA,CACd,OAAA,GAAS,aAAA,CACP,gBAAA,CAAiB,cAAA,KAElB,yBAAA;;;;AAtC0E;AAmB7E;cAkCa,oBAAA,YAAgC,eAAA;EAAA,iBAKxB,QAAA;EAAA,iBAJF,OAAA;cAGf,OAAA,EAAS,aAAA,CAAc,OAAA,aAAoB,oBAAA,IAAwB,UAAA,GAClD,QAAA;EAKnB,UAAA,IAAc,UAAA;EAId,OAAA;AAAA;AAhDsF;AAexF;;;;;AAfwF,cA2D3E,2BAAA,SACH,uBAAA,CAAwB,gBAAA,aACrB,eAAA;EAAA,QAEH,aAAA;cAEI,IAAA,EAAM,gBAAA;EAIlB,UAAA,IAAc,UAAA;AAAA;;KASJ,uBAAA,GAA0B,2BAA2B;;;;AA3DrC;AAe5B;cAmDa,6BAAA,SACH,yBAAA,CAA0B,gBAAA,aACvB,eAAA;EAAA,QAEH,aAAA;cAGN,OAAA,GAAS,aAAA,CACP,gBAAA,CAAiB,cAAA;EAoBrB,UAAA,IAAc,UAAA;AAAA;;KASJ,yBAAA,GAA4B,6BAA6B"}
+{"version":3,"file":"providers.d.ts","names":[],"sources":["../../../src/columns/column_providers/providers.ts"],"mappings":";;;;;;;;;;AAqBA;;;;UAAiB,eAAA;EAED;EAAd,UAAA,IAAc,gBAAgB,CAAC,SAAA;EAE/B;EAAA,OAAA;AAAA;AAeF;;;;;;;;;;;;AAAA,iBAAgB,eAAA,CACd,MAAA,GAAS,gBAAA,GAAmB,aAAA,CAAc,gBAAA,CAAiB,cAAA,KAAgB,6BAAA,GAAA,2BAAA;AAAA,iBAmB7D,uBAAA,CAAwB,IAAA,EAAM,gBAAA,GAAmB,uBAAuB;AAAA,iBAexE,yBAAA,CACd,OAAA,GAAS,aAAA,CACP,gBAAA,CAAiB,cAAA,KAElB,yBAAA;;;;;AAtC0E;cAqDhE,oBAAA,YAAgC,eAAA;EAAA,iBAKxB,QAAA;EAAA,iBAJF,OAAA;cAGf,OAAA,EAAS,aAAA,CAAc,OAAA,aAAoB,oBAAA,IAAwB,gBAAA,CAAiB,SAAA,IACnE,QAAA;EAKnB,UAAA,IAAc,gBAAA,CAAiB,SAAA;EAI/B,OAAA;AAAA;;AAhDsF;AAexF;;;;cA4Ca,2BAAA,SACH,uBAAA,CAAwB,gBAAA,aACrB,eAAA;EAAA,QAEH,aAAA;cAEI,IAAA,EAAM,gBAAA;EAIlB,UAAA,IAAc,gBAAA,CAAiB,SAAA;AAAA;;KASrB,uBAAA,GAA0B,2BAA2B;;;;;AA3DrC;cAkEf,6BAAA,SACH,yBAAA,CAA0B,gBAAA,aACvB,eAAA;EAAA,QAEH,aAAA;cAGN,OAAA,GAAS,aAAA,CACP,gBAAA,CAAiB,cAAA;EAoBrB,UAAA,IAAc,gBAAA,CAAiB,SAAA;AAAA;;KASrB,yBAAA,GAA4B,6BAA6B"}

package/dist/columns/column_providers/providers.js

@@ -1,7 +1,7 @@
 import { getCfgRenderCtx } from "../../internal.js";
 import { TreeNodeAccessor } from "../../render/accessor.js";
 import "../../render/index.js";
-import { ColumnLazyImpl } from "../column_lazy.js";
+import { DataColumn } from "../data_column.js";
 import { AccessorEntriesProvider, ResultPoolEntriesProvider } from "@milaboratories/pl-model-common";
 import { isNil } from "es-toolkit";
 import { LRUCache } from "lru-cache";
@@ -62,7 +62,7 @@ var ArrayColumnsProvider = class {
 	columns;
 	constructor(columns, _isFinal) {
 		this._isFinal = _isFinal;
-		this.columns = columns.map((c) => ColumnLazyImpl.fromColumn(c));
+		this.columns = columns.map((c) => DataColumn.fromColumn(c));
 	}
 	getColumns() {
 		return this.columns;
@@ -74,7 +74,7 @@ var ArrayColumnsProvider = class {
 /**
 * Sandbox-specific provider over a {@link TreeNodeAccessor} root. Uses the
 * accessor's own `resolvePath` as the canonical root path for id construction,
-* and adds `getColumns()` returning {@link ColumnLazy}s on top of the generic
+* and adds `getColumns()` returning {@link DataColumnRecipe<PObjectId>}s on top of the generic
 * entries index.
 */
 var AccessorColumnsProviderImpl = class extends AccessorEntriesProvider {
@@ -84,7 +84,7 @@ var AccessorColumnsProviderImpl = class extends AccessorEntriesProvider {
 	}
 	getColumns() {
 		if (this.cachedColumns !== void 0) return this.cachedColumns;
-		return this.cachedColumns = Array.from(this.entries.values()).map((e) => ColumnLazyImpl.fromAccessor(e)).filter((v) => !isNil(v));
+		return this.cachedColumns = Array.from(this.entries.values()).map((e) => DataColumn.fromAccessor(e)).filter((v) => !isNil(v));
 	}
 };
 /**
@@ -106,7 +106,7 @@ var ResultPoolColumnsProviderImpl = class extends ResultPoolEntriesProvider {
 	}
 	getColumns() {
 		if (this.cachedColumns !== void 0) return this.cachedColumns;
-		return this.cachedColumns = Array.from(this.getPObjectEntries().values()).map((e) => ColumnLazyImpl.fromAccessor(e)).filter((v) => !isNil(v));
+		return this.cachedColumns = Array.from(this.getPObjectEntries().values()).map((e) => DataColumn.fromAccessor(e)).filter((v) => !isNil(v));
 	}
 };
 function hashRawPool(rawPool) {

package/dist/columns/column_providers/providers.js.map

@@ -1 +1 @@
-{"version":3,"file":"providers.js","names":[],"sources":["../../../src/columns/column_providers/providers.ts"],"sourcesContent":["import {\n  AccessorEntriesProvider,\n  ResultPoolEntriesProvider,\n  type PColumn,\n  type UpstreamBlockCtx,\n} from \"@milaboratories/pl-model-common\";\nimport { AccessorHandle, PColumnDataUniversal, TreeNodeAccessor } from \"../../render\";\nimport { ColumnLazy, ColumnLazyImpl } from \"../column_lazy\";\nimport { getCfgRenderCtx } from \"../../internal\";\nimport { isNil } from \"es-toolkit\";\nimport { LRUCache } from \"lru-cache\";\n\n/**\n * Data source for sandbox column-list builders. Has nothing to say about\n * id-resolution — `ColumnRegistry` (in `@milaboratories/pl-model-common`)\n * consumes the separate `ColumnEntriesProvider` interface for that.\n *\n * Same name as the factory function below — they merge into one TS\n * declaration: `ColumnsProvider` is callable AND the interface type.\n */\nexport interface ColumnsProvider {\n  /** Returns all currently known PColumn columns as lazy views. */\n  getColumns(): ColumnLazy[];\n  /** Whether the provider has finished enumerating all its columns. */\n  isFinal(): boolean;\n}\n\n/**\n * Unified memoised factory dispatching to the right provider flavour by the\n * source shape:\n * - `TreeNodeAccessor` → {@link AccessorColumnsProvider}\n *   (indexed by `root.handle`, walks the accessor tree once per root).\n * - `UpstreamBlockCtx<AccessorHandle>[]` (or omitted — pulled from the\n *   ambient ctx) → {@link ResultPoolColumnsProvider}\n *   (indexed by a content-hash of the block list).\n *\n * Both branches return cached instances within their LRU window, so repeated\n * calls with the same source skip re-walking / re-hashing.\n */\nexport function ColumnsProvider(\n  source?: TreeNodeAccessor | ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>,\n) {\n  if (isNil(source) || Array.isArray(source)) {\n    return ResultPoolColumnsProvider(source);\n  } else if (source instanceof TreeNodeAccessor) {\n    return AccessorColumnsProvider(source);\n  } else {\n    throw new Error(\"Unknown columns provider source\");\n  }\n}\n\n/**\n * Memoised constructor — same `root.handle` returns the same\n * {@link AccessorColumnsProviderImpl}, so `indexAccessorRoot` runs once per\n * accessor root (within the LRU window).\n */\nconst _accessorProviderCache = new LRUCache<AccessorHandle, AccessorColumnsProviderImpl>({\n  max: 64,\n});\nexport function AccessorColumnsProvider(root: TreeNodeAccessor): AccessorColumnsProvider {\n  let provider = _accessorProviderCache.get(root.handle);\n  if (provider === undefined) {\n    provider = new AccessorColumnsProviderImpl(root);\n    _accessorProviderCache.set(root.handle, provider);\n  }\n  return provider;\n}\n\n/**\n * Memoised constructor — same `rawPool` content returns the same\n * {@link ResultPoolColumnsProviderImpl}, so `indexPoolBlock` runs once per\n * pool snapshot (within the LRU window).\n */\nconst _resultPoolProviderCache = new LRUCache<string, ResultPoolColumnsProviderImpl>({ max: 4 });\nexport function ResultPoolColumnsProvider(\n  rawPool: ReadonlyArray<\n    UpstreamBlockCtx<AccessorHandle>\n  > = getCfgRenderCtx().getUpstreamBlockCtx(),\n): ResultPoolColumnsProvider {\n  const key = hashRawPool(rawPool);\n  let provider = _resultPoolProviderCache.get(key);\n  if (provider === undefined) {\n    provider = new ResultPoolColumnsProviderImpl(rawPool);\n    _resultPoolProviderCache.set(key, provider);\n  }\n  return provider;\n}\n\n/**\n * Simple provider wrapping an array of PColumns. Sandbox-only —\n * implements {@link ColumnsProvider} (lazy-view enumeration). It is *not* an\n * id-index source — `ColumnRegistry` does not consume it.\n */\nexport class ArrayColumnsProvider implements ColumnsProvider {\n  private readonly columns: ColumnLazy[];\n\n  constructor(\n    columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | ColumnLazy>,\n    private readonly _isFinal: boolean,\n  ) {\n    this.columns = columns.map((c) => ColumnLazyImpl.fromColumn(c));\n  }\n\n  getColumns(): ColumnLazy[] {\n    return this.columns;\n  }\n\n  isFinal(): boolean {\n    return this._isFinal;\n  }\n}\n\n/**\n * Sandbox-specific provider over a {@link TreeNodeAccessor} root. Uses the\n * accessor's own `resolvePath` as the canonical root path for id construction,\n * and adds `getColumns()` returning {@link ColumnLazy}s on top of the generic\n * entries index.\n */\nexport class AccessorColumnsProviderImpl\n  extends AccessorEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: ColumnLazy[];\n\n  constructor(root: TreeNodeAccessor) {\n    super(root, root.resolvePath);\n  }\n\n  getColumns(): ColumnLazy[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(this.entries.values())\n      .map((e) => ColumnLazyImpl.fromAccessor(e))\n      .filter((v): v is ColumnLazy => !isNil(v)));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type AccessorColumnsProvider = AccessorColumnsProviderImpl;\n\n/**\n * Sandbox-specific result-pool provider. Accepts the raw handle-shaped blocks\n * returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx} and\n * wraps them into {@link TreeNodeAccessor}s, then adds `getColumns()`.\n */\nexport class ResultPoolColumnsProviderImpl\n  extends ResultPoolEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: ColumnLazy[];\n\n  constructor(\n    rawPool: ReadonlyArray<\n      UpstreamBlockCtx<AccessorHandle>\n    > = getCfgRenderCtx().getUpstreamBlockCtx(),\n  ) {\n    const blocks = rawPool.map((b) => ({\n      blockId: b.blockId,\n      prodCtx:\n        b.prodCtx !== undefined\n          ? new TreeNodeAccessor(b.prodCtx, [b.blockId, \"prodCtx\"])\n          : undefined,\n      stagingCtx:\n        b.stagingCtx !== undefined\n          ? new TreeNodeAccessor(b.stagingCtx, [b.blockId, \"stagingCtx\"])\n          : undefined,\n      prodIncomplete: b.prodIncomplete,\n      stagingIncomplete: b.stagingIncomplete,\n    }));\n\n    super(blocks);\n  }\n\n  getColumns(): ColumnLazy[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(this.getPObjectEntries().values())\n      .map((e) => ColumnLazyImpl.fromAccessor(e))\n      .filter((v): v is ColumnLazy => !isNil(v)));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type ResultPoolColumnsProvider = ResultPoolColumnsProviderImpl;\n\nfunction hashRawPool(rawPool: ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>): string {\n  return rawPool\n    .map(\n      (b) =>\n        `${b.blockId}\\x1f${b.prodCtx ?? \"\"}\\x1f${b.stagingCtx ?? \"\"}\\x1f${\n          b.prodIncomplete ? 1 : 0\n        }\\x1f${b.stagingIncomplete ? 1 : 0}`,\n    )\n    .join(\"\\x1e\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,gBACd,QACA;CACA,IAAI,MAAM,MAAM,KAAK,MAAM,QAAQ,MAAM,GACvC,OAAO,0BAA0B,MAAM;MAClC,IAAI,kBAAkB,kBAC3B,OAAO,wBAAwB,MAAM;MAErC,MAAM,IAAI,MAAM,iCAAiC;AAErD;;;;;;AAOA,MAAM,yBAAyB,IAAI,SAAsD,EACvF,KAAK,GACP,CAAC;AACD,SAAgB,wBAAwB,MAAiD;CACvF,IAAI,WAAW,uBAAuB,IAAI,KAAK,MAAM;CACrD,IAAI,aAAa,KAAA,GAAW;EAC1B,WAAW,IAAI,4BAA4B,IAAI;EAC/C,uBAAuB,IAAI,KAAK,QAAQ,QAAQ;CAClD;CACA,OAAO;AACT;;;;;;AAOA,MAAM,2BAA2B,IAAI,SAAgD,EAAE,KAAK,EAAE,CAAC;AAC/F,SAAgB,0BACd,UAEI,gBAAgB,CAAC,CAAC,oBAAoB,GACf;CAC3B,MAAM,MAAM,YAAY,OAAO;CAC/B,IAAI,WAAW,yBAAyB,IAAI,GAAG;CAC/C,IAAI,aAAa,KAAA,GAAW;EAC1B,WAAW,IAAI,8BAA8B,OAAO;EACpD,yBAAyB,IAAI,KAAK,QAAQ;CAC5C;CACA,OAAO;AACT;;;;;;AAOA,IAAa,uBAAb,MAA6D;CAKxC;CAJnB;CAEA,YACE,SACA,UACA;EADiB,KAAA,WAAA;EAEjB,KAAK,UAAU,QAAQ,KAAK,MAAM,eAAe,WAAW,CAAC,CAAC;CAChE;CAEA,aAA2B;EACzB,OAAO,KAAK;CACd;CAEA,UAAmB;EACjB,OAAO,KAAK;CACd;AACF;;;;;;;AAQA,IAAa,8BAAb,cACU,wBAEV;CACE;CAEA,YAAY,MAAwB;EAClC,MAAM,MAAM,KAAK,WAAW;CAC9B;CAEA,aAA2B;EACzB,IAAI,KAAK,kBAAkB,KAAA,GAAW,OAAO,KAAK;EAClD,OAAQ,KAAK,gBAAgB,MAAM,KAAK,KAAK,QAAQ,OAAO,CAAC,CAAC,CAC3D,KAAK,MAAM,eAAe,aAAa,CAAC,CAAC,CAAC,CAC1C,QAAQ,MAAuB,CAAC,MAAM,CAAC,CAAC;CAC7C;AACF;;;;;;AAUA,IAAa,gCAAb,cACU,0BAEV;CACE;CAEA,YACE,UAEI,gBAAgB,CAAC,CAAC,oBAAoB,GAC1C;EACA,MAAM,SAAS,QAAQ,KAAK,OAAO;GACjC,SAAS,EAAE;GACX,SACE,EAAE,YAAY,KAAA,IACV,IAAI,iBAAiB,EAAE,SAAS,CAAC,EAAE,SAAS,SAAS,CAAC,IACtD,KAAA;GACN,YACE,EAAE,eAAe,KAAA,IACb,IAAI,iBAAiB,EAAE,YAAY,CAAC,EAAE,SAAS,YAAY,CAAC,IAC5D,KAAA;GACN,gBAAgB,EAAE;GAClB,mBAAmB,EAAE;EACvB,EAAE;EAEF,MAAM,MAAM;CACd;CAEA,aAA2B;EACzB,IAAI,KAAK,kBAAkB,KAAA,GAAW,OAAO,KAAK;EAClD,OAAQ,KAAK,gBAAgB,MAAM,KAAK,KAAK,kBAAkB,CAAC,CAAC,OAAO,CAAC,CAAC,CACvE,KAAK,MAAM,eAAe,aAAa,CAAC,CAAC,CAAC,CAC1C,QAAQ,MAAuB,CAAC,MAAM,CAAC,CAAC;CAC7C;AACF;AAKA,SAAS,YAAY,SAAkE;CACrF,OAAO,QACJ,KACE,MACC,GAAG,EAAE,QAAQ,MAAM,EAAE,WAAW,GAAG,MAAM,EAAE,cAAc,GAAG,MAC1D,EAAE,iBAAiB,IAAI,EACxB,MAAM,EAAE,oBAAoB,IAAI,GACrC,CAAC,CACA,KAAK,GAAM;AAChB"}
+{"version":3,"file":"providers.js","names":[],"sources":["../../../src/columns/column_providers/providers.ts"],"sourcesContent":["import {\n  AccessorEntriesProvider,\n  ResultPoolEntriesProvider,\n  type PColumn,\n  type PObjectId,\n  type UpstreamBlockCtx,\n} from \"@milaboratories/pl-model-common\";\nimport { AccessorHandle, PColumnDataUniversal, TreeNodeAccessor } from \"../../render\";\nimport { DataColumn, DataColumnRecipe } from \"../data_column\";\nimport { getCfgRenderCtx } from \"../../internal\";\nimport { isNil } from \"es-toolkit\";\nimport { LRUCache } from \"lru-cache\";\n\n/**\n * Data source for sandbox column-list builders. Has nothing to say about\n * id-resolution — `ColumnRegistry` (in `@milaboratories/pl-model-common`)\n * consumes the separate `ColumnEntriesProvider` interface for that.\n *\n * Same name as the factory function below — they merge into one TS\n * declaration: `ColumnsProvider` is callable AND the interface type.\n */\nexport interface ColumnsProvider {\n  /** Returns all currently known PColumn columns as lazy views. */\n  getColumns(): DataColumnRecipe<PObjectId>[];\n  /** Whether the provider has finished enumerating all its columns. */\n  isFinal(): boolean;\n}\n\n/**\n * Unified memoised factory dispatching to the right provider flavour by the\n * source shape:\n * - `TreeNodeAccessor` → {@link AccessorColumnsProvider}\n *   (indexed by `root.handle`, walks the accessor tree once per root).\n * - `UpstreamBlockCtx<AccessorHandle>[]` (or omitted — pulled from the\n *   ambient ctx) → {@link ResultPoolColumnsProvider}\n *   (indexed by a content-hash of the block list).\n *\n * Both branches return cached instances within their LRU window, so repeated\n * calls with the same source skip re-walking / re-hashing.\n */\nexport function ColumnsProvider(\n  source?: TreeNodeAccessor | ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>,\n) {\n  if (isNil(source) || Array.isArray(source)) {\n    return ResultPoolColumnsProvider(source);\n  } else if (source instanceof TreeNodeAccessor) {\n    return AccessorColumnsProvider(source);\n  } else {\n    throw new Error(\"Unknown columns provider source\");\n  }\n}\n\n/**\n * Memoised constructor — same `root.handle` returns the same\n * {@link AccessorColumnsProviderImpl}, so `indexAccessorRoot` runs once per\n * accessor root (within the LRU window).\n */\nconst _accessorProviderCache = new LRUCache<AccessorHandle, AccessorColumnsProviderImpl>({\n  max: 64,\n});\nexport function AccessorColumnsProvider(root: TreeNodeAccessor): AccessorColumnsProvider {\n  let provider = _accessorProviderCache.get(root.handle);\n  if (provider === undefined) {\n    provider = new AccessorColumnsProviderImpl(root);\n    _accessorProviderCache.set(root.handle, provider);\n  }\n  return provider;\n}\n\n/**\n * Memoised constructor — same `rawPool` content returns the same\n * {@link ResultPoolColumnsProviderImpl}, so `indexPoolBlock` runs once per\n * pool snapshot (within the LRU window).\n */\nconst _resultPoolProviderCache = new LRUCache<string, ResultPoolColumnsProviderImpl>({ max: 4 });\nexport function ResultPoolColumnsProvider(\n  rawPool: ReadonlyArray<\n    UpstreamBlockCtx<AccessorHandle>\n  > = getCfgRenderCtx().getUpstreamBlockCtx(),\n): ResultPoolColumnsProvider {\n  const key = hashRawPool(rawPool);\n  let provider = _resultPoolProviderCache.get(key);\n  if (provider === undefined) {\n    provider = new ResultPoolColumnsProviderImpl(rawPool);\n    _resultPoolProviderCache.set(key, provider);\n  }\n  return provider;\n}\n\n/**\n * Simple provider wrapping an array of PColumns. Sandbox-only —\n * implements {@link ColumnsProvider} (lazy-view enumeration). It is *not* an\n * id-index source — `ColumnRegistry` does not consume it.\n */\nexport class ArrayColumnsProvider implements ColumnsProvider {\n  private readonly columns: DataColumnRecipe<PObjectId>[];\n\n  constructor(\n    columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | DataColumnRecipe<PObjectId>>,\n    private readonly _isFinal: boolean,\n  ) {\n    this.columns = columns.map((c) => DataColumn.fromColumn(c));\n  }\n\n  getColumns(): DataColumnRecipe<PObjectId>[] {\n    return this.columns;\n  }\n\n  isFinal(): boolean {\n    return this._isFinal;\n  }\n}\n\n/**\n * Sandbox-specific provider over a {@link TreeNodeAccessor} root. Uses the\n * accessor's own `resolvePath` as the canonical root path for id construction,\n * and adds `getColumns()` returning {@link DataColumnRecipe<PObjectId>}s on top of the generic\n * entries index.\n */\nexport class AccessorColumnsProviderImpl\n  extends AccessorEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: DataColumnRecipe<PObjectId>[];\n\n  constructor(root: TreeNodeAccessor) {\n    super(root, root.resolvePath);\n  }\n\n  getColumns(): DataColumnRecipe<PObjectId>[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(this.entries.values())\n      .map((e) => DataColumn.fromAccessor(e))\n      .filter((v): v is DataColumnRecipe<PObjectId> => !isNil(v)));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type AccessorColumnsProvider = AccessorColumnsProviderImpl;\n\n/**\n * Sandbox-specific result-pool provider. Accepts the raw handle-shaped blocks\n * returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx} and\n * wraps them into {@link TreeNodeAccessor}s, then adds `getColumns()`.\n */\nexport class ResultPoolColumnsProviderImpl\n  extends ResultPoolEntriesProvider<TreeNodeAccessor>\n  implements ColumnsProvider\n{\n  private cachedColumns?: DataColumnRecipe<PObjectId>[];\n\n  constructor(\n    rawPool: ReadonlyArray<\n      UpstreamBlockCtx<AccessorHandle>\n    > = getCfgRenderCtx().getUpstreamBlockCtx(),\n  ) {\n    const blocks = rawPool.map((b) => ({\n      blockId: b.blockId,\n      prodCtx:\n        b.prodCtx !== undefined\n          ? new TreeNodeAccessor(b.prodCtx, [b.blockId, \"prodCtx\"])\n          : undefined,\n      stagingCtx:\n        b.stagingCtx !== undefined\n          ? new TreeNodeAccessor(b.stagingCtx, [b.blockId, \"stagingCtx\"])\n          : undefined,\n      prodIncomplete: b.prodIncomplete,\n      stagingIncomplete: b.stagingIncomplete,\n    }));\n\n    super(blocks);\n  }\n\n  getColumns(): DataColumnRecipe<PObjectId>[] {\n    if (this.cachedColumns !== undefined) return this.cachedColumns;\n    return (this.cachedColumns = Array.from(this.getPObjectEntries().values())\n      .map((e) => DataColumn.fromAccessor(e))\n      .filter((v): v is DataColumnRecipe<PObjectId> => !isNil(v)));\n  }\n}\n\n/** Public type alias — value of the same name is the memoised factory above. */\nexport type ResultPoolColumnsProvider = ResultPoolColumnsProviderImpl;\n\nfunction hashRawPool(rawPool: ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>): string {\n  return rawPool\n    .map(\n      (b) =>\n        `${b.blockId}\\x1f${b.prodCtx ?? \"\"}\\x1f${b.stagingCtx ?? \"\"}\\x1f${\n          b.prodIncomplete ? 1 : 0\n        }\\x1f${b.stagingIncomplete ? 1 : 0}`,\n    )\n    .join(\"\\x1e\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,gBACd,QACA;CACA,IAAI,MAAM,MAAM,KAAK,MAAM,QAAQ,MAAM,GACvC,OAAO,0BAA0B,MAAM;MAClC,IAAI,kBAAkB,kBAC3B,OAAO,wBAAwB,MAAM;MAErC,MAAM,IAAI,MAAM,iCAAiC;AAErD;;;;;;AAOA,MAAM,yBAAyB,IAAI,SAAsD,EACvF,KAAK,GACP,CAAC;AACD,SAAgB,wBAAwB,MAAiD;CACvF,IAAI,WAAW,uBAAuB,IAAI,KAAK,MAAM;CACrD,IAAI,aAAa,KAAA,GAAW;EAC1B,WAAW,IAAI,4BAA4B,IAAI;EAC/C,uBAAuB,IAAI,KAAK,QAAQ,QAAQ;CAClD;CACA,OAAO;AACT;;;;;;AAOA,MAAM,2BAA2B,IAAI,SAAgD,EAAE,KAAK,EAAE,CAAC;AAC/F,SAAgB,0BACd,UAEI,gBAAgB,CAAC,CAAC,oBAAoB,GACf;CAC3B,MAAM,MAAM,YAAY,OAAO;CAC/B,IAAI,WAAW,yBAAyB,IAAI,GAAG;CAC/C,IAAI,aAAa,KAAA,GAAW;EAC1B,WAAW,IAAI,8BAA8B,OAAO;EACpD,yBAAyB,IAAI,KAAK,QAAQ;CAC5C;CACA,OAAO;AACT;;;;;;AAOA,IAAa,uBAAb,MAA6D;CAKxC;CAJnB;CAEA,YACE,SACA,UACA;EADiB,KAAA,WAAA;EAEjB,KAAK,UAAU,QAAQ,KAAK,MAAM,WAAW,WAAW,CAAC,CAAC;CAC5D;CAEA,aAA4C;EAC1C,OAAO,KAAK;CACd;CAEA,UAAmB;EACjB,OAAO,KAAK;CACd;AACF;;;;;;;AAQA,IAAa,8BAAb,cACU,wBAEV;CACE;CAEA,YAAY,MAAwB;EAClC,MAAM,MAAM,KAAK,WAAW;CAC9B;CAEA,aAA4C;EAC1C,IAAI,KAAK,kBAAkB,KAAA,GAAW,OAAO,KAAK;EAClD,OAAQ,KAAK,gBAAgB,MAAM,KAAK,KAAK,QAAQ,OAAO,CAAC,CAAC,CAC3D,KAAK,MAAM,WAAW,aAAa,CAAC,CAAC,CAAC,CACtC,QAAQ,MAAwC,CAAC,MAAM,CAAC,CAAC;CAC9D;AACF;;;;;;AAUA,IAAa,gCAAb,cACU,0BAEV;CACE;CAEA,YACE,UAEI,gBAAgB,CAAC,CAAC,oBAAoB,GAC1C;EACA,MAAM,SAAS,QAAQ,KAAK,OAAO;GACjC,SAAS,EAAE;GACX,SACE,EAAE,YAAY,KAAA,IACV,IAAI,iBAAiB,EAAE,SAAS,CAAC,EAAE,SAAS,SAAS,CAAC,IACtD,KAAA;GACN,YACE,EAAE,eAAe,KAAA,IACb,IAAI,iBAAiB,EAAE,YAAY,CAAC,EAAE,SAAS,YAAY,CAAC,IAC5D,KAAA;GACN,gBAAgB,EAAE;GAClB,mBAAmB,EAAE;EACvB,EAAE;EAEF,MAAM,MAAM;CACd;CAEA,aAA4C;EAC1C,IAAI,KAAK,kBAAkB,KAAA,GAAW,OAAO,KAAK;EAClD,OAAQ,KAAK,gBAAgB,MAAM,KAAK,KAAK,kBAAkB,CAAC,CAAC,OAAO,CAAC,CAAC,CACvE,KAAK,MAAM,WAAW,aAAa,CAAC,CAAC,CAAC,CACtC,QAAQ,MAAwC,CAAC,MAAM,CAAC,CAAC;CAC9D;AACF;AAKA,SAAS,YAAY,SAAkE;CACrF,OAAO,QACJ,KACE,MACC,GAAG,EAAE,QAAQ,MAAM,EAAE,WAAW,GAAG,MAAM,EAAE,cAAc,GAAG,MAC1D,EAAE,iBAAiB,IAAI,EACxB,MAAM,EAAE,oBAAoB,IAAI,GACrC,CAAC,CACA,KAAK,GAAM;AAChB"}

package/dist/columns/column_providers/types.d.ts

@@ -1,6 +1,6 @@
 import { PColumnDataUniversal } from "../../render/internal.js";
 import { TreeNodeAccessor } from "../../render/accessor.js";
-import { ColumnLazy } from "../column_lazy.js";
+import { DataColumnRecipe } from "../data_column.js";
 import { ColumnRecipe } from "../column_recipes/index.js";
 import { ColumnsProvider } from "./providers.js";
 import { PColumn } from "@milaboratories/pl-model-common";
@@ -11,11 +11,11 @@ import { PColumn } from "@milaboratories/pl-model-common";
  * Includes TreeNodeAccessor, ColumnsProvider, and arrays of columns.
  *
  * The array form accepts plain {@link PColumn}s (materialized snapshots),
- * {@link ColumnLazy} leaves, or any {@link ColumnRecipe} — builders only
+ * {@link DataColumnRecipe} leaves, or any {@link ColumnRecipe} — builders only
  * need each entry's `id` for serialization.
  */
 type ColumnsSource = ColumnsProvider | TreeNodeAccessor | {
-  readonly columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | ColumnLazy | ColumnRecipe>;
+  readonly columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | DataColumnRecipe | ColumnRecipe>;
   readonly isFinal: boolean;
 };
 //#endregion

package/dist/columns/column_providers/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/columns/column_providers/types.ts"],"mappings":";;;;;;;;;;;AAeA;;;;;KAAY,aAAA,GACR,eAAA,GACA,gBAAA;EAAA,SAEW,OAAA,EAAS,aAAA,CAChB,OAAA,aAAoB,oBAAA,IAAwB,UAAA,GAAa,YAAA;EAAA,SAElD,OAAA;AAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/columns/column_providers/types.ts"],"mappings":";;;;;;;;;;;AAeA;;;;;KAAY,aAAA,GACR,eAAA,GACA,gBAAA;EAAA,SAEW,OAAA,EAAS,aAAA,CAChB,OAAA,aAAoB,oBAAA,IAAwB,gBAAA,GAAmB,YAAA;EAAA,SAExD,OAAA;AAAA"}

package/dist/columns/column_recipes/column_discovered_recipe.cjs

@@ -25,7 +25,7 @@ var ColumnDiscoveredRecipe = class ColumnDiscoveredRecipe {
 	columns;
 	/**
 	* Validate the key + resolve every referenced column via
-	* {@link ColumnLazy.fromId} (which itself checks the leaf accessor reports
+	* {@link DataColumnRecipe.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.
 	*

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

@@ -1 +1 @@
-{"version":3,"file":"column_discovered_recipe.cjs","names":["Column","ColumnRecipe","ColumnOverriddenRecipe","rebrandLeafId"],"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":"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"}
+{"version":3,"file":"column_discovered_recipe.cjs","names":["Column","ColumnRecipe","ColumnOverriddenRecipe","rebrandLeafId"],"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 DataColumnRecipe.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":"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"}

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

@@ -24,7 +24,7 @@ declare class ColumnDiscoveredRecipe implements ColumnRecipe<ColumnDiscoveredId>
   private readonly columns;
   /**
    * Validate the key + resolve every referenced column via
-   * {@link ColumnLazy.fromId} (which itself checks the leaf accessor reports
+   * {@link DataColumnRecipe.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.
    *

package/dist/columns/column_recipes/column_discovered_recipe.js

@@ -25,7 +25,7 @@ var ColumnDiscoveredRecipe = class ColumnDiscoveredRecipe {
 	columns;
 	/**
 	* Validate the key + resolve every referenced column via
-	* {@link ColumnLazy.fromId} (which itself checks the leaf accessor reports
+	* {@link DataColumnRecipe.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.
 	*