@milaboratories/pl-model-common 1.46.4 → 1.47.0

package/dist/columns/dedup.cjs

@@ -0,0 +1,47 @@
+const require_spec = require("../pool/spec.cjs");
+require("../pool/index.cjs");
+const require_native_id = require("../drivers/pframe/spec/native_id.cjs");
+//#region src/columns/dedup.ts
+/**
+* Two-track dedup over an item stream keyed by `ColumnUniversalId`:
+*
+* - **Raw `PObjectId`s** are deduped by `deriveNativeId(spec)`. The same
+*   physical column reached via outputs vs. result_pool has different
+*   id shapes but identical nativeId — first occurrence wins so the
+*   provider order (outputs before pool) decides which id is canonical.
+* - **Non-`PObjectId` ids** (e.g. `SUniversalPColumnUniversalId`,
+*   `ColumnDiscoveredId`) keep raw-id dedup — they legitimately share
+*   nativeId with siblings.
+*
+* When `getSpec` returns `undefined` for a `PObjectId`, falls back to raw-id
+* dedup (so an unresolvable id still survives instead of dropping silently).
+*
+* Shared by sandbox-side `extractColumns` (column_providers) and host-side
+* `ColumnsCollectionDriverImpl.getColumns` — both layers need identical
+* dedup semantics, but operate on different concrete item types (ColumnLazy
+* vs. raw ColumnUniversalId).
+*/
+function dedupColumns(items, getId, getSpec) {
+	const seenNative = /* @__PURE__ */ new Set();
+	const seenId = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const item of items) {
+		const id = getId(item);
+		if (seenId.has(id)) continue;
+		if (require_spec.isPObjectId(id)) {
+			const spec = getSpec(item);
+			if (spec !== void 0) {
+				const nativeId = require_native_id.deriveNativeId(spec);
+				if (seenNative.has(nativeId)) continue;
+				seenNative.add(nativeId);
+			}
+		}
+		seenId.add(id);
+		out.push(item);
+	}
+	return out;
+}
+//#endregion
+exports.dedupColumns = dedupColumns;
+
+//# sourceMappingURL=dedup.cjs.map

package/dist/columns/dedup.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup.cjs","names":["isPObjectId","deriveNativeId"],"sources":["../../src/columns/dedup.ts"],"sourcesContent":["import type { PColumnSpec } from \"../drivers/pframe/spec/spec\";\nimport type { NativePObjectId } from \"../drivers/pframe/spec/native_id\";\nimport { deriveNativeId } from \"../drivers/pframe/spec/native_id\";\nimport type { ColumnUniversalId } from \"../drivers/pframe/spec/ids\";\nimport { isPObjectId } from \"../pool\";\n\n/**\n * Two-track dedup over an item stream keyed by `ColumnUniversalId`:\n *\n * - **Raw `PObjectId`s** are deduped by `deriveNativeId(spec)`. The same\n *   physical column reached via outputs vs. result_pool has different\n *   id shapes but identical nativeId — first occurrence wins so the\n *   provider order (outputs before pool) decides which id is canonical.\n * - **Non-`PObjectId` ids** (e.g. `SUniversalPColumnUniversalId`,\n *   `ColumnDiscoveredId`) keep raw-id dedup — they legitimately share\n *   nativeId with siblings.\n *\n * When `getSpec` returns `undefined` for a `PObjectId`, falls back to raw-id\n * dedup (so an unresolvable id still survives instead of dropping silently).\n *\n * Shared by sandbox-side `extractColumns` (column_providers) and host-side\n * `ColumnsCollectionDriverImpl.getColumns` — both layers need identical\n * dedup semantics, but operate on different concrete item types (ColumnLazy\n * vs. raw ColumnUniversalId).\n */\nexport function dedupColumns<T>(\n  items: ReadonlyArray<T>,\n  getId: (item: T) => ColumnUniversalId,\n  getSpec: (item: T) => PColumnSpec | undefined,\n): T[] {\n  const seenNative = new Set<NativePObjectId>();\n  const seenId = new Set<ColumnUniversalId>();\n  const out: T[] = [];\n  for (const item of items) {\n    const id = getId(item);\n    if (seenId.has(id)) continue;\n    if (isPObjectId(id)) {\n      const spec = getSpec(item);\n      if (spec !== undefined) {\n        const nativeId = deriveNativeId(spec);\n        if (seenNative.has(nativeId)) continue;\n        seenNative.add(nativeId);\n      }\n    }\n    seenId.add(id);\n    out.push(item);\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,aACd,OACA,OACA,SACK;CACL,MAAM,6BAAa,IAAI,IAAqB;CAC5C,MAAM,yBAAS,IAAI,IAAuB;CAC1C,MAAM,MAAW,CAAC;CAClB,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,KAAK,MAAM,IAAI;EACrB,IAAI,OAAO,IAAI,EAAE,GAAG;EACpB,IAAIA,aAAAA,YAAY,EAAE,GAAG;GACnB,MAAM,OAAO,QAAQ,IAAI;GACzB,IAAI,SAAS,KAAA,GAAW;IACtB,MAAM,WAAWC,kBAAAA,eAAe,IAAI;IACpC,IAAI,WAAW,IAAI,QAAQ,GAAG;IAC9B,WAAW,IAAI,QAAQ;GACzB;EACF;EACA,OAAO,IAAI,EAAE;EACb,IAAI,KAAK,IAAI;CACf;CACA,OAAO;AACT"}

package/dist/columns/dedup.d.ts

@@ -0,0 +1,27 @@
+import { PColumnSpec } from "../drivers/pframe/spec/spec.js";
+import { ColumnUniversalId } from "../drivers/pframe/spec/ids.js";
+
+//#region src/columns/dedup.d.ts
+/**
+ * Two-track dedup over an item stream keyed by `ColumnUniversalId`:
+ *
+ * - **Raw `PObjectId`s** are deduped by `deriveNativeId(spec)`. The same
+ *   physical column reached via outputs vs. result_pool has different
+ *   id shapes but identical nativeId — first occurrence wins so the
+ *   provider order (outputs before pool) decides which id is canonical.
+ * - **Non-`PObjectId` ids** (e.g. `SUniversalPColumnUniversalId`,
+ *   `ColumnDiscoveredId`) keep raw-id dedup — they legitimately share
+ *   nativeId with siblings.
+ *
+ * When `getSpec` returns `undefined` for a `PObjectId`, falls back to raw-id
+ * dedup (so an unresolvable id still survives instead of dropping silently).
+ *
+ * Shared by sandbox-side `extractColumns` (column_providers) and host-side
+ * `ColumnsCollectionDriverImpl.getColumns` — both layers need identical
+ * dedup semantics, but operate on different concrete item types (ColumnLazy
+ * vs. raw ColumnUniversalId).
+ */
+declare function dedupColumns<T>(items: ReadonlyArray<T>, getId: (item: T) => ColumnUniversalId, getSpec: (item: T) => PColumnSpec | undefined): T[];
+//#endregion
+export { dedupColumns };
+//# sourceMappingURL=dedup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dedup.d.ts","names":[],"sources":["../../src/columns/dedup.ts"],"mappings":";;;;;;AAyBA;;;;;;;;;;;;;;;;;iBAAgB,YAAA,IACd,KAAA,EAAO,aAAA,CAAc,CAAA,GACrB,KAAA,GAAQ,IAAA,EAAM,CAAA,KAAM,iBAAA,EACpB,OAAA,GAAU,IAAA,EAAM,CAAA,KAAM,WAAA,eACrB,CAAA"}

