@platforma-sdk/model 1.79.27 → 1.80.2

package/dist/columns/column_lazy.js

@@ -0,0 +1,245 @@
+import { ColumnOverriddenRecipe } from "./column_recipes/column_overrided_recipe.js";
+import { getCtxProviders } from "./column_providers/index.js";
+import { ColumnRegistry, createGlobalPObjectId, isPColumn, isPlRef } from "@milaboratories/pl-model-common";
+import { isNil } from "es-toolkit";
+import { LRUCache } from "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 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 ColumnRegistry(getCtxProviders({ ctx }));
+		const leaf = registry.resolve(id);
+		if (isNil(leaf)) {
+			if (registry.isFinal()) throw new ColumnAbsentError(id);
+			return;
+		}
+		const spec = readSpecAccessor(leaf);
+		if (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(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 (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 ColumnRegistry(getCtxProviders({ ctx }));
+		const leaf = registry.resolve(id);
+		if (isNil(leaf)) return registry.isFinal() ? "absent" : "resolving";
+		return getLeafEntryStatus(leaf);
+	}
+	/** {@link PlRef} wrapper over {@link getStatusById}. */
+	static getStatusByPlRef(ref, opts = {}) {
+		return ColumnLazyImpl.getStatusById(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 (isPlRef(source)) return ColumnLazyImpl.fromPlRef(source);
+	if (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 (isPlRef(source)) return ColumnLazyImpl.getStatusByPlRef(source, opts);
+	if (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 (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 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
+export { ColumnAbsentError, ColumnLazy, ColumnLazyImpl, isColumnLazy };
+
+//# sourceMappingURL=column_lazy.js.map

package/dist/columns/column_lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column_lazy.js","names":[],"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_providers/index.cjs

@@ -0,0 +1,62 @@
+const require_internal = require("../../internal.cjs");
+const require_accessor = require("../../render/accessor.cjs");
+const require_internal$1 = require("../../render/internal.cjs");
+const require_providers = require("./providers.cjs");
+//#region src/columns/column_providers/index.ts
+/**
+* Build the default set of ColumnsProviders for the ambient render ctx:
+*  - `AccessorColumnsProvider` over `outputs` (if present)
+*  - `AccessorColumnsProvider` over `prerun`  (if present)
+*  - `ResultPoolColumnsProvider` over `rawResultPool`
+*
+* Pulls handles directly from the ambient `cfgRenderCtx`. Returns `[]` when
+* called outside a render context.
+*
+* Result is memoised per-ctx (WeakMap → array). Repeated calls within the
+* same render cycle return the same provider triplet — inner providers are
+* also LRU-memoised by their content keys, so even a cache miss here doesn't
+* re-walk the trees.
+*/
+const _ctxProvidersCache = /* @__PURE__ */ new WeakMap();
+function getCtxProviders(deps) {
+	const ctx = deps?.ctx ?? require_internal.getCfgRenderCtx();
+	const cached = _ctxProvidersCache.get(ctx);
+	if (cached !== void 0) return cached;
+	const providers = [];
+	const outputs = ctx.getAccessorHandleByName(require_internal$1.MainAccessorName);
+	if (outputs !== void 0) providers.push(require_providers.ColumnsProvider(new require_accessor.TreeNodeAccessor(outputs, [require_internal$1.MainAccessorName])));
+	const prerun = ctx.getAccessorHandleByName(require_internal$1.StagingAccessorName);
+	if (prerun !== void 0) providers.push(require_providers.ColumnsProvider(new require_accessor.TreeNodeAccessor(prerun, [require_internal$1.StagingAccessorName])));
+	providers.push(require_providers.ColumnsProvider(ctx.getUpstreamBlockCtx()));
+	_ctxProvidersCache.set(ctx, providers);
+	return providers;
+}
+function isColumnProvider(source) {
+	if (typeof source !== "object" || source === null) return false;
+	const p = source;
+	return typeof p.getColumns === "function" && typeof p.isFinal === "function";
+}
+function toColumnProvider(source) {
+	if (isColumnArray(source)) return new require_providers.ArrayColumnsProvider(source.columns, source.isFinal);
+	if (isColumnProvider(source)) return source;
+	if (source instanceof require_accessor.TreeNodeAccessor) return require_providers.ColumnsProvider(source);
+	throw new Error("Unknown ColumnsSource type");
+}
+function isColumnArray(source) {
+	if (typeof source !== "object" || source === null) return false;
+	const s = source;
+	return Array.isArray(s.columns) && typeof s.isFinal === "boolean";
+}
+//#endregion
+exports.AccessorColumnsProvider = require_providers.AccessorColumnsProvider;
+exports.AccessorColumnsProviderImpl = require_providers.AccessorColumnsProviderImpl;
+exports.ArrayColumnsProvider = require_providers.ArrayColumnsProvider;
+exports.ColumnsProvider = require_providers.ColumnsProvider;
+exports.ResultPoolColumnsProvider = require_providers.ResultPoolColumnsProvider;
+exports.ResultPoolColumnsProviderImpl = require_providers.ResultPoolColumnsProviderImpl;
+exports._ctxProvidersCache = _ctxProvidersCache;
+exports.getCtxProviders = getCtxProviders;
+exports.isColumnProvider = isColumnProvider;
+exports.toColumnProvider = toColumnProvider;
+
+//# sourceMappingURL=index.cjs.map

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

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

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

@@ -0,0 +1,30 @@
+import { GlobalCfgRenderCtx } from "../../render/internal.js";
+import { TreeNodeAccessor } from "../../render/accessor.js";
+import { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl } from "./providers.js";
+import { ColumnsSource } from "./types.js";
+import { ColumnEntriesProvider } from "@milaboratories/pl-model-common";
+
+//#region src/columns/column_providers/index.d.ts
+/**
+ * Build the default set of ColumnsProviders for the ambient render ctx:
+ *  - `AccessorColumnsProvider` over `outputs` (if present)
+ *  - `AccessorColumnsProvider` over `prerun`  (if present)
+ *  - `ResultPoolColumnsProvider` over `rawResultPool`
+ *
+ * Pulls handles directly from the ambient `cfgRenderCtx`. Returns `[]` when
+ * called outside a render context.
+ *
+ * Result is memoised per-ctx (WeakMap → array). Repeated calls within the
+ * same render cycle return the same provider triplet — inner providers are
+ * also LRU-memoised by their content keys, so even a cache miss here doesn't
+ * re-walk the trees.
+ */
+declare const _ctxProvidersCache: WeakMap<GlobalCfgRenderCtx, (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[]>;
+declare function getCtxProviders(deps?: {
+  ctx?: GlobalCfgRenderCtx;
+}): (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[];
+declare function isColumnProvider(source: unknown): source is ColumnsProvider;
+declare function toColumnProvider(source: ColumnsSource): ColumnsProvider;
+//#endregion
+export { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ColumnsSource, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl, _ctxProvidersCache, getCtxProviders, isColumnProvider, toColumnProvider };
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/columns/column_providers/index.js

@@ -0,0 +1,53 @@
+import { getCfgRenderCtx } from "../../internal.js";
+import { TreeNodeAccessor } from "../../render/accessor.js";
+import { MainAccessorName, StagingAccessorName } from "../../render/internal.js";
+import { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl } from "./providers.js";
+//#region src/columns/column_providers/index.ts
+/**
+* Build the default set of ColumnsProviders for the ambient render ctx:
+*  - `AccessorColumnsProvider` over `outputs` (if present)
+*  - `AccessorColumnsProvider` over `prerun`  (if present)
+*  - `ResultPoolColumnsProvider` over `rawResultPool`
+*
+* Pulls handles directly from the ambient `cfgRenderCtx`. Returns `[]` when
+* called outside a render context.
+*
+* Result is memoised per-ctx (WeakMap → array). Repeated calls within the
+* same render cycle return the same provider triplet — inner providers are
+* also LRU-memoised by their content keys, so even a cache miss here doesn't
+* re-walk the trees.
+*/
+const _ctxProvidersCache = /* @__PURE__ */ new WeakMap();
+function getCtxProviders(deps) {
+	const ctx = deps?.ctx ?? getCfgRenderCtx();
+	const cached = _ctxProvidersCache.get(ctx);
+	if (cached !== void 0) return cached;
+	const providers = [];
+	const outputs = ctx.getAccessorHandleByName(MainAccessorName);
+	if (outputs !== void 0) providers.push(ColumnsProvider(new TreeNodeAccessor(outputs, [MainAccessorName])));
+	const prerun = ctx.getAccessorHandleByName(StagingAccessorName);
+	if (prerun !== void 0) providers.push(ColumnsProvider(new TreeNodeAccessor(prerun, [StagingAccessorName])));
+	providers.push(ColumnsProvider(ctx.getUpstreamBlockCtx()));
+	_ctxProvidersCache.set(ctx, providers);
+	return providers;
+}
+function isColumnProvider(source) {
+	if (typeof source !== "object" || source === null) return false;
+	const p = source;
+	return typeof p.getColumns === "function" && typeof p.isFinal === "function";
+}
+function toColumnProvider(source) {
+	if (isColumnArray(source)) return new ArrayColumnsProvider(source.columns, source.isFinal);
+	if (isColumnProvider(source)) return source;
+	if (source instanceof TreeNodeAccessor) return ColumnsProvider(source);
+	throw new Error("Unknown ColumnsSource type");
+}
+function isColumnArray(source) {
+	if (typeof source !== "object" || source === null) return false;
+	const s = source;
+	return Array.isArray(s.columns) && typeof s.isFinal === "boolean";
+}
+//#endregion
+export { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl, _ctxProvidersCache, getCtxProviders, isColumnProvider, toColumnProvider };
+
+//# sourceMappingURL=index.js.map

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

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

package/dist/columns/column_providers/providers.cjs

@@ -0,0 +1,123 @@
+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");
+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_providers/providers.ts
+/**
+* Unified memoised factory dispatching to the right provider flavour by the
+* source shape:
+* - `TreeNodeAccessor` → {@link AccessorColumnsProvider}
+*   (indexed by `root.handle`, walks the accessor tree once per root).
+* - `UpstreamBlockCtx<AccessorHandle>[]` (or omitted — pulled from the
+*   ambient ctx) → {@link ResultPoolColumnsProvider}
+*   (indexed by a content-hash of the block list).
+*
+* Both branches return cached instances within their LRU window, so repeated
+* calls with the same source skip re-walking / re-hashing.
+*/
+function ColumnsProvider(source) {
+	if ((0, es_toolkit.isNil)(source) || Array.isArray(source)) return ResultPoolColumnsProvider(source);
+	else if (source instanceof require_accessor.TreeNodeAccessor) return AccessorColumnsProvider(source);
+	else throw new Error("Unknown columns provider source");
+}
+/**
+* Memoised constructor — same `root.handle` returns the same
+* {@link AccessorColumnsProviderImpl}, so `indexAccessorRoot` runs once per
+* accessor root (within the LRU window).
+*/
+const _accessorProviderCache = new lru_cache.LRUCache({ max: 64 });
+function AccessorColumnsProvider(root) {
+	let provider = _accessorProviderCache.get(root.handle);
+	if (provider === void 0) {
+		provider = new AccessorColumnsProviderImpl(root);
+		_accessorProviderCache.set(root.handle, provider);
+	}
+	return provider;
+}
+/**
+* Memoised constructor — same `rawPool` content returns the same
+* {@link ResultPoolColumnsProviderImpl}, so `indexPoolBlock` runs once per
+* pool snapshot (within the LRU window).
+*/
+const _resultPoolProviderCache = new lru_cache.LRUCache({ max: 4 });
+function ResultPoolColumnsProvider(rawPool = require_internal.getCfgRenderCtx().getUpstreamBlockCtx()) {
+	const key = hashRawPool(rawPool);
+	let provider = _resultPoolProviderCache.get(key);
+	if (provider === void 0) {
+		provider = new ResultPoolColumnsProviderImpl(rawPool);
+		_resultPoolProviderCache.set(key, provider);
+	}
+	return provider;
+}
+/**
+* Simple provider wrapping an array of PColumns. Sandbox-only —
+* implements {@link ColumnsProvider} (lazy-view enumeration). It is *not* an
+* id-index source — `ColumnRegistry` does not consume it.
+*/
+var ArrayColumnsProvider = class {
+	_isFinal;
+	columns;
+	constructor(columns, _isFinal) {
+		this._isFinal = _isFinal;
+		this.columns = columns.map((c) => require_column_lazy.ColumnLazyImpl.fromColumn(c));
+	}
+	getColumns() {
+		return this.columns;
+	}
+	isFinal() {
+		return this._isFinal;
+	}
+};
+/**
+* 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
+* entries index.
+*/
+var AccessorColumnsProviderImpl = class extends _milaboratories_pl_model_common.AccessorEntriesProvider {
+	cachedColumns;
+	constructor(root) {
+		super(root, root.resolvePath);
+	}
+	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));
+	}
+};
+/**
+* Sandbox-specific result-pool provider. Accepts the raw handle-shaped blocks
+* returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx} and
+* wraps them into {@link TreeNodeAccessor}s, then adds `getColumns()`.
+*/
+var ResultPoolColumnsProviderImpl = class extends _milaboratories_pl_model_common.ResultPoolEntriesProvider {
+	cachedColumns;
+	constructor(rawPool = require_internal.getCfgRenderCtx().getUpstreamBlockCtx()) {
+		const blocks = rawPool.map((b) => ({
+			blockId: b.blockId,
+			prodCtx: b.prodCtx !== void 0 ? new require_accessor.TreeNodeAccessor(b.prodCtx, [b.blockId, "prodCtx"]) : void 0,
+			stagingCtx: b.stagingCtx !== void 0 ? new require_accessor.TreeNodeAccessor(b.stagingCtx, [b.blockId, "stagingCtx"]) : void 0,
+			prodIncomplete: b.prodIncomplete,
+			stagingIncomplete: b.stagingIncomplete
+		}));
+		super(blocks);
+	}
+	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));
+	}
+};
+function hashRawPool(rawPool) {
+	return rawPool.map((b) => `${b.blockId}\x1f${b.prodCtx ?? ""}\x1f${b.stagingCtx ?? ""}\x1f${b.prodIncomplete ? 1 : 0}\x1f${b.stagingIncomplete ? 1 : 0}`).join("");
+}
+//#endregion
+exports.AccessorColumnsProvider = AccessorColumnsProvider;
+exports.AccessorColumnsProviderImpl = AccessorColumnsProviderImpl;
+exports.ArrayColumnsProvider = ArrayColumnsProvider;
+exports.ColumnsProvider = ColumnsProvider;
+exports.ResultPoolColumnsProvider = ResultPoolColumnsProvider;
+exports.ResultPoolColumnsProviderImpl = ResultPoolColumnsProviderImpl;
+
+//# sourceMappingURL=providers.cjs.map

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

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