@platforma-sdk/model 1.79.27 → 1.80.0

package/dist/block_model.d.ts

@@ -37,6 +37,7 @@ declare class BlockModelV3<Args, OutputsCfg extends Record<string, ConfigRenderL
     requiresPFrameSpec: true;
     requiresPFrame: true;
     requiresDialog: true;
+    requiresColumnsCollection: true;
     supportsLazyState: true;
     supportsPframeQueryRanking: true;
     requiresUIAPIVersion: number;
@@ -49,6 +50,7 @@ declare class BlockModelV3<Args, OutputsCfg extends Record<string, ConfigRenderL
     requiresPFrameSpec: true;
     requiresPFrame: true;
     requiresDialog: true;
+    requiresColumnsCollection: true;
     supportsLazyState: true;
     supportsPframeQueryRanking: true;
     requiresUIAPIVersion: number;

package/dist/block_model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_model.d.ts","names":[],"sources":["../src/block_model.ts"],"mappings":"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"}
+{"version":3,"file":"block_model.d.ts","names":[],"sources":["../src/block_model.ts"],"mappings":"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"}

package/dist/columns/column.cjs

@@ -0,0 +1,28 @@
+const require_index = require("./column_recipes/index.cjs");
+const require_column_lazy = require("./column_lazy.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}
+*
+* `ColumnLazy` 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);
+}
+/**
+* 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.
+*/
+function isColumn(value) {
+	return require_index.isColumnRecipe(value);
+}
+//#endregion
+exports.Column = Column;
+exports.isColumn = isColumn;
+
+//# sourceMappingURL=column.cjs.map

package/dist/columns/column.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"column.cjs","names":["ColumnRecipe","ColumnLazy","isColumnRecipe"],"sources":["../../src/columns/column.ts"],"sourcesContent":["import type {\n  ColumnUniversalId,\n  LeafEntry,\n  PColumn,\n  PlRef,\n  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"}

package/dist/columns/column.d.ts

@@ -0,0 +1,30 @@
+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 { 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;
+/**
+ * Unified entry point — routes between the two top-level dispatchers:
+ *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}
+ *   - object source (`PlRef` / `LeafEntry` / `PColumn` / `ColumnLazy`) → {@link ColumnLazy}
+ *
+ * `ColumnLazy` is itself a `ColumnRecipe<PObjectId>`, so the return type is
+ * the common `ColumnRecipe`.
+ */
+declare function Column(source: ColumnSource, opts?: {
+  ctx?: GlobalCfgRenderCtx;
+}): undefined | ColumnRecipe;
+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.
+ */
+declare function isColumn(value: unknown): value is Column;
+//#endregion
+export { Column, ColumnSource, isColumn };
+//# sourceMappingURL=column.d.ts.map

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

@@ -0,0 +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"}

package/dist/columns/column.js

@@ -0,0 +1,27 @@
+import { ColumnRecipe, isColumnRecipe } from "./column_recipes/index.js";
+import { ColumnLazy } from "./column_lazy.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}
+*
+* `ColumnLazy` 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);
+}
+/**
+* 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.
+*/
+function isColumn(value) {
+	return isColumnRecipe(value);
+}
+//#endregion
+export { Column, isColumn };
+
+//# sourceMappingURL=column.js.map

package/dist/columns/column.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column.js","names":[],"sources":["../../src/columns/column.ts"],"sourcesContent":["import type {\n  ColumnUniversalId,\n  LeafEntry,\n  PColumn,\n  PlRef,\n  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"}

package/dist/columns/column_lazy.cjs

@@ -0,0 +1,248 @@
+const require_column_overrided_recipe = require("./column_recipes/column_overrided_recipe.cjs");
+const require_index = require("./column_providers/index.cjs");
+let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
+let es_toolkit = require("es-toolkit");
+let lru_cache = require("lru-cache");
+//#region src/columns/column_lazy.ts
+/**
+* Thrown by leaf-recipe factories when the requested column is provably
+* absent in the active render ctx — i.e. every relevant accessor reports
+* `inputsLocked` and the column did not appear. Distinct from the
+* `undefined` return that the factories still use for the "resolving" case
+* (the column may still appear later).
+*
+* Catch at the boundary (resolver / filter+sort wiring / data-table assembly)
+* when partial absence should be surfaced to the user rather than silently
+* producing an empty result.
+*/
+var ColumnAbsentError = class extends Error {
+	id;
+	constructor(id) {
+		super(`Column is absent in the active render ctx and will not appear: ${id}`);
+		this.id = id;
+		this.name = "ColumnAbsentError";
+	}
+};
+/**
+* ColumnLazy is the leaf-recipe building block: a {@link ColumnRecipe} whose
+* `id` is a bare {@link PObjectId} and whose readers are bound to a single
+* tree-accessor leaf. Layered encodings (Overridden / Discovered / Filtered)
+* are reified through their dedicated recipe classes and reference leaf
+* columns by id.
+*/
+var ColumnLazyImpl = class ColumnLazyImpl {
+	id;
+	options;
+	specCache;
+	dataCache;
+	dataStatusCache;
+	constructor(id, options) {
+		this.id = id;
+		this.options = options;
+	}
+	/** A leaf-recipe references exactly one column — its own id. */
+	getReferencedIds() {
+		return [this.id];
+	}
+	getSpec() {
+		if (this.specCache === void 0) this.specCache = { value: this.options.getSpec() };
+		return this.specCache.value;
+	}
+	/** Leaf-shaped — points straight at `this.id`. */
+	getQuery() {
+		return {
+			type: "column",
+			column: this.id
+		};
+	}
+	/** Leaf-only: not on the recipe interface — only the leaf can read data directly. */
+	getData() {
+		if (this.dataCache === void 0) this.dataCache = { value: this.options.getData() };
+		return this.dataCache.value;
+	}
+	getDataStatus() {
+		if (this.dataStatusCache === void 0) this.dataStatusCache = { value: this.options.getDataStatus() };
+		return this.dataStatusCache.value;
+	}
+	/**
+	* Overlay overrides → produces a {@link ColumnOverriddenRecipe} wrapping
+	* this leaf. ColumnLazy itself stays bare (id remains a plain PObjectId);
+	* layering lives entirely in the recipe wrappers.
+	*/
+	withSpecs(overrides) {
+		return require_column_overrided_recipe.ColumnOverriddenRecipe.wrap(this, overrides);
+	}
+	/**
+	* Resolve via the ambient {@link ColumnRegistry}. Spec is resolved eagerly:
+	* returns `undefined` if the leaf isn't reachable yet (resolving). Throws
+	* {@link ColumnAbsentError} when every relevant accessor is `inputsLocked`
+	* and the column did not appear — the column will not exist in this ctx.
+	* Data and dataStatus stay lazy.
+	*/
+	static fromId(id, { ctx } = {}) {
+		const registry = new _milaboratories_pl_model_common.ColumnRegistry(require_index.getCtxProviders({ ctx }));
+		const leaf = registry.resolve(id);
+		if ((0, es_toolkit.isNil)(leaf)) {
+			if (registry.isFinal()) throw new ColumnAbsentError(id);
+			return;
+		}
+		const spec = readSpecAccessor(leaf);
+		if ((0, es_toolkit.isNil)(spec)) {
+			if (leaf.accessor.getInputsLocked()) throw new ColumnAbsentError(id);
+			return;
+		}
+		if (!spec.hasData()) return void 0;
+		return new ColumnLazyImpl(id, {
+			getSpec: () => spec.getDataAsJson(),
+			getData: () => readDataAccessor(leaf),
+			getDataStatus: () => readDataStatus(leaf)
+		});
+	}
+	/** {@link PlRef} wrapper over {@link fromId}. */
+	static fromPlRef(ref) {
+		return ColumnLazyImpl.fromId((0, _milaboratories_pl_model_common.createGlobalPObjectId)(ref.blockId, ref.name));
+	}
+	/**
+	* Bind directly to an accessor-backed {@link LeafEntry} — no registry.
+	* Throws {@link ColumnAbsentError} if the leaf has no spec field and its
+	* accessor is `inputsLocked`. Returns `undefined` while still resolving.
+	*/
+	static fromAccessor(entry) {
+		const spec = readSpecAccessor(entry);
+		if ((0, es_toolkit.isNil)(spec)) {
+			if (entry.accessor.getInputsLocked()) throw new ColumnAbsentError(entry.id);
+			return;
+		}
+		if (!spec.hasData()) return void 0;
+		return new ColumnLazyImpl(entry.id, {
+			getSpec: () => spec.getDataAsJson(),
+			getData: () => readDataAccessor(entry),
+			getDataStatus: () => readDataStatus(entry)
+		});
+	}
+	/**
+	* Wrap a materialised {@link PColumn}. If the input is already a
+	* {@link ColumnLazy} it is returned as-is.
+	*/
+	static fromColumn(column) {
+		if (column instanceof ColumnLazyImpl) return column;
+		return new ColumnLazyImpl(column.id, {
+			getSpec: () => column.spec,
+			getData: () => column.data,
+			getDataStatus: () => "present"
+		});
+	}
+	/**
+	* Distinguishes `present` / `resolving` / `absent` for a {@link PObjectId}
+	* in the active render ctx. Falls back to the registry's `isFinal()`
+	* when the id has no entry — only then we can say `absent` instead of
+	* `resolving`.
+	*/
+	static getStatusById(id, { ctx } = {}) {
+		const registry = new _milaboratories_pl_model_common.ColumnRegistry(require_index.getCtxProviders({ ctx }));
+		const leaf = registry.resolve(id);
+		if ((0, es_toolkit.isNil)(leaf)) return registry.isFinal() ? "absent" : "resolving";
+		return getLeafEntryStatus(leaf);
+	}
+	/** {@link PlRef} wrapper over {@link getStatusById}. */
+	static getStatusByPlRef(ref, opts = {}) {
+		return ColumnLazyImpl.getStatusById((0, _milaboratories_pl_model_common.createGlobalPObjectId)(ref.blockId, ref.name), opts);
+	}
+	/** No registry — reads straight off the entry's accessor. */
+	static getStatusByAccessor(entry) {
+		return getLeafEntryStatus(entry);
+	}
+};
+/**
+* Unified dispatcher — picks the right `ColumnLazyImpl.fromX` by source
+* shape. For ambiguous inputs callers can still use the explicit factories
+* (also attached as properties: `ColumnLazy.fromId`, `.fromPlRef`,
+* `.fromAccessor`, `.fromColumn`).
+*/
+function ColumnLazyDispatch(source, opts = {}) {
+	if (typeof source === "string") return ColumnLazyImpl.fromId(source, opts);
+	if (source instanceof ColumnLazyImpl) return source;
+	if ("accessor" in source) return ColumnLazyImpl.fromAccessor(source);
+	if ((0, _milaboratories_pl_model_common.isPlRef)(source)) return ColumnLazyImpl.fromPlRef(source);
+	if ((0, _milaboratories_pl_model_common.isPColumn)(source)) return ColumnLazyImpl.fromColumn(source);
+	throw new Error("ColumnLazy: unknown source shape");
+}
+/**
+* Polymorphic counterpart to {@link ColumnLazyDispatch}: returns the
+* {@link ColumnResolutionStatus} for any factory input without constructing
+* the recipe. For already-materialised sources ({@link PColumn} value,
+* existing {@link ColumnLazy}) status is `present` by construction.
+*/
+function ColumnLazyGetStatus(source, opts = {}) {
+	if (typeof source === "string") return ColumnLazyImpl.getStatusById(source, opts);
+	if (source instanceof ColumnLazyImpl) return "present";
+	if ("accessor" in source) return ColumnLazyImpl.getStatusByAccessor(source);
+	if ((0, _milaboratories_pl_model_common.isPlRef)(source)) return ColumnLazyImpl.getStatusByPlRef(source, opts);
+	if ((0, _milaboratories_pl_model_common.isPColumn)(source)) return "present";
+	throw new Error("ColumnLazy.getStatus: unknown source shape");
+}
+const ColumnLazy = Object.assign(ColumnLazyDispatch, {
+	fromId: ColumnLazyImpl.fromId,
+	fromPlRef: ColumnLazyImpl.fromPlRef,
+	fromAccessor: ColumnLazyImpl.fromAccessor,
+	fromColumn: ColumnLazyImpl.fromColumn,
+	getStatus: ColumnLazyGetStatus,
+	getStatusById: ColumnLazyImpl.getStatusById,
+	getStatusByPlRef: ColumnLazyImpl.getStatusByPlRef,
+	getStatusByAccessor: ColumnLazyImpl.getStatusByAccessor
+});
+/**
+* Type-guard narrowing to the leaf recipe. Prefer this over
+* `instanceof ColumnLazyImpl` — `ColumnLazy` (the value) is the dispatcher
+* with statics, not the class, so `instanceof` requires the impl symbol.
+*/
+function isColumnLazy(value) {
+	return value instanceof ColumnLazyImpl;
+}
+const readSpecAccessor = memoizeByEntry(({ accessor, name }) => accessor.traverse({
+	field: `${name}.spec`,
+	assertFieldType: "Input",
+	ignoreError: true
+}));
+/**
+* Per-entry counterpart to {@link readDataStatus}: tells whether the leaf's
+* **spec** can be read in this ctx, and — for the negative cases —
+* distinguishes `resolving` from `absent` via `getInputsLocked()`.
+*
+*  - spec field not yet on the entry's accessor + inputs locked → `absent`
+*  - spec field not yet on the entry's accessor + still resolving → `resolving`
+*  - spec resource present but bytes not yet written → `resolving`
+*    (transient — the spec resource is connected, just unfilled)
+*  - spec resource present and `hasData()` → `present`
+*/
+function getLeafEntryStatus(entry) {
+	const spec = readSpecAccessor(entry);
+	if ((0, es_toolkit.isNil)(spec)) return entry.accessor.getInputsLocked() ? "absent" : "resolving";
+	if (!spec.hasData()) return "resolving";
+	return "present";
+}
+const readDataAccessor = memoizeByEntry(({ accessor, name }) => accessor.traverse({
+	field: `${name}.data`,
+	assertFieldType: "Input",
+	ignoreError: true
+}));
+const readDataStatus = memoizeByEntry(({ accessor, name }) => {
+	if (accessor.listInputFields().includes(`${name}.data`)) return "present";
+	return accessor.getInputsLocked() ? "absent" : "resolving";
+});
+function memoizeByEntry(fn) {
+	const cache = new lru_cache.LRUCache({ max: 1e3 });
+	return (entry) => {
+		const key = `${entry.accessor.handle}:${entry.name}`;
+		let hit = cache.get(key);
+		if (!hit) cache.set(key, hit = { value: fn(entry) });
+		return hit.value;
+	};
+}
+//#endregion
+exports.ColumnAbsentError = ColumnAbsentError;
+exports.ColumnLazy = ColumnLazy;
+exports.ColumnLazyImpl = ColumnLazyImpl;
+exports.isColumnLazy = isColumnLazy;
+
+//# sourceMappingURL=column_lazy.cjs.map

package/dist/columns/column_lazy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"column_lazy.cjs","names":["ColumnOverriddenRecipe","ColumnRegistry","getCtxProviders","LRUCache"],"sources":["../../src/columns/column_lazy.ts"],"sourcesContent":["import {\n  ColumnRegistry,\n  createGlobalPObjectId,\n  isPColumn,\n  isPlRef,\n  PlRef,\n  PObjectId,\n  type ColumnUniversalId,\n  type LeafEntry,\n  type PColumn,\n  type PColumnSpec,\n  type SpecOverrides,\n  type SpecQuery,\n} from \"@milaboratories/pl-model-common\";\nimport type { GlobalCfgRenderCtx, PColumnDataUniversal } from \"../render/internal\";\nimport { getCtxProviders } from \"./column_providers\";\nimport { isNil } from \"es-toolkit\";\nimport { LRUCache } from \"lru-cache\";\nimport { TreeNodeAccessor } from \"../render\";\nimport type {\n  ColumnFieldStatus,\n  ColumnRecipe,\n  ColumnResolutionStatus,\n} from \"./column_recipes/types\";\nimport { ColumnOverriddenRecipe } from \"./column_recipes/column_overrided_recipe\";\n\nexport type ColumnLazyId = PObjectId;\nexport type ColumnLazyData = undefined | PColumnDataUniversal;\nexport type { ColumnFieldStatus, ColumnResolutionStatus } from \"./column_recipes/types\";\n\n/**\n * Thrown by leaf-recipe factories when the requested column is provably\n * absent in the active render ctx — i.e. every relevant accessor reports\n * `inputsLocked` and the column did not appear. Distinct from the\n * `undefined` return that the factories still use for the \"resolving\" case\n * (the column may still appear later).\n *\n * Catch at the boundary (resolver / filter+sort wiring / data-table assembly)\n * when partial absence should be surfaced to the user rather than silently\n * producing an empty result.\n */\nexport class ColumnAbsentError extends Error {\n  constructor(public readonly id: ColumnUniversalId) {\n    super(`Column is absent in the active render ctx and will not appear: ${id}`);\n    this.name = \"ColumnAbsentError\";\n  }\n}\n\n/**\n * ColumnLazy is the leaf-recipe building block: a {@link ColumnRecipe} whose\n * `id` is a bare {@link PObjectId} and whose readers are bound to a single\n * tree-accessor leaf. Layered encodings (Overridden / Discovered / Filtered)\n * are reified through their dedicated recipe classes and reference leaf\n * columns by id.\n */\nexport class ColumnLazyImpl implements ColumnRecipe<PObjectId> {\n  private specCache?: { readonly value: PColumnSpec };\n  private dataCache?: { readonly value: ColumnLazyData };\n  private dataStatusCache?: { readonly value: ColumnFieldStatus };\n\n  private constructor(\n    public readonly id: PObjectId,\n    private readonly options: {\n      getSpec: () => PColumnSpec;\n      getData: () => ColumnLazyData;\n      getDataStatus: () => ColumnFieldStatus;\n    },\n  ) {}\n\n  /** A leaf-recipe references exactly one column — its own id. */\n  getReferencedIds(): PObjectId[] {\n    return [this.id];\n  }\n\n  getSpec(): PColumnSpec {\n    if (this.specCache === undefined) {\n      this.specCache = { value: this.options.getSpec() };\n    }\n    return this.specCache.value;\n  }\n\n  /** Leaf-shaped — points straight at `this.id`. */\n  getQuery(): SpecQuery {\n    return { type: \"column\", column: this.id } as SpecQuery;\n  }\n\n  /** Leaf-only: not on the recipe interface — only the leaf can read data directly. */\n  getData(): ColumnLazyData {\n    if (this.dataCache === undefined) this.dataCache = { value: this.options.getData() };\n    return this.dataCache.value;\n  }\n\n  getDataStatus(): ColumnFieldStatus {\n    if (this.dataStatusCache === undefined) {\n      this.dataStatusCache = { value: this.options.getDataStatus() };\n    }\n    return this.dataStatusCache.value;\n  }\n\n  /**\n   * Overlay overrides → produces a {@link ColumnOverriddenRecipe} wrapping\n   * this leaf. ColumnLazy itself stays bare (id remains a plain PObjectId);\n   * layering lives entirely in the recipe wrappers.\n   */\n  withSpecs(overrides: SpecOverrides): ColumnRecipe {\n    return ColumnOverriddenRecipe.wrap(this, overrides);\n  }\n\n  /**\n   * Resolve via the ambient {@link ColumnRegistry}. Spec is resolved eagerly:\n   * returns `undefined` if the leaf isn't reachable yet (resolving). Throws\n   * {@link ColumnAbsentError} when every relevant accessor is `inputsLocked`\n   * and the column did not appear — the column will not exist in this ctx.\n   * Data and dataStatus stay lazy.\n   */\n  static fromId(id: PObjectId, { ctx }: { ctx?: GlobalCfgRenderCtx } = {}): undefined | ColumnLazy {\n    const registry = new ColumnRegistry(getCtxProviders({ ctx }));\n    const leaf = registry.resolve(id);\n    if (isNil(leaf)) {\n      if (registry.isFinal()) throw new ColumnAbsentError(id);\n      return undefined;\n    }\n    const spec = readSpecAccessor(leaf);\n    if (isNil(spec)) {\n      if (leaf.accessor.getInputsLocked()) throw new ColumnAbsentError(id);\n      return undefined;\n    }\n    if (!spec.hasData()) return undefined;\n    return new ColumnLazyImpl(id, {\n      getSpec: () => spec.getDataAsJson<PColumnSpec>(),\n      getData: () => readDataAccessor(leaf),\n      getDataStatus: () => readDataStatus(leaf),\n    });\n  }\n\n  /** {@link PlRef} wrapper over {@link fromId}. */\n  static fromPlRef(ref: PlRef): undefined | ColumnLazy {\n    return ColumnLazyImpl.fromId(createGlobalPObjectId(ref.blockId, ref.name));\n  }\n\n  /**\n   * Bind directly to an accessor-backed {@link LeafEntry} — no registry.\n   * Throws {@link ColumnAbsentError} if the leaf has no spec field and its\n   * accessor is `inputsLocked`. Returns `undefined` while still resolving.\n   */\n  static fromAccessor(entry: LeafEntry<TreeNodeAccessor>): undefined | ColumnLazy {\n    const spec = readSpecAccessor(entry);\n    if (isNil(spec)) {\n      if (entry.accessor.getInputsLocked()) throw new ColumnAbsentError(entry.id);\n      return undefined;\n    }\n    if (!spec.hasData()) return undefined;\n    return new ColumnLazyImpl(entry.id, {\n      getSpec: () => spec.getDataAsJson<PColumnSpec>(),\n      getData: () => readDataAccessor(entry),\n      getDataStatus: () => readDataStatus(entry),\n    });\n  }\n\n  /**\n   * Wrap a materialised {@link PColumn}. If the input is already a\n   * {@link ColumnLazy} it is returned as-is.\n   */\n  static fromColumn(column: PColumn<ColumnLazyData> | ColumnLazy): ColumnLazy {\n    if (column instanceof ColumnLazyImpl) return column;\n    return new ColumnLazyImpl(column.id, {\n      getSpec: () => column.spec,\n      getData: () => column.data,\n      getDataStatus: () => \"present\",\n    });\n  }\n\n  /**\n   * Distinguishes `present` / `resolving` / `absent` for a {@link PObjectId}\n   * in the active render ctx. Falls back to the registry's `isFinal()`\n   * when the id has no entry — only then we can say `absent` instead of\n   * `resolving`.\n   */\n  static getStatusById(\n    id: PObjectId,\n    { ctx }: { ctx?: GlobalCfgRenderCtx } = {},\n  ): ColumnResolutionStatus {\n    const registry = new ColumnRegistry(getCtxProviders({ ctx }));\n    const leaf = registry.resolve(id);\n    if (isNil(leaf)) return registry.isFinal() ? \"absent\" : \"resolving\";\n    return getLeafEntryStatus(leaf);\n  }\n\n  /** {@link PlRef} wrapper over {@link getStatusById}. */\n  static getStatusByPlRef(\n    ref: PlRef,\n    opts: { ctx?: GlobalCfgRenderCtx } = {},\n  ): ColumnResolutionStatus {\n    return ColumnLazyImpl.getStatusById(createGlobalPObjectId(ref.blockId, ref.name), opts);\n  }\n\n  /** No registry — reads straight off the entry's accessor. */\n  static getStatusByAccessor(entry: LeafEntry<TreeNodeAccessor>): ColumnResolutionStatus {\n    return getLeafEntryStatus(entry);\n  }\n}\n\n/**\n * Public type alias — `ColumnLazy` (the type) refers to the underlying\n * {@link ColumnLazyImpl} class instance. `ColumnLazy` (the value) is the\n * callable below with the static factories attached.\n */\nexport type ColumnLazy = ColumnLazyImpl;\n\n/**\n * Unified dispatcher — picks the right `ColumnLazyImpl.fromX` by source\n * shape. For ambiguous inputs callers can still use the explicit factories\n * (also attached as properties: `ColumnLazy.fromId`, `.fromPlRef`,\n * `.fromAccessor`, `.fromColumn`).\n */\nfunction ColumnLazyDispatch(\n  source: PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnLazyData> | ColumnLazy,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): undefined | ColumnLazy {\n  if (typeof source === \"string\") return ColumnLazyImpl.fromId(source, opts);\n  if (source instanceof ColumnLazyImpl) return source;\n  if (\"accessor\" in source) return ColumnLazyImpl.fromAccessor(source);\n  if (isPlRef(source)) return ColumnLazyImpl.fromPlRef(source);\n  if (isPColumn(source)) return ColumnLazyImpl.fromColumn(source);\n  throw new Error(\"ColumnLazy: unknown source shape\");\n}\n\n/**\n * Polymorphic counterpart to {@link ColumnLazyDispatch}: returns the\n * {@link ColumnResolutionStatus} for any factory input without constructing\n * the recipe. For already-materialised sources ({@link PColumn} value,\n * existing {@link ColumnLazy}) status is `present` by construction.\n */\nfunction ColumnLazyGetStatus(\n  source: PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnLazyData> | ColumnLazy,\n  opts: { ctx?: GlobalCfgRenderCtx } = {},\n): ColumnResolutionStatus {\n  if (typeof source === \"string\") return ColumnLazyImpl.getStatusById(source, opts);\n  if (source instanceof ColumnLazyImpl) return \"present\";\n  if (\"accessor\" in source) return ColumnLazyImpl.getStatusByAccessor(source);\n  if (isPlRef(source)) return ColumnLazyImpl.getStatusByPlRef(source, opts);\n  if (isPColumn(source)) return \"present\";\n  throw new Error(\"ColumnLazy.getStatus: unknown source shape\");\n}\n\nexport const ColumnLazy = Object.assign(ColumnLazyDispatch, {\n  fromId: ColumnLazyImpl.fromId,\n  fromPlRef: ColumnLazyImpl.fromPlRef,\n  fromAccessor: ColumnLazyImpl.fromAccessor,\n  fromColumn: ColumnLazyImpl.fromColumn,\n  getStatus: ColumnLazyGetStatus,\n  getStatusById: ColumnLazyImpl.getStatusById,\n  getStatusByPlRef: ColumnLazyImpl.getStatusByPlRef,\n  getStatusByAccessor: ColumnLazyImpl.getStatusByAccessor,\n});\n\n/**\n * Type-guard narrowing to the leaf recipe. Prefer this over\n * `instanceof ColumnLazyImpl` — `ColumnLazy` (the value) is the dispatcher\n * with statics, not the class, so `instanceof` requires the impl symbol.\n */\nexport function isColumnLazy(value: unknown): value is ColumnLazy {\n  return value instanceof ColumnLazyImpl;\n}\n\nconst readSpecAccessor = memoizeByEntry(\n  ({ accessor, name }: LeafEntry<TreeNodeAccessor>): undefined | TreeNodeAccessor =>\n    accessor.traverse({ field: `${name}.spec`, assertFieldType: \"Input\", ignoreError: true }),\n);\n\n/**\n * Per-entry counterpart to {@link readDataStatus}: tells whether the leaf's\n * **spec** can be read in this ctx, and — for the negative cases —\n * distinguishes `resolving` from `absent` via `getInputsLocked()`.\n *\n *  - spec field not yet on the entry's accessor + inputs locked → `absent`\n *  - spec field not yet on the entry's accessor + still resolving → `resolving`\n *  - spec resource present but bytes not yet written → `resolving`\n *    (transient — the spec resource is connected, just unfilled)\n *  - spec resource present and `hasData()` → `present`\n */\nfunction getLeafEntryStatus(entry: LeafEntry<TreeNodeAccessor>): ColumnResolutionStatus {\n  const spec = readSpecAccessor(entry);\n  if (isNil(spec)) return entry.accessor.getInputsLocked() ? \"absent\" : \"resolving\";\n  if (!spec.hasData()) return \"resolving\";\n  return \"present\";\n}\n\nconst readDataAccessor = memoizeByEntry(\n  ({ accessor, name }: LeafEntry<TreeNodeAccessor>): undefined | TreeNodeAccessor =>\n    accessor.traverse({ field: `${name}.data`, assertFieldType: \"Input\", ignoreError: true }),\n);\n\nconst readDataStatus = memoizeByEntry(\n  ({ accessor, name }: LeafEntry<TreeNodeAccessor>): ColumnFieldStatus => {\n    if (accessor.listInputFields().includes(`${name}.data`)) return \"present\";\n    return accessor.getInputsLocked() ? \"absent\" : \"resolving\";\n  },\n);\n\nfunction memoizeByEntry<R>(\n  fn: (entry: LeafEntry<TreeNodeAccessor>) => R,\n): (entry: LeafEntry<TreeNodeAccessor>) => R {\n  const cache = new LRUCache<string, { value: R }>({ max: 1000 });\n  return (entry) => {\n    const key = `${entry.accessor.handle}:${entry.name}`;\n    let hit = cache.get(key);\n    if (!hit) cache.set(key, (hit = { value: fn(entry) }));\n    return hit.value;\n  };\n}\n"],"mappings":"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"}

package/dist/columns/column_lazy.d.ts

@@ -0,0 +1,137 @@
+import { GlobalCfgRenderCtx, PColumnDataUniversal } from "../render/internal.js";
+import { TreeNodeAccessor } from "../render/accessor.js";
+import { ColumnFieldStatus, ColumnRecipe, ColumnResolutionStatus } from "./column_recipes/types.js";
+import { ColumnUniversalId, LeafEntry, PColumn, PColumnSpec, PObjectId, PlRef, SpecOverrides, SpecQuery } from "@milaboratories/pl-model-common";
+
+//#region src/columns/column_lazy.d.ts
+type ColumnLazyId = PObjectId;
+type ColumnLazyData = undefined | PColumnDataUniversal;
+/**
+ * Thrown by leaf-recipe factories when the requested column is provably
+ * absent in the active render ctx — i.e. every relevant accessor reports
+ * `inputsLocked` and the column did not appear. Distinct from the
+ * `undefined` return that the factories still use for the "resolving" case
+ * (the column may still appear later).
+ *
+ * Catch at the boundary (resolver / filter+sort wiring / data-table assembly)
+ * when partial absence should be surfaced to the user rather than silently
+ * producing an empty result.
+ */
+declare class ColumnAbsentError extends Error {
+  readonly id: ColumnUniversalId;
+  constructor(id: ColumnUniversalId);
+}
+/**
+ * ColumnLazy is the leaf-recipe building block: a {@link ColumnRecipe} whose
+ * `id` is a bare {@link PObjectId} and whose readers are bound to a single
+ * tree-accessor leaf. Layered encodings (Overridden / Discovered / Filtered)
+ * are reified through their dedicated recipe classes and reference leaf
+ * columns by id.
+ */
+declare class ColumnLazyImpl implements ColumnRecipe<PObjectId> {
+  readonly id: PObjectId;
+  private readonly options;
+  private specCache?;
+  private dataCache?;
+  private dataStatusCache?;
+  private constructor();
+  /** A leaf-recipe references exactly one column — its own id. */
+  getReferencedIds(): PObjectId[];
+  getSpec(): PColumnSpec;
+  /** Leaf-shaped — points straight at `this.id`. */
+  getQuery(): SpecQuery;
+  /** Leaf-only: not on the recipe interface — only the leaf can read data directly. */
+  getData(): ColumnLazyData;
+  getDataStatus(): ColumnFieldStatus;
+  /**
+   * Overlay overrides → produces a {@link ColumnOverriddenRecipe} wrapping
+   * this leaf. ColumnLazy itself stays bare (id remains a plain PObjectId);
+   * layering lives entirely in the recipe wrappers.
+   */
+  withSpecs(overrides: SpecOverrides): ColumnRecipe;
+  /**
+   * Resolve via the ambient {@link ColumnRegistry}. Spec is resolved eagerly:
+   * returns `undefined` if the leaf isn't reachable yet (resolving). Throws
+   * {@link ColumnAbsentError} when every relevant accessor is `inputsLocked`
+   * and the column did not appear — the column will not exist in this ctx.
+   * Data and dataStatus stay lazy.
+   */
+  static fromId(id: PObjectId, {
+    ctx
+  }?: {
+    ctx?: GlobalCfgRenderCtx;
+  }): undefined | ColumnLazy;
+  /** {@link PlRef} wrapper over {@link fromId}. */
+  static fromPlRef(ref: PlRef): undefined | ColumnLazy;
+  /**
+   * Bind directly to an accessor-backed {@link LeafEntry} — no registry.
+   * Throws {@link ColumnAbsentError} if the leaf has no spec field and its
+   * accessor is `inputsLocked`. Returns `undefined` while still resolving.
+   */
+  static fromAccessor(entry: LeafEntry<TreeNodeAccessor>): undefined | ColumnLazy;
+  /**
+   * Wrap a materialised {@link PColumn}. If the input is already a
+   * {@link ColumnLazy} it is returned as-is.
+   */
+  static fromColumn(column: PColumn<ColumnLazyData> | ColumnLazy): ColumnLazy;
+  /**
+   * Distinguishes `present` / `resolving` / `absent` for a {@link PObjectId}
+   * in the active render ctx. Falls back to the registry's `isFinal()`
+   * when the id has no entry — only then we can say `absent` instead of
+   * `resolving`.
+   */
+  static getStatusById(id: PObjectId, {
+    ctx
+  }?: {
+    ctx?: GlobalCfgRenderCtx;
+  }): ColumnResolutionStatus;
+  /** {@link PlRef} wrapper over {@link getStatusById}. */
+  static getStatusByPlRef(ref: PlRef, opts?: {
+    ctx?: GlobalCfgRenderCtx;
+  }): ColumnResolutionStatus;
+  /** No registry — reads straight off the entry's accessor. */
+  static getStatusByAccessor(entry: LeafEntry<TreeNodeAccessor>): ColumnResolutionStatus;
+}
+/**
+ * Public type alias — `ColumnLazy` (the type) refers to the underlying
+ * {@link ColumnLazyImpl} class instance. `ColumnLazy` (the value) is the
+ * callable below with the static factories attached.
+ */
+type ColumnLazy = ColumnLazyImpl;
+/**
+ * Unified dispatcher — picks the right `ColumnLazyImpl.fromX` by source
+ * shape. For ambiguous inputs callers can still use the explicit factories
+ * (also attached as properties: `ColumnLazy.fromId`, `.fromPlRef`,
+ * `.fromAccessor`, `.fromColumn`).
+ */
+declare function ColumnLazyDispatch(source: PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnLazyData> | ColumnLazy, opts?: {
+  ctx?: GlobalCfgRenderCtx;
+}): undefined | ColumnLazy;
+/**
+ * Polymorphic counterpart to {@link ColumnLazyDispatch}: returns the
+ * {@link ColumnResolutionStatus} for any factory input without constructing
+ * the recipe. For already-materialised sources ({@link PColumn} value,
+ * existing {@link ColumnLazy}) status is `present` by construction.
+ */
+declare function ColumnLazyGetStatus(source: PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnLazyData> | ColumnLazy, opts?: {
+  ctx?: GlobalCfgRenderCtx;
+}): ColumnResolutionStatus;
+declare const ColumnLazy: typeof ColumnLazyDispatch & {
+  fromId: typeof ColumnLazyImpl.fromId;
+  fromPlRef: typeof ColumnLazyImpl.fromPlRef;
+  fromAccessor: typeof ColumnLazyImpl.fromAccessor;
+  fromColumn: typeof ColumnLazyImpl.fromColumn;
+  getStatus: typeof ColumnLazyGetStatus;
+  getStatusById: typeof ColumnLazyImpl.getStatusById;
+  getStatusByPlRef: typeof ColumnLazyImpl.getStatusByPlRef;
+  getStatusByAccessor: typeof ColumnLazyImpl.getStatusByAccessor;
+};
+/**
+ * Type-guard narrowing to the leaf recipe. Prefer this over
+ * `instanceof ColumnLazyImpl` — `ColumnLazy` (the value) is the dispatcher
+ * with statics, not the class, so `instanceof` requires the impl symbol.
+ */
+declare function isColumnLazy(value: unknown): value is ColumnLazy;
+//#endregion
+export { ColumnAbsentError, type ColumnFieldStatus, ColumnLazy, ColumnLazyData, ColumnLazyId, ColumnLazyImpl, type ColumnResolutionStatus, isColumnLazy };
+//# sourceMappingURL=column_lazy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"column_lazy.d.ts","names":[],"sources":["../../src/columns/column_lazy.ts"],"mappings":";;;;;;KA0BY,YAAA,GAAe,SAAS;AAAA,KACxB,cAAA,eAA6B,oBAAoB;AAD7D;;;;AAAoC;AACpC;;;;AAA6D;AAc7D;AAfA,cAea,iBAAA,SAA0B,KAAA;EAAA,SACT,EAAA,EAAI,iBAAA;cAAJ,EAAA,EAAI,iBAAA;AAAA;;;;;;;;cAarB,cAAA,YAA0B,YAAA,CAAa,SAAA;EAAA,SAMhC,EAAA,EAAI,SAAA;EAAA,iBACH,OAAA;EAAA,QANX,SAAA;EAAA,QACA,SAAA;EAAA,QACA,eAAA;EAAA,QAED,WAAA;EAL2C;EAelD,gBAAA,IAAoB,SAAA;EAIpB,OAAA,IAAW,WAAA;EAAA;EAQX,QAAA,IAAY,SAAA;EAKD;EAAX,OAAA,IAAW,cAAA;EAKX,aAAA,IAAiB,iBAAA;EAYoB;;;;;EAArC,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,YAAA;EAgCK;;;;;;;EAAA,OArBnC,MAAA,CAAO,EAAA,EAAI,SAAA;IAAa;EAAA;IAAS,GAAA,GAAM,kBAAA;EAAA,gBAAwC,UAAA;EAiEnE;EAAA,OA5CZ,SAAA,CAAU,GAAA,EAAK,KAAA,eAAoB,UAAA;EAsDnC;;;;;EAAA,OA7CA,YAAA,CAAa,KAAA,EAAO,SAAA,CAAU,gBAAA,gBAAgC,UAAA;EA1FhC;;;;EAAA,OA4G9B,UAAA,CAAW,MAAA,EAAQ,OAAA,CAAQ,cAAA,IAAkB,UAAA,GAAa,UAAA;EAtG/C;;;;;;EAAA,OAqHX,aAAA,CACL,EAAA,EAAI,SAAA;IACF;EAAA;IAAS,GAAA,GAAM,kBAAA;EAAA,IAChB,sBAAA;EA3GH;EAAA,OAmHO,gBAAA,CACL,GAAA,EAAK,KAAA,EACL,IAAA;IAAQ,GAAA,GAAM,kBAAA;EAAA,IACb,sBAAA;EAzGH;EAAA,OA8GO,mBAAA,CAAoB,KAAA,EAAO,SAAA,CAAU,gBAAA,IAAoB,sBAAA;AAAA;;;;;;KAUtD,UAAA,GAAa,cAAc;;;;;;;iBAQ9B,kBAAA,CACP,MAAA,EAAQ,SAAA,GAAY,KAAA,GAAQ,SAAA,CAAU,gBAAA,IAAoB,OAAA,CAAQ,cAAA,IAAkB,UAAA,EACpF,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,gBACD,UAAA;;;;;;;iBAeN,mBAAA,CACP,MAAA,EAAQ,SAAA,GAAY,KAAA,GAAQ,SAAA,CAAU,gBAAA,IAAoB,OAAA,CAAQ,cAAA,IAAkB,UAAA,EACpF,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,IACb,sBAAA;AAAA,cASU,UAAA,SAAU,kBAAA;;;;;;;;;;;;;;;iBAgBP,YAAA,CAAa,KAAA,YAAiB,KAAA,IAAS,UAAU"}