package/dist/columns/dedup.js

@@ -0,0 +1,47 @@
+import { isPObjectId } from "../pool/spec.js";
+import "../pool/index.js";
+import { deriveNativeId } from "../drivers/pframe/spec/native_id.js";
+//#region src/columns/dedup.ts
+/**
+* Two-track dedup over an item stream keyed by `ColumnUniversalId`:
+*
+* - **Raw `PObjectId`s** are deduped by `deriveNativeId(spec)`. The same
+*   physical column reached via outputs vs. result_pool has different
+*   id shapes but identical nativeId — first occurrence wins so the
+*   provider order (outputs before pool) decides which id is canonical.
+* - **Non-`PObjectId` ids** (e.g. `SUniversalPColumnUniversalId`,
+*   `ColumnDiscoveredId`) keep raw-id dedup — they legitimately share
+*   nativeId with siblings.
+*
+* When `getSpec` returns `undefined` for a `PObjectId`, falls back to raw-id
+* dedup (so an unresolvable id still survives instead of dropping silently).
+*
+* Shared by sandbox-side `extractColumns` (column_providers) and host-side
+* `ColumnsCollectionDriverImpl.getColumns` — both layers need identical
+* dedup semantics, but operate on different concrete item types (ColumnLazy
+* vs. raw ColumnUniversalId).
+*/
+function dedupColumns(items, getId, getSpec) {
+	const seenNative = /* @__PURE__ */ new Set();
+	const seenId = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const item of items) {
+		const id = getId(item);
+		if (seenId.has(id)) continue;
+		if (isPObjectId(id)) {
+			const spec = getSpec(item);
+			if (spec !== void 0) {
+				const nativeId = deriveNativeId(spec);
+				if (seenNative.has(nativeId)) continue;
+				seenNative.add(nativeId);
+			}
+		}
+		seenId.add(id);
+		out.push(item);
+	}
+	return out;
+}
+//#endregion
+export { dedupColumns };
+
+//# sourceMappingURL=dedup.js.map

package/dist/columns/dedup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup.js","names":[],"sources":["../../src/columns/dedup.ts"],"sourcesContent":["import type { PColumnSpec } from \"../drivers/pframe/spec/spec\";\nimport type { NativePObjectId } from \"../drivers/pframe/spec/native_id\";\nimport { deriveNativeId } from \"../drivers/pframe/spec/native_id\";\nimport type { ColumnUniversalId } from \"../drivers/pframe/spec/ids\";\nimport { isPObjectId } from \"../pool\";\n\n/**\n * Two-track dedup over an item stream keyed by `ColumnUniversalId`:\n *\n * - **Raw `PObjectId`s** are deduped by `deriveNativeId(spec)`. The same\n *   physical column reached via outputs vs. result_pool has different\n *   id shapes but identical nativeId — first occurrence wins so the\n *   provider order (outputs before pool) decides which id is canonical.\n * - **Non-`PObjectId` ids** (e.g. `SUniversalPColumnUniversalId`,\n *   `ColumnDiscoveredId`) keep raw-id dedup — they legitimately share\n *   nativeId with siblings.\n *\n * When `getSpec` returns `undefined` for a `PObjectId`, falls back to raw-id\n * dedup (so an unresolvable id still survives instead of dropping silently).\n *\n * Shared by sandbox-side `extractColumns` (column_providers) and host-side\n * `ColumnsCollectionDriverImpl.getColumns` — both layers need identical\n * dedup semantics, but operate on different concrete item types (ColumnLazy\n * vs. raw ColumnUniversalId).\n */\nexport function dedupColumns<T>(\n  items: ReadonlyArray<T>,\n  getId: (item: T) => ColumnUniversalId,\n  getSpec: (item: T) => PColumnSpec | undefined,\n): T[] {\n  const seenNative = new Set<NativePObjectId>();\n  const seenId = new Set<ColumnUniversalId>();\n  const out: T[] = [];\n  for (const item of items) {\n    const id = getId(item);\n    if (seenId.has(id)) continue;\n    if (isPObjectId(id)) {\n      const spec = getSpec(item);\n      if (spec !== undefined) {\n        const nativeId = deriveNativeId(spec);\n        if (seenNative.has(nativeId)) continue;\n        seenNative.add(nativeId);\n      }\n    }\n    seenId.add(id);\n    out.push(item);\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,aACd,OACA,OACA,SACK;CACL,MAAM,6BAAa,IAAI,IAAqB;CAC5C,MAAM,yBAAS,IAAI,IAAuB;CAC1C,MAAM,MAAW,CAAC;CAClB,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,KAAK,MAAM,IAAI;EACrB,IAAI,OAAO,IAAI,EAAE,GAAG;EACpB,IAAI,YAAY,EAAE,GAAG;GACnB,MAAM,OAAO,QAAQ,IAAI;GACzB,IAAI,SAAS,KAAA,GAAW;IACtB,MAAM,WAAW,eAAe,IAAI;IACpC,IAAI,WAAW,IAAI,QAAQ,GAAG;IAC9B,WAAW,IAAI,QAAQ;GACzB;EACF;EACA,OAAO,IAAI,EAAE;EACb,IAAI,KAAK,IAAI;CACf;CACA,OAAO;AACT"}

package/dist/columns/index.cjs

@@ -0,0 +1,18 @@
+const require_accessor_traversal = require("./accessor_traversal.cjs");
+const require_column_registry = require("./column_registry.cjs");
+const require_column_selector = require("./column_selector.cjs");
+const require_dedup = require("./dedup.cjs");
+const require_providers = require("./providers.cjs");
+exports.AccessorEntriesProvider = require_providers.AccessorEntriesProvider;
+exports.COLLECT_TYPES = require_accessor_traversal.COLLECT_TYPES;
+exports.ColumnRegistry = require_column_registry.ColumnRegistry;
+exports.DESCEND_TYPES = require_accessor_traversal.DESCEND_TYPES;
+exports.ResultPoolEntriesProvider = require_providers.ResultPoolEntriesProvider;
+exports.convertColumnSelectorToMultiColumnSelector = require_column_selector.convertColumnSelectorToMultiColumnSelector;
+exports.convertRelaxedAxisSelectorToMultiAxisSelector = require_column_selector.convertRelaxedAxisSelectorToMultiAxisSelector;
+exports.convertRelaxedColumnSelectorToMultiColumnSelector = require_column_selector.convertRelaxedColumnSelectorToMultiColumnSelector;
+exports.dedupColumns = require_dedup.dedupColumns;
+exports.findDescendantsByType = require_accessor_traversal.findDescendantsByType;
+exports.indexAccessorRoot = require_accessor_traversal.indexAccessorRoot;
+exports.indexPoolBlock = require_accessor_traversal.indexPoolBlock;
+exports.listColumnNames = require_accessor_traversal.listColumnNames;

package/dist/columns/index.d.ts

@@ -0,0 +1,8 @@
+import { StringMatcher } from "../drivers/pframe/spec_driver.js";
+import { ColumnSelector, RelaxedAxisSelector, RelaxedColumnSelector, RelaxedRecord, RelaxedStringMatchers, convertColumnSelectorToMultiColumnSelector, convertRelaxedAxisSelectorToMultiAxisSelector, convertRelaxedColumnSelectorToMultiColumnSelector } from "./column_selector.js";
+import { AccessorHandle, AccessorLike, ColumnEntriesProvider, FieldTraversalStepLike, LeafEntry, UpstreamBlockCtx } from "./types.js";
+import { COLLECT_TYPES, DESCEND_TYPES, findDescendantsByType, indexAccessorRoot, indexPoolBlock, listColumnNames } from "./accessor_traversal.js";
+import { ColumnRegistry } from "./column_registry.js";
+import { dedupColumns } from "./dedup.js";
+import { AccessorEntriesProvider, ResultPoolEntriesProvider } from "./providers.js";
+export { AccessorEntriesProvider, AccessorHandle, AccessorLike, COLLECT_TYPES, ColumnEntriesProvider, ColumnRegistry, ColumnSelector, DESCEND_TYPES, FieldTraversalStepLike, LeafEntry, RelaxedAxisSelector, RelaxedColumnSelector, RelaxedRecord, RelaxedStringMatchers, ResultPoolEntriesProvider, UpstreamBlockCtx, convertColumnSelectorToMultiColumnSelector, convertRelaxedAxisSelectorToMultiAxisSelector, convertRelaxedColumnSelectorToMultiColumnSelector, dedupColumns, findDescendantsByType, indexAccessorRoot, indexPoolBlock, listColumnNames };

package/dist/columns/index.js

@@ -0,0 +1,6 @@
+import { COLLECT_TYPES, DESCEND_TYPES, findDescendantsByType, indexAccessorRoot, indexPoolBlock, listColumnNames } from "./accessor_traversal.js";
+import { ColumnRegistry } from "./column_registry.js";
+import { convertColumnSelectorToMultiColumnSelector, convertRelaxedAxisSelectorToMultiAxisSelector, convertRelaxedColumnSelectorToMultiColumnSelector } from "./column_selector.js";
+import { dedupColumns } from "./dedup.js";
+import { AccessorEntriesProvider, ResultPoolEntriesProvider } from "./providers.js";
+export { AccessorEntriesProvider, COLLECT_TYPES, ColumnRegistry, DESCEND_TYPES, ResultPoolEntriesProvider, convertColumnSelectorToMultiColumnSelector, convertRelaxedAxisSelectorToMultiAxisSelector, convertRelaxedColumnSelectorToMultiColumnSelector, dedupColumns, findDescendantsByType, indexAccessorRoot, indexPoolBlock, listColumnNames };

package/dist/columns/providers.cjs

@@ -0,0 +1,62 @@
+const require_accessor_traversal = require("./accessor_traversal.cjs");
+//#region src/columns/providers.ts
+/**
+* Generic entries provider over a single accessor root. Walks `<root>` once
+* from the supplied `rootPath`, builds an id → {@link LeafEntry} map and
+* exposes `isFinal()` via the root's `getInputsLocked()`.
+*
+* Used directly on the host side; sandbox extends it with `getColumns()`
+* returning {@link ColumnLazy}s — see `AccessorColumnsProvider` in
+* `@platforma-sdk/model`.
+*/
+var AccessorEntriesProvider = class {
+	root;
+	entries;
+	constructor(root, rootPath) {
+		this.root = root;
+		const map = /* @__PURE__ */ new Map();
+		for (const entry of require_accessor_traversal.indexAccessorRoot(root, rootPath)) if (!map.has(entry.id)) map.set(entry.id, entry);
+		this.entries = map;
+	}
+	getPObjectEntries() {
+		return this.entries;
+	}
+	isFinal() {
+		return this.root.getInputsLocked();
+	}
+};
+/**
+* Generic entries provider over a list of upstream-block ctx pairs.
+*
+* Per-block merge: iterate `prod` then `staging`, dedupe by name with
+* first-wins semantics (prod takes precedence).
+*
+* `isFinal()` is the AND of `getInputsLocked()` over every present ctx
+* accessor and `!prodIncomplete && !stagingIncomplete` over every block.
+*/
+var ResultPoolEntriesProvider = class {
+	blocks;
+	cachedEntries;
+	constructor(blocks) {
+		this.blocks = blocks;
+	}
+	getPObjectEntries() {
+		if (this.cachedEntries !== void 0) return this.cachedEntries;
+		const map = /* @__PURE__ */ new Map();
+		for (const block of this.blocks) for (const entry of require_accessor_traversal.indexPoolBlock(block)) if (!map.has(entry.id)) map.set(entry.id, entry);
+		return this.cachedEntries = map;
+	}
+	isFinal() {
+		for (const block of this.blocks) {
+			if (block.prodIncomplete || block.stagingIncomplete) return false;
+			if (block.prodCtx && !block.prodCtx.getInputsLocked()) return false;
+			if (block.stagingCtx && !block.stagingCtx.getInputsLocked()) return false;
+		}
+		return true;
+	}
+};
+//#endregion
+exports.AccessorEntriesProvider = AccessorEntriesProvider;
+exports.ResultPoolEntriesProvider = ResultPoolEntriesProvider;
+
+//# sourceMappingURL=providers.cjs.map

package/dist/columns/providers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.cjs","names":["indexAccessorRoot","indexPoolBlock"],"sources":["../../src/columns/providers.ts"],"sourcesContent":["import type { PObjectId } from \"../pool\";\nimport { indexAccessorRoot, indexPoolBlock } from \"./accessor_traversal\";\nimport type { AccessorLike, ColumnEntriesProvider, LeafEntry, UpstreamBlockCtx } from \"./types\";\n\n/**\n * Generic entries provider over a single accessor root. Walks `<root>` once\n * from the supplied `rootPath`, builds an id → {@link LeafEntry} map and\n * exposes `isFinal()` via the root's `getInputsLocked()`.\n *\n * Used directly on the host side; sandbox extends it with `getColumns()`\n * returning {@link ColumnLazy}s — see `AccessorColumnsProvider` in\n * `@platforma-sdk/model`.\n */\nexport class AccessorEntriesProvider<\n  A extends AccessorLike<A>,\n> implements ColumnEntriesProvider<A> {\n  protected readonly entries: ReadonlyMap<PObjectId, LeafEntry<A>>;\n\n  constructor(\n    protected readonly root: A,\n    rootPath: ReadonlyArray<string>,\n  ) {\n    const map = new Map<PObjectId, LeafEntry<A>>();\n    for (const entry of indexAccessorRoot(root, rootPath)) {\n      if (!map.has(entry.id)) map.set(entry.id, entry);\n    }\n    this.entries = map;\n  }\n\n  getPObjectEntries(): ReadonlyMap<PObjectId, LeafEntry<A>> {\n    return this.entries;\n  }\n\n  isFinal(): boolean {\n    return this.root.getInputsLocked();\n  }\n}\n\n/**\n * Generic entries provider over a list of upstream-block ctx pairs.\n *\n * Per-block merge: iterate `prod` then `staging`, dedupe by name with\n * first-wins semantics (prod takes precedence).\n *\n * `isFinal()` is the AND of `getInputsLocked()` over every present ctx\n * accessor and `!prodIncomplete && !stagingIncomplete` over every block.\n */\nexport class ResultPoolEntriesProvider<\n  A extends AccessorLike<A>,\n> implements ColumnEntriesProvider<A> {\n  protected cachedEntries?: ReadonlyMap<PObjectId, LeafEntry<A>>;\n\n  constructor(protected readonly blocks: ReadonlyArray<UpstreamBlockCtx<A>>) {}\n\n  getPObjectEntries(): ReadonlyMap<PObjectId, LeafEntry<A>> {\n    if (this.cachedEntries !== undefined) return this.cachedEntries;\n    const map = new Map<PObjectId, LeafEntry<A>>();\n    for (const block of this.blocks) {\n      for (const entry of indexPoolBlock(block)) {\n        if (!map.has(entry.id)) map.set(entry.id, entry);\n      }\n    }\n    return (this.cachedEntries = map);\n  }\n\n  isFinal(): boolean {\n    for (const block of this.blocks) {\n      if (block.prodIncomplete || block.stagingIncomplete) return false;\n      if (block.prodCtx && !block.prodCtx.getInputsLocked()) return false;\n      if (block.stagingCtx && !block.stagingCtx.getInputsLocked()) return false;\n    }\n    return true;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAaA,IAAa,0BAAb,MAEsC;CAIf;CAHrB;CAEA,YACE,MACA,UACA;EAFmB,KAAA,OAAA;EAGnB,MAAM,sBAAM,IAAI,IAA6B;EAC7C,KAAK,MAAM,SAASA,2BAAAA,kBAAkB,MAAM,QAAQ,GAClD,IAAI,CAAC,IAAI,IAAI,MAAM,EAAE,GAAG,IAAI,IAAI,MAAM,IAAI,KAAK;EAEjD,KAAK,UAAU;CACjB;CAEA,oBAA0D;EACxD,OAAO,KAAK;CACd;CAEA,UAAmB;EACjB,OAAO,KAAK,KAAK,gBAAgB;CACnC;AACF;;;;;;;;;;AAWA,IAAa,4BAAb,MAEsC;CAGL;CAF/B;CAEA,YAAY,QAA+D;EAA5C,KAAA,SAAA;CAA6C;CAE5E,oBAA0D;EACxD,IAAI,KAAK,kBAAkB,KAAA,GAAW,OAAO,KAAK;EAClD,MAAM,sBAAM,IAAI,IAA6B;EAC7C,KAAK,MAAM,SAAS,KAAK,QACvB,KAAK,MAAM,SAASC,2BAAAA,eAAe,KAAK,GACtC,IAAI,CAAC,IAAI,IAAI,MAAM,EAAE,GAAG,IAAI,IAAI,MAAM,IAAI,KAAK;EAGnD,OAAQ,KAAK,gBAAgB;CAC/B;CAEA,UAAmB;EACjB,KAAK,MAAM,SAAS,KAAK,QAAQ;GAC/B,IAAI,MAAM,kBAAkB,MAAM,mBAAmB,OAAO;GAC5D,IAAI,MAAM,WAAW,CAAC,MAAM,QAAQ,gBAAgB,GAAG,OAAO;GAC9D,IAAI,MAAM,cAAc,CAAC,MAAM,WAAW,gBAAgB,GAAG,OAAO;EACtE;EACA,OAAO;CACT;AACF"}

package/dist/columns/providers.d.ts

@@ -0,0 +1,39 @@
+import { PObjectId } from "../pool/spec.js";
+import { AccessorLike, ColumnEntriesProvider, LeafEntry, UpstreamBlockCtx } from "./types.js";
+
+//#region src/columns/providers.d.ts
+/**
+ * Generic entries provider over a single accessor root. Walks `<root>` once
+ * from the supplied `rootPath`, builds an id → {@link LeafEntry} map and
+ * exposes `isFinal()` via the root's `getInputsLocked()`.
+ *
+ * Used directly on the host side; sandbox extends it with `getColumns()`
+ * returning {@link ColumnLazy}s — see `AccessorColumnsProvider` in
+ * `@platforma-sdk/model`.
+ */
+declare class AccessorEntriesProvider<A extends AccessorLike<A>> implements ColumnEntriesProvider<A> {
+  protected readonly root: A;
+  protected readonly entries: ReadonlyMap<PObjectId, LeafEntry<A>>;
+  constructor(root: A, rootPath: ReadonlyArray<string>);
+  getPObjectEntries(): ReadonlyMap<PObjectId, LeafEntry<A>>;
+  isFinal(): boolean;
+}
+/**
+ * Generic entries provider over a list of upstream-block ctx pairs.
+ *
+ * Per-block merge: iterate `prod` then `staging`, dedupe by name with
+ * first-wins semantics (prod takes precedence).
+ *
+ * `isFinal()` is the AND of `getInputsLocked()` over every present ctx
+ * accessor and `!prodIncomplete && !stagingIncomplete` over every block.
+ */
+declare class ResultPoolEntriesProvider<A extends AccessorLike<A>> implements ColumnEntriesProvider<A> {
+  protected readonly blocks: ReadonlyArray<UpstreamBlockCtx<A>>;
+  protected cachedEntries?: ReadonlyMap<PObjectId, LeafEntry<A>>;
+  constructor(blocks: ReadonlyArray<UpstreamBlockCtx<A>>);
+  getPObjectEntries(): ReadonlyMap<PObjectId, LeafEntry<A>>;
+  isFinal(): boolean;
+}
+//#endregion
+export { AccessorEntriesProvider, ResultPoolEntriesProvider };
+//# sourceMappingURL=providers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","names":[],"sources":["../../src/columns/providers.ts"],"mappings":";;;;;;;AAaA;;;;;;cAAa,uBAAA,WACD,YAAA,CAAa,CAAA,cACZ,qBAAA,CAAsB,CAAA;EAAA,mBAIZ,IAAA,EAAM,CAAA;EAAA,mBAHR,OAAA,EAAS,WAAA,CAAY,SAAA,EAAW,SAAA,CAAU,CAAA;cAGxC,IAAA,EAAM,CAAA,EACzB,QAAA,EAAU,aAAA;EASZ,iBAAA,IAAqB,WAAA,CAAY,SAAA,EAAW,SAAA,CAAU,CAAA;EAItD,OAAA;AAAA;;;;;;;;;;cAcW,yBAAA,WACD,YAAA,CAAa,CAAA,cACZ,qBAAA,CAAsB,CAAA;EAAA,mBAGF,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,CAAA;EAAA,UAF5D,aAAA,GAAgB,WAAA,CAAY,SAAA,EAAW,SAAA,CAAU,CAAA;cAE5B,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,CAAA;EAEtE,iBAAA,IAAqB,WAAA,CAAY,SAAA,EAAW,SAAA,CAAU,CAAA;EAWtD,OAAA;AAAA"}

package/dist/columns/providers.js

@@ -0,0 +1,61 @@
+import { indexAccessorRoot, indexPoolBlock } from "./accessor_traversal.js";
+//#region src/columns/providers.ts
+/**
+* Generic entries provider over a single accessor root. Walks `<root>` once
+* from the supplied `rootPath`, builds an id → {@link LeafEntry} map and
+* exposes `isFinal()` via the root's `getInputsLocked()`.
+*
+* Used directly on the host side; sandbox extends it with `getColumns()`
+* returning {@link ColumnLazy}s — see `AccessorColumnsProvider` in
+* `@platforma-sdk/model`.
+*/
+var AccessorEntriesProvider = class {
+	root;
+	entries;
+	constructor(root, rootPath) {
+		this.root = root;
+		const map = /* @__PURE__ */ new Map();
+		for (const entry of indexAccessorRoot(root, rootPath)) if (!map.has(entry.id)) map.set(entry.id, entry);
+		this.entries = map;
+	}
+	getPObjectEntries() {
+		return this.entries;
+	}
+	isFinal() {
+		return this.root.getInputsLocked();
+	}
+};
+/**
+* Generic entries provider over a list of upstream-block ctx pairs.
+*
+* Per-block merge: iterate `prod` then `staging`, dedupe by name with
+* first-wins semantics (prod takes precedence).
+*
+* `isFinal()` is the AND of `getInputsLocked()` over every present ctx
+* accessor and `!prodIncomplete && !stagingIncomplete` over every block.
+*/
+var ResultPoolEntriesProvider = class {
+	blocks;
+	cachedEntries;
+	constructor(blocks) {
+		this.blocks = blocks;
+	}
+	getPObjectEntries() {
+		if (this.cachedEntries !== void 0) return this.cachedEntries;
+		const map = /* @__PURE__ */ new Map();
+		for (const block of this.blocks) for (const entry of indexPoolBlock(block)) if (!map.has(entry.id)) map.set(entry.id, entry);
+		return this.cachedEntries = map;
+	}
+	isFinal() {
+		for (const block of this.blocks) {
+			if (block.prodIncomplete || block.stagingIncomplete) return false;
+			if (block.prodCtx && !block.prodCtx.getInputsLocked()) return false;
+			if (block.stagingCtx && !block.stagingCtx.getInputsLocked()) return false;
+		}
+		return true;
+	}
+};
+//#endregion
+export { AccessorEntriesProvider, ResultPoolEntriesProvider };
+
+//# sourceMappingURL=providers.js.map

package/dist/columns/providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.js","names":[],"sources":["../../src/columns/providers.ts"],"sourcesContent":["import type { PObjectId } from \"../pool\";\nimport { indexAccessorRoot, indexPoolBlock } from \"./accessor_traversal\";\nimport type { AccessorLike, ColumnEntriesProvider, LeafEntry, UpstreamBlockCtx } from \"./types\";\n\n/**\n * Generic entries provider over a single accessor root. Walks `<root>` once\n * from the supplied `rootPath`, builds an id → {@link LeafEntry} map and\n * exposes `isFinal()` via the root's `getInputsLocked()`.\n *\n * Used directly on the host side; sandbox extends it with `getColumns()`\n * returning {@link ColumnLazy}s — see `AccessorColumnsProvider` in\n * `@platforma-sdk/model`.\n */\nexport class AccessorEntriesProvider<\n  A extends AccessorLike<A>,\n> implements ColumnEntriesProvider<A> {\n  protected readonly entries: ReadonlyMap<PObjectId, LeafEntry<A>>;\n\n  constructor(\n    protected readonly root: A,\n    rootPath: ReadonlyArray<string>,\n  ) {\n    const map = new Map<PObjectId, LeafEntry<A>>();\n    for (const entry of indexAccessorRoot(root, rootPath)) {\n      if (!map.has(entry.id)) map.set(entry.id, entry);\n    }\n    this.entries = map;\n  }\n\n  getPObjectEntries(): ReadonlyMap<PObjectId, LeafEntry<A>> {\n    return this.entries;\n  }\n\n  isFinal(): boolean {\n    return this.root.getInputsLocked();\n  }\n}\n\n/**\n * Generic entries provider over a list of upstream-block ctx pairs.\n *\n * Per-block merge: iterate `prod` then `staging`, dedupe by name with\n * first-wins semantics (prod takes precedence).\n *\n * `isFinal()` is the AND of `getInputsLocked()` over every present ctx\n * accessor and `!prodIncomplete && !stagingIncomplete` over every block.\n */\nexport class ResultPoolEntriesProvider<\n  A extends AccessorLike<A>,\n> implements ColumnEntriesProvider<A> {\n  protected cachedEntries?: ReadonlyMap<PObjectId, LeafEntry<A>>;\n\n  constructor(protected readonly blocks: ReadonlyArray<UpstreamBlockCtx<A>>) {}\n\n  getPObjectEntries(): ReadonlyMap<PObjectId, LeafEntry<A>> {\n    if (this.cachedEntries !== undefined) return this.cachedEntries;\n    const map = new Map<PObjectId, LeafEntry<A>>();\n    for (const block of this.blocks) {\n      for (const entry of indexPoolBlock(block)) {\n        if (!map.has(entry.id)) map.set(entry.id, entry);\n      }\n    }\n    return (this.cachedEntries = map);\n  }\n\n  isFinal(): boolean {\n    for (const block of this.blocks) {\n      if (block.prodIncomplete || block.stagingIncomplete) return false;\n      if (block.prodCtx && !block.prodCtx.getInputsLocked()) return false;\n      if (block.stagingCtx && !block.stagingCtx.getInputsLocked()) return false;\n    }\n    return true;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAaA,IAAa,0BAAb,MAEsC;CAIf;CAHrB;CAEA,YACE,MACA,UACA;EAFmB,KAAA,OAAA;EAGnB,MAAM,sBAAM,IAAI,IAA6B;EAC7C,KAAK,MAAM,SAAS,kBAAkB,MAAM,QAAQ,GAClD,IAAI,CAAC,IAAI,IAAI,MAAM,EAAE,GAAG,IAAI,IAAI,MAAM,IAAI,KAAK;EAEjD,KAAK,UAAU;CACjB;CAEA,oBAA0D;EACxD,OAAO,KAAK;CACd;CAEA,UAAmB;EACjB,OAAO,KAAK,KAAK,gBAAgB;CACnC;AACF;;;;;;;;;;AAWA,IAAa,4BAAb,MAEsC;CAGL;CAF/B;CAEA,YAAY,QAA+D;EAA5C,KAAA,SAAA;CAA6C;CAE5E,oBAA0D;EACxD,IAAI,KAAK,kBAAkB,KAAA,GAAW,OAAO,KAAK;EAClD,MAAM,sBAAM,IAAI,IAA6B;EAC7C,KAAK,MAAM,SAAS,KAAK,QACvB,KAAK,MAAM,SAAS,eAAe,KAAK,GACtC,IAAI,CAAC,IAAI,IAAI,MAAM,EAAE,GAAG,IAAI,IAAI,MAAM,IAAI,KAAK;EAGnD,OAAQ,KAAK,gBAAgB;CAC/B;CAEA,UAAmB;EACjB,KAAK,MAAM,SAAS,KAAK,QAAQ;GAC/B,IAAI,MAAM,kBAAkB,MAAM,mBAAmB,OAAO;GAC5D,IAAI,MAAM,WAAW,CAAC,MAAM,QAAQ,gBAAgB,GAAG,OAAO;GAC9D,IAAI,MAAM,cAAc,CAAC,MAAM,WAAW,gBAAgB,GAAG,OAAO;EACtE;EACA,OAAO;CACT;AACF"}

package/dist/columns/types.d.ts

@@ -0,0 +1,108 @@
+import { Branded } from "../branding.js";
+import { PObjectId } from "../pool/spec.js";
+//#region src/columns/types.d.ts
+/**
+ * Opaque sandbox/host accessor handle.
+ *
+ * Both the sandbox `TreeNodeAccessor.handle` and the host-issued accessor
+ * keys alias this brand — `sdk/model` re-exports the same type so the two
+ * sides stay structurally identical.
+ */
+type AccessorHandle = Branded<string, "AccessorHandle">;
+/**
+ * Structural subset of {@link FieldTraversalStep} (from `@platforma-sdk/model`)
+ * needed by the host/sandbox column-providers traversal.
+ *
+ * Defined locally so this module does not depend on the sandbox `render`
+ * subtree. Both `TreeNodeAccessor.traverse` (sandbox) and
+ * `PlTreeNodeAccessor.traverse` (host) accept a superset of these fields, so
+ * structural compatibility is preserved.
+ */
+interface FieldTraversalStepLike {
+  /** Field name */
+  readonly field: string;
+  /** Asserted field type — used by `accessor.traverse` to validate. */
+  readonly assertFieldType?: "Input" | "Output" | "Service" | "OTW" | "Dynamic" | "MTW";
+  /** Don't terminate chain if current resource or field has an error associated. */
+  readonly ignoreError?: true;
+}
+/**
+ * Raw entry returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx}
+ * on the sandbox side, or by `collectUpstreamBlockCtx` on the host side.
+ * Carries handle ids only — providers wrap them into accessor instances as
+ * needed.
+ *
+ * Generic over the handle type so the same shape backs both:
+ * - sandbox (`AHandle = AccessorHandle`, a `Branded<string, "AccessorHandle">`)
+ * - host (`AHandle = PlTreeNodeAccessor`, the resolved accessor instance)
+ *
+ * Default `AHandle = string` since `AccessorHandle` is a brand on `string` —
+ * the default is safe for the sandbox case.
+ */
+interface UpstreamBlockCtx<AHandle = string> {
+  blockId: string;
+  prodCtx?: AHandle;
+  stagingCtx?: AHandle;
+  /** True when the `prodCtx` ctx-holder exists but `prodUiCtx` is still rendering. */
+  prodIncomplete?: boolean;
+  /** True when the `stagingCtx` ctx-holder exists but `stagingUiCtx` is still rendering. */
+  stagingIncomplete?: boolean;
+}
+/**
+ * Minimal accessor surface used by column-providers / column-registry
+ * traversal.
+ *
+ * Both sandbox `TreeNodeAccessor` and host `PlTreeNodeAccessor` satisfy this
+ * contract directly — `traverse(step)` is defined on both, and the other
+ * members already match by shape. No `resolvePath` member: when canonical
+ * `PObjectId`s are required (local-id construction inside the
+ * outputs/prerun branch), the traversal helpers thread the path explicitly.
+ */
+interface AccessorLike<Self extends AccessorLike<Self>> {
+  /** Resource type carried by the underlying node (only `.name` is used). */
+  readonly resourceType: {
+    readonly name: string;
+  };
+  /**
+   * Single-step field traversal. Returns `undefined` when the field is
+   * absent / unresolved (with `ignoreError`). Same shape on sandbox and host —
+   * sandbox `TreeNodeAccessor.traverse` is an alias for `resolveAny` and host
+   * `PlTreeNodeAccessor.traverse` is the canonical method.
+   */
+  traverse(step: FieldTraversalStepLike): Self | undefined;
+  /** List input-field names on this node. */
+  listInputFields(): string[];
+  /** Whether the input-field collection on this node is finalized. */
+  getInputsLocked(): boolean;
+  /** Whether this node has a data payload attached. */
+  hasData(): boolean;
+  /** Decode the data payload as JSON. Returns `undefined` if no data. */
+  getDataAsJson<T = unknown>(): T | undefined;
+}
+/**
+ * One indexed column — the canonical record produced by every traversal.
+ * Carries everything needed to read spec/data/status under a stable id.
+ *
+ * Generic over the accessor flavour so the same record shape works for both
+ * the sandbox `TreeNodeAccessor` and the host `PlTreeNodeAccessor`.
+ */
+type LeafEntry<A extends AccessorLike<A>> = {
+  /** PFrame accessor that owns `<name>.spec` / `<name>.data` fields. */accessor: A; /** Field-name prefix inside the PFrame. */
+  name: string; /** Canonical id under which this column is reachable. */
+  id: PObjectId;
+};
+/**
+ * Base interface for id-indexed column providers — the surface
+ * {@link ColumnRegistry} consumes. Generic over the concrete accessor flavour
+ * so it can back both sandbox (`TreeNodeAccessor`) and host
+ * (`PlTreeNodeAccessor` adapter) registries.
+ */
+interface ColumnEntriesProvider<A extends AccessorLike<A>> {
+  /** Map of canonical {@link PObjectId} → {@link LeafEntry} for every column reachable from this source. */
+  getPObjectEntries(): ReadonlyMap<PObjectId, LeafEntry<A>>;
+  /** Whether enumeration of columns from this source has finalised. */
+  isFinal(): boolean;
+}
+//#endregion
+export { AccessorHandle, AccessorLike, ColumnEntriesProvider, FieldTraversalStepLike, LeafEntry, UpstreamBlockCtx };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/columns/types.ts"],"mappings":";;;;;;AAUA;;;;KAAY,cAAA,GAAiB,OAAO;AAWpC;;;;;;;;AAMsB;AANtB,UAAiB,sBAAA;EAsBgB;EAAA,SApBtB,KAAA;EAuBW;EAAA,SArBX,eAAA;EAmBT;EAAA,SAjBS,WAAA;AAAA;;;;;;AAuBQ;AAanB;;;;;;;UApBiB,gBAAA;EACf,OAAA;EACA,OAAA,GAAU,OAAA;EACV,UAAA,GAAa,OAAO;EAiBqB;EAfzC,cAAA;EAiBS;EAfT,iBAAA;AAAA;;;;;;;;;;;UAae,YAAA,cAA0B,YAAA,CAAa,IAAA;EAgC5C;EAAA,SA9BD,YAAA;IAAA,SAAyB,IAAA;EAAA;EA8BJ;;;;;;EAtB9B,QAAA,CAAS,IAAA,EAAM,sBAAA,GAAyB,IAAA;EAsBG;EAnB3C,eAAA;EAqBU;EAlBV,eAAA;EAsBA;EAnBA,OAAA;EAmBa;EAhBb,aAAA,iBAA8B,CAAA;AAAA;;;;;;;;KAUpB,SAAA,WAAoB,YAAA,CAAa,CAAA;EAiBX,sEAfhC,QAAA,EAAU,CAAA,EAa2B;EAXrC,IAAA,UAW4D;EAT5D,EAAA,EAAI,SAAA;AAAA;;;;;;AAaG;UAJQ,qBAAA,WAAgC,YAAA,CAAa,CAAA;;EAE5D,iBAAA,IAAqB,WAAA,CAAY,SAAA,EAAW,SAAA,CAAU,CAAA;;EAEtD,OAAA;AAAA"}

package/dist/driver_kit.d.ts

@@ -1,8 +1,7 @@
 import { BlobDriver } from "./drivers/blob.js";
 import { LogsDriver } from "./drivers/log.js";
-import { LsDriver } from "./drivers/ls.js";
 import { PFrameDriver } from "./drivers/pframe/driver.js";
-
+import { LsDriver } from "./drivers/ls.js";
 //#region src/driver_kit.d.ts
 /** Set of all drivers exposed in UI SDK via the platforma object. */
 interface DriverKit {

package/dist/driver_kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"driver_kit.d.ts","names":[],"sources":["../src/driver_kit.ts"],"mappings":";;;;;;;UAGiB,SAAA;;WAEN,UAAA,EAAY,UAAA;;WAGZ,SAAA,EAAW,UAAA;EALL;;;;;;;;EAAA,SAeN,QAAA,EAAU,QAAA;EAbV;EAAA,SAgBA,YAAA,EAAc,YAAA;AAAA"}
+{"version":3,"file":"driver_kit.d.ts","names":[],"sources":["../src/driver_kit.ts"],"mappings":";;;;;;UAGiB,SAAA;;WAEN,UAAA,EAAY,UAAA;;WAGZ,SAAA,EAAW,UAAA;EALL;;;;;;;;EAAA,SAeN,QAAA,EAAU,QAAA;EAbV;EAAA,SAgBA,YAAA,EAAc,YAAA;AAAA"}

package/dist/drivers/columns/columns_collection_driver.d.ts

@@ -0,0 +1,124 @@
+import { Branded } from "../../branding.js";
+import { PoolEntry } from "../../pool_entry.js";
+import { PColumnSpec } from "../pframe/spec/spec.js";
+import { ColumnUniversalId } from "../pframe/spec/ids.js";
+import { PFrameSpecDriver } from "../pframe/spec_driver.js";
+import { ColumnsDiscoverOptions, ColumnsFilterOptions } from "./discover_columns_options.js";
+import { PObjectId } from "../../pool/spec.js";
+import { AccessorHandle, AccessorLike, UpstreamBlockCtx } from "../../columns/types.js";
+
+//#region src/drivers/columns/columns_collection_driver.d.ts
+/**
+ * Opaque host-owned handle for a `ColumnsCollection` instance. Issued by
+ * {@link ColumnsCollectionDriver.create}, refcounted by the driver, and
+ * pinned to the active render ctx via the VM injector — sandbox never
+ * sees raw refcounting.
+ */
+type CollectionHandle = Branded<string, "CollectionHandle">;
+/**
+ * JSON descriptor crossing the VM bridge in place of a sandbox
+ * `ColumnsSource`. Always plain data — no closures, no class instances.
+ *
+ * - `"collection"`  – reference another driver-managed collection by handle
+ *   (chaining, splicing).
+ * - `"result_pool"` – fan-out into the host's current render ctx upstream
+ *   block ctxes. Carries no payload — the host always uses its own pool.
+ * - `"accessor"`    – walk the host tree starting at the given accessor
+ *   handle from a `path` prefix.
+ * - `"ids"`         – pre-resolved id list (sandbox-materialised provider).
+ */
+type SerializedColumnsSource = {
+  readonly kind: "collection";
+  readonly handle: CollectionHandle;
+} | {
+  readonly kind: "result_pool";
+} | {
+  readonly kind: "accessor";
+  readonly accessor: AccessorHandle;
+  readonly path: string[];
+} | {
+  readonly kind: "ids";
+  readonly ids: ColumnUniversalId[];
+  readonly isFinal: boolean;
+};
+/**
+ * Per-call host bindings the driver needs to resolve sources whose
+ * shape references render-ctx state (`"accessor"`, `"result_pool"`).
+ *
+ * The VM injector inside `pl-middle-layer` supplies these on every call;
+ * UI-side direct callers that only build collections out of `"ids"` /
+ * `"collection"` sources may omit the bindings entirely.
+ *
+ * Parameterised on the concrete accessor flavour so host implementations
+ * keep their static types (e.g. `PlTreeNodeAccessor`) without leaking that
+ * dependency into `@milaboratories/pl-model-common`.
+ */
+interface ColumnsCollectionDriverHost<A extends AccessorLike<A> = AccessorLike<any>> {
+  /** Resolve an {@link AccessorHandle} to the host's concrete accessor. */
+  resolveAccessor(handle: AccessorHandle): A;
+  /** Snapshot of upstream-block ctx pairs from the current render ctx. */
+  getUpstreamBlockCtxes(): ReadonlyArray<UpstreamBlockCtx<A>>;
+  /**
+   * Per-call spec driver. The injector supplies the active render ctx's
+   * `PFrameSpec` service; `discover` / `filter` use it to build a spec
+   * frame and run a single discovery query.
+   */
+  getSpecDriver(): PFrameSpecDriver;
+  /**
+   * Resolve the canonical {@link PColumnSpec} for a leaf {@link PObjectId}.
+   * Returns `undefined` when the id is not present in the active registry
+   * (e.g. handed to the driver via a `{kind:"ids"}` source whose underlying
+   * column has since left the visible scope). Override-wrapped ids are
+   * unwrapped by the caller — this method only resolves the underlying leaf.
+   */
+  resolveSpec(id: PObjectId): PColumnSpec | undefined;
+}
+/**
+ * Sandbox / UI view of the `ColumnsCollection` driver. Same methods as
+ * {@link ColumnsCollectionDriver}, but the `host` parameters are dropped —
+ * the VM bridge / UI wrapper supplies them on every call so callers only
+ * pass plain data (handles + source descriptors + option objects).
+ *
+ * `getService("columnsCollection")` returns a value of this shape on both
+ * sandbox and UI sides.
+ */
+interface ColumnsCollectionDriverModel {
+  /** Build a fresh collection from the supplied source descriptors. */
+  create(sources: ReadonlyArray<SerializedColumnsSource>): CollectionHandle;
+  /** Whether the collection currently exposes zero columns. */
+  isEmpty(handle: CollectionHandle): boolean;
+  /** Whether enumeration is finalised across every contributing source. */
+  isFinal(handle: CollectionHandle): boolean;
+  /** Canonical id list for the columns visible through this collection. */
+  getColumns(handle: CollectionHandle): ColumnUniversalId[];
+  /** Append one or more sources and return a fresh collection handle. */
+  addSource(handle: CollectionHandle, sources: ReadonlyArray<SerializedColumnsSource>): CollectionHandle;
+  /** Anchored/selector-driven discovery. Returns a fresh handle. */
+  discover(handle: CollectionHandle, options: ColumnsDiscoverOptions): CollectionHandle;
+  /** Selector-only filter (no anchor traversal). Returns a fresh handle. */
+  filter(handle: CollectionHandle, options: ColumnsFilterOptions): CollectionHandle;
+}
+/**
+ * Synchronous host-side driver for `ColumnsCollection` operations. All
+ * collection state lives on the host side, addressable through opaque
+ * {@link CollectionHandle}s. Every handle-minting method returns a
+ * {@link PoolEntry} so callers can wire the refcount into their own
+ * lifecycle; the VM bridge pins each entry to the active render ctx and
+ * forwards only the handle string to sandbox.
+ *
+ * Sandbox / UI callers consume {@link ColumnsCollectionDriverModel}
+ * instead; the bridge maps that surface onto this one by injecting
+ * {@link ColumnsCollectionDriverHost} bindings.
+ */
+interface ColumnsCollectionDriver {
+  create(sources: ReadonlyArray<SerializedColumnsSource>, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+  isEmpty(handle: CollectionHandle): boolean;
+  isFinal(handle: CollectionHandle): boolean;
+  getColumns(handle: CollectionHandle, host: ColumnsCollectionDriverHost): ColumnUniversalId[];
+  addSource(handle: CollectionHandle, sources: ReadonlyArray<SerializedColumnsSource>, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+  discover(handle: CollectionHandle, options: ColumnsDiscoverOptions, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+  filter(handle: CollectionHandle, options: ColumnsFilterOptions, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+}
+//#endregion
+export { CollectionHandle, ColumnsCollectionDriver, ColumnsCollectionDriverHost, ColumnsCollectionDriverModel, SerializedColumnsSource };
+//# sourceMappingURL=columns_collection_driver.d.ts.map

package/dist/drivers/columns/columns_collection_driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns_collection_driver.d.ts","names":[],"sources":["../../../src/drivers/columns/columns_collection_driver.ts"],"mappings":";;;;;;;;;;;;;AAeA;;;KAAY,gBAAA,GAAmB,OAAO;AAAA;AActC;;;;;;;;;;;AAdsC,KAc1B,uBAAA;EAAA,SACG,IAAA;EAAA,SAA6B,MAAA,EAAQ,gBAAA;AAAA;EAAA,SACrC,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAA2B,QAAA,EAAU,cAAA;EAAA,SAAyB,IAAA;AAAA;EAAA,SAC9D,IAAA;EAAA,SAAsB,GAAA,EAAK,iBAAA;EAAA,SAA8B,OAAA;AAAA;;;;;;;;;;;;;UAcvD,2BAAA,WAAsC,YAAA,CAAa,CAAA,IAAK,YAAA;EAA5B;EAE3C,eAAA,CAAgB,MAAA,EAAQ,cAAA,GAAiB,CAAA;EAFyB;EAKlE,qBAAA,IAAyB,aAAA,CAAc,gBAAA,CAAiB,CAAA;EAHxD;;;;;EAUA,aAAA,IAAiB,gBAAA;EAPsB;;;;;;;EAgBvC,WAAA,CAAY,EAAA,EAAI,SAAA,GAAY,WAAA;AAAA;AAAW;AAYzC;;;;;;;;AAZyC,UAYxB,4BAAA;EAWuB;EATtC,MAAA,CAAO,OAAA,EAAS,aAAA,CAAc,uBAAA,IAA2B,gBAAA;EAchC;EAXzB,OAAA,CAAQ,MAAA,EAAQ,gBAAA;EAYb;EATH,OAAA,CAAQ,MAAA,EAAQ,gBAAA;EAY4B;EAT5C,UAAA,CAAW,MAAA,EAAQ,gBAAA,GAAmB,iBAAA;EAYvB;EATf,SAAA,CACE,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,aAAA,CAAc,uBAAA,IACtB,gBAAA;EAM8D;EAHjE,QAAA,CAAS,MAAA,EAAQ,gBAAA,EAAkB,OAAA,EAAS,sBAAA,GAAyB,gBAAA;EAGY;EAAjF,MAAA,CAAO,MAAA,EAAQ,gBAAA,EAAkB,OAAA,EAAS,oBAAA,GAAuB,gBAAA;AAAA;;;;;;;;;;;;;UAelD,uBAAA;EACf,MAAA,CACE,OAAA,EAAS,aAAA,CAAc,uBAAA,GACvB,IAAA,EAAM,2BAAA,GACL,SAAA,CAAU,gBAAA;EAEb,OAAA,CAAQ,MAAA,EAAQ,gBAAA;EAChB,OAAA,CAAQ,MAAA,EAAQ,gBAAA;EAChB,UAAA,CAAW,MAAA,EAAQ,gBAAA,EAAkB,IAAA,EAAM,2BAAA,GAA8B,iBAAA;EAEzE,SAAA,CACE,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,aAAA,CAAc,uBAAA,GACvB,IAAA,EAAM,2BAAA,GACL,SAAA,CAAU,gBAAA;EAEb,QAAA,CACE,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,sBAAA,EACT,IAAA,EAAM,2BAAA,GACL,SAAA,CAAU,gBAAA;EAEb,MAAA,CACE,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,oBAAA,EACT,IAAA,EAAM,2BAAA,GACL,SAAA,CAAU,gBAAA;AAAA"}