@milaboratories/pl-model-common 1.47.3 → 1.49.0

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

@@ -1 +1 @@
-{"version":3,"file":"column_registry.d.ts","names":[],"sources":["../../src/columns/column_registry.ts"],"mappings":";;;;;;;AAcA;;;;;;;;cAAa,cAAA,WAAyB,YAAA,CAAa,CAAA;EAAA,iBACpB,SAAA;cAAA,SAAA,EAAW,aAAA,CAAc,qBAAA,CAAsB,CAAA;EAO3C;;;;;EAAjC,OAAA,CAAQ,EAAA,EAAI,SAAA,GAAY,SAAA,CAAU,CAAA;;EAKlC,OAAA;EAAA,QAIQ,UAAA;AAAA"}
+{"version":3,"file":"column_registry.d.ts","names":[],"sources":["../../src/columns/column_registry.ts"],"mappings":";;;;;;;;;;;;;;;qBAca,eAAe,UAAU,aAAa;mBACpB;EAA7B,YAA6B,WAAW,cAAc,sBAAsB;;;;;;EAO5E,QAAQ,IAAI,YAAY,UAAU;;EAKlC;UAIQ"}

package/dist/columns/column_selector.d.ts

@@ -1,12 +1,13 @@
 import { AxisValueType, ColumnValueType } from "../drivers/pframe/spec/spec.js";
 import { MultiAxisSelector, MultiColumnSelector, StringMatcher } from "../drivers/pframe/spec_driver.js";
+import "../drivers/pframe/index.js";
 //#region src/columns/column_selector.d.ts
 /** Relaxed string matcher input: plain string, single matcher, or array of mixed. */
-type RelaxedStringMatchers = string | StringMatcher | (string | StringMatcher)[];
+export type RelaxedStringMatchers = string | StringMatcher | (string | StringMatcher)[];
 /** Relaxed record matcher: values can be plain strings or relaxed matchers. */
-type RelaxedRecord = Record<string, RelaxedStringMatchers>;
+export type RelaxedRecord = Record<string, RelaxedStringMatchers>;
 /** Relaxed axis selector — accepts plain strings where strict requires StringMatcher[]. */
-interface RelaxedAxisSelector {
+export interface RelaxedAxisSelector {
   name?: RelaxedStringMatchers;
   type?: AxisValueType | AxisValueType[];
   domain?: RelaxedRecord;
@@ -14,7 +15,7 @@ interface RelaxedAxisSelector {
   annotations?: RelaxedRecord;
 }
 /** Relaxed column selector — convenient hand-written form. */
-interface RelaxedColumnSelector {
+export interface RelaxedColumnSelector {
   name?: RelaxedStringMatchers;
   type?: ColumnValueType | ColumnValueType[];
   domain?: RelaxedRecord;
@@ -24,10 +25,9 @@ interface RelaxedColumnSelector {
   partialAxesMatch?: boolean;
 }
 /** One or many relaxed column selectors; normalizes to MultiColumnSelector[]. */
-type ColumnSelector = RelaxedColumnSelector | RelaxedColumnSelector[];
-declare function convertRelaxedAxisSelectorToMultiAxisSelector(input: RelaxedAxisSelector): MultiAxisSelector;
-declare function convertRelaxedColumnSelectorToMultiColumnSelector(input: RelaxedColumnSelector): MultiColumnSelector;
-declare function convertColumnSelectorToMultiColumnSelector(input: ColumnSelector): MultiColumnSelector[];
+export type ColumnSelector = RelaxedColumnSelector | RelaxedColumnSelector[];
+export declare function convertRelaxedAxisSelectorToMultiAxisSelector(input: RelaxedAxisSelector): MultiAxisSelector;
+export declare function convertRelaxedColumnSelectorToMultiColumnSelector(input: RelaxedColumnSelector): MultiColumnSelector;
+export declare function convertColumnSelectorToMultiColumnSelector(input: ColumnSelector): MultiColumnSelector[];
 //#endregion
-export { ColumnSelector, RelaxedAxisSelector, RelaxedColumnSelector, RelaxedRecord, RelaxedStringMatchers, convertColumnSelectorToMultiColumnSelector, convertRelaxedAxisSelectorToMultiAxisSelector, convertRelaxedColumnSelectorToMultiColumnSelector };
 //# sourceMappingURL=column_selector.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"column_selector.d.ts","names":[],"sources":["../../src/columns/column_selector.ts"],"mappings":";;;;KAaY,qBAAA,YAAiC,aAAA,aAA0B,aAAa;;KAGxE,aAAA,GAAgB,MAAM,SAAS,qBAAA;;UAG1B,mBAAA;EACf,IAAA,GAAO,qBAAA;EACP,IAAA,GAAO,aAAA,GAAgB,aAAA;EACvB,MAAA,GAAS,aAAA;EACT,aAAA,GAAgB,aAAA;EAChB,WAAA,GAAc,aAAA;AAAA;AARgD;AAAA,UAY/C,qBAAA;EACf,IAAA,GAAO,qBAAA;EACP,IAAA,GAAO,eAAA,GAAkB,eAAA;EACzB,MAAA,GAAS,aAAA;EACT,aAAA,GAAgB,aAAA;EAChB,WAAA,GAAc,aAAA;EACd,IAAA,GAAO,mBAAA;EACP,gBAAA;AAAA;;KAIU,cAAA,GAAiB,qBAAA,GAAwB,qBAAqB;AAAA,iBA0B1D,6CAAA,CACd,KAAA,EAAO,mBAAA,GACN,iBAAiB;AAAA,iBAWJ,iDAAA,CACd,KAAA,EAAO,qBAAA,GACN,mBAAmB;AAAA,iBAcN,0CAAA,CACd,KAAA,EAAO,cAAA,GACN,mBAAmB"}
+{"version":3,"file":"column_selector.d.ts","names":[],"sources":["../../src/columns/column_selector.ts"],"mappings":";;;;;YAaY,iCAAiC,0BAA0B;;YAG3D,gBAAgB,eAAe;;iBAG1B;EACf,OAAO;EACP,OAAO,gBAAgB;EACvB,SAAS;EACT,gBAAgB;EAChB,cAAc;;;iBAIC;EACf,OAAO;EACP,OAAO,kBAAkB;EACzB,SAAS;EACT,gBAAgB;EAChB,cAAc;EACd,OAAO;EACP;;;YAIU,iBAAiB,wBAAwB;wBA0BrC,8CACd,OAAO,sBACN;wBAWa,kDACd,OAAO,wBACN;wBAca,2CACd,OAAO,iBACN"}

package/dist/columns/dedup.cjs

@@ -18,7 +18,7 @@ const require_native_id = require("../drivers/pframe/spec/native_id.cjs");
 *
 * 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
+* dedup semantics, but operate on different concrete item types (DataColumnRecipe
 * vs. raw ColumnUniversalId).
 */
 function dedupColumns(items, getId, getSpec) {

package/dist/columns/dedup.cjs.map

@@ -1 +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"}
+{"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 (DataColumnRecipe\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

@@ -1,6 +1,5 @@
 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`:
@@ -18,10 +17,9 @@ import { ColumnUniversalId } from "../drivers/pframe/spec/ids.js";
  *
  * 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
+ * dedup semantics, but operate on different concrete item types (DataColumnRecipe
  * vs. raw ColumnUniversalId).
  */
-declare function dedupColumns<T>(items: ReadonlyArray<T>, getId: (item: T) => ColumnUniversalId, getSpec: (item: T) => PColumnSpec | undefined): T[];
+export 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

@@ -1 +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"}
+{"version":3,"file":"dedup.d.ts","names":[],"sources":["../../src/columns/dedup.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;wBAyBgB,aAAa,GAC3B,OAAO,cAAc,IACrB,QAAQ,MAAM,MAAM,mBACpB,UAAU,MAAM,MAAM,0BACrB"}

package/dist/columns/dedup.js

@@ -18,7 +18,7 @@ import { deriveNativeId } from "../drivers/pframe/spec/native_id.js";
 *
 * 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
+* dedup semantics, but operate on different concrete item types (DataColumnRecipe
 * vs. raw ColumnUniversalId).
 */
 function dedupColumns(items, getId, getSpec) {

package/dist/columns/dedup.js.map

@@ -1 +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"}
+{"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 (DataColumnRecipe\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/providers.cjs

@@ -6,7 +6,7 @@ const require_accessor_traversal = require("./accessor_traversal.cjs");
 * 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
+* returning {@link DataColumnRecipe}s — see `AccessorColumnsProvider` in
 * `@platforma-sdk/model`.
 */
 var AccessorEntriesProvider = class {

package/dist/columns/providers.cjs.map

@@ -1 +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"}
+{"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 DataColumnRecipe}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

@@ -1,6 +1,6 @@
 import { PObjectId } from "../pool/spec.js";
+import "../pool/index.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
@@ -8,10 +8,10 @@ import { AccessorLike, ColumnEntriesProvider, LeafEntry, UpstreamBlockCtx } from
  * 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
+ * returning {@link DataColumnRecipe}s — see `AccessorColumnsProvider` in
  * `@platforma-sdk/model`.
  */
-declare class AccessorEntriesProvider<A extends AccessorLike<A>> implements ColumnEntriesProvider<A> {
+export 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>);
@@ -27,7 +27,7 @@ declare class AccessorEntriesProvider<A extends AccessorLike<A>> implements Colu
  * `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> {
+export 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>>);
@@ -35,5 +35,4 @@ declare class ResultPoolEntriesProvider<A extends AccessorLike<A>> implements Co
   isFinal(): boolean;
 }
 //#endregion
-export { AccessorEntriesProvider, ResultPoolEntriesProvider };
 //# sourceMappingURL=providers.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"providers.d.ts","names":[],"sources":["../../src/columns/providers.ts"],"mappings":";;;;;;;;;;;;;qBAaa,wBACX,UAAU,aAAa,eACZ,sBAAsB;qBAIZ,MAAM;qBAHR,SAAS,YAAY,WAAW,UAAU;EAE7D,YACqB,MAAM,GACzB,UAAU;EASZ,qBAAqB,YAAY,WAAW,UAAU;EAItD;;;;;;;;;;;qBAcW,0BACX,UAAU,aAAa,eACZ,sBAAsB;qBAGF,QAAQ,cAAc,iBAAiB;YAF5D,gBAAgB,YAAY,WAAW,UAAU;EAE3D,YAA+B,QAAQ,cAAc,iBAAiB;EAEtE,qBAAqB,YAAY,WAAW,UAAU;EAWtD"}

package/dist/columns/providers.js

@@ -6,7 +6,7 @@ import { indexAccessorRoot, indexPoolBlock } from "./accessor_traversal.js";
 * 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
+* returning {@link DataColumnRecipe}s — see `AccessorColumnsProvider` in
 * `@platforma-sdk/model`.
 */
 var AccessorEntriesProvider = class {

package/dist/columns/providers.js.map

@@ -1 +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"}
+{"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 DataColumnRecipe}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

@@ -1,5 +1,6 @@
 import { Branded } from "../branding.js";
 import { PObjectId } from "../pool/spec.js";
+import "../pool/index.js";
 //#region src/columns/types.d.ts
 /**
  * Opaque sandbox/host accessor handle.
@@ -8,7 +9,7 @@ import { PObjectId } from "../pool/spec.js";
  * keys alias this brand — `sdk/model` re-exports the same type so the two
  * sides stay structurally identical.
  */
-type AccessorHandle = Branded<string, "AccessorHandle">;
+export type AccessorHandle = Branded<string, "AccessorHandle">;
 /**
  * Structural subset of {@link FieldTraversalStep} (from `@platforma-sdk/model`)
  * needed by the host/sandbox column-providers traversal.
@@ -18,7 +19,7 @@ type AccessorHandle = Branded<string, "AccessorHandle">;
  * `PlTreeNodeAccessor.traverse` (host) accept a superset of these fields, so
  * structural compatibility is preserved.
  */
-interface FieldTraversalStepLike {
+export interface FieldTraversalStepLike {
   /** Field name */
   readonly field: string;
   /** Asserted field type — used by `accessor.traverse` to validate. */
@@ -39,7 +40,7 @@ interface FieldTraversalStepLike {
  * Default `AHandle = string` since `AccessorHandle` is a brand on `string` —
  * the default is safe for the sandbox case.
  */
-interface UpstreamBlockCtx<AHandle = string> {
+export interface UpstreamBlockCtx<AHandle = string> {
   blockId: string;
   prodCtx?: AHandle;
   stagingCtx?: AHandle;
@@ -58,7 +59,7 @@ interface UpstreamBlockCtx<AHandle = string> {
  * `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>> {
+export interface AccessorLike<Self extends AccessorLike<Self>> {
   /** Resource type carried by the underlying node (only `.name` is used). */
   readonly resourceType: {
     readonly name: string;
@@ -86,9 +87,12 @@ interface AccessorLike<Self extends AccessorLike<Self>> {
  * 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. */
+export 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;
 };
 /**
@@ -97,12 +101,11 @@ type LeafEntry<A extends AccessorLike<A>> = {
  * so it can back both sandbox (`TreeNodeAccessor`) and host
  * (`PlTreeNodeAccessor` adapter) registries.
  */
-interface ColumnEntriesProvider<A extends AccessorLike<A>> {
+export 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

@@ -1 +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"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/columns/types.ts"],"mappings":";;;;;;;;;;;YAUY,iBAAiB;;;;;;;;;;iBAWZ;;WAEN;;WAEA;;WAEA;;;;;;;;;;;;;;;iBAgBM,iBAAiB;EAChC;EACA,UAAU;EACV,aAAa;;EAEb;;EAEA;;;;;;;;;;;;iBAae,aAAa,aAAa,aAAa;;WAE7C;aAAyB;;;;;;;;EAQlC,SAAS,MAAM,yBAAyB;;EAGxC;;EAGA;;EAGA;;EAGA,cAAc,gBAAgB;;;;;;;;;YAUpB,UAAU,UAAU,aAAa;;EAE3C,UAAU;;EAEV;;EAEA,IAAI;;;;;;;;iBASW,sBAAsB,UAAU,aAAa;;EAE5D,qBAAqB,YAAY,WAAW,UAAU;;EAEtD"}

package/dist/common_types.d.ts

@@ -1,9 +1,8 @@
 import { ErrorLike } from "@milaboratories/pl-error-like";
-
 //#region src/common_types.d.ts
 /** Use this as constraint instead of `Function` */
-type AnyFunction = (...args: any[]) => any;
-type OutputWithStatus<T> = {
+export type AnyFunction = (...args: any[]) => any;
+export type OutputWithStatus<T> = {
   ok: true;
   value: T;
   stable: boolean;
@@ -13,13 +12,12 @@ type OutputWithStatus<T> = {
   moreErrors: boolean;
 };
 /** Base type for block outputs */
-type BlockOutputsBase = Record<string, OutputWithStatus<unknown>>;
-type ListOptionBase<T = unknown> = {
+export type BlockOutputsBase = Record<string, OutputWithStatus<unknown>>;
+export type ListOptionBase<T = unknown> = {
   label: string;
   description?: string;
   value: T;
   group?: string;
 };
 //#endregion
-export { AnyFunction, BlockOutputsBase, ListOptionBase, OutputWithStatus };
 //# sourceMappingURL=common_types.d.ts.map

package/dist/common_types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common_types.d.ts","names":[],"sources":["../src/common_types.ts"],"mappings":";;;;KAGY,WAAA,OAAkB,IAAI;AAAA,KAEtB,gBAAA;EACN,EAAA;EAAU,KAAA,EAAO,CAAA;EAAG,MAAA;AAAA;EACpB,EAAA;EAAW,MAAA,EAAQ,SAAS;EAAI,UAAA;AAAA;;KAG1B,gBAAA,GAAmB,MAAM,SAAS,gBAAA;AAAA,KAElC,cAAA;EACV,KAAA;EACA,WAAA;EACA,KAAA,EAAO,CAAC;EACR,KAAA;AAAA"}
+{"version":3,"file":"common_types.d.ts","names":[],"sources":["../src/common_types.ts"],"mappings":";;;YAGY,kBAAkB;YAElB,iBAAiB;EACvB;EAAU,OAAO;EAAG;;EACpB;EAAW,QAAQ;EAAa;;;YAG1B,mBAAmB,eAAe;YAElC,eAAe;EACzB;EACA;EACA,OAAO;EACP"}

package/dist/dialog/index.d.ts

@@ -3,7 +3,7 @@
  * File filter passed to the native save dialog. Matches Electron's
  * `FileFilter` shape so desktop runtimes can forward it verbatim.
  */
-interface FileFilter {
+export interface FileFilter {
   name: string;
   extensions: string[];
 }
@@ -12,13 +12,13 @@ interface FileFilter {
  * default file name; the main-process handler decides the default
  * directory (e.g. `~/Downloads`).
  */
-interface ShowSaveDialogOptions {
+export interface ShowSaveDialogOptions {
   defaultFileName?: string;
   filters?: FileFilter[];
   title?: string;
 }
 /** Result of `Dialog.showSaveDialog`. */
-interface ShowSaveDialogResult {
+export interface ShowSaveDialogResult {
   canceled: boolean;
   path?: string;
 }
@@ -26,9 +26,8 @@ interface ShowSaveDialogResult {
  * UI-facing save-dialog service. Implemented by desktop runtimes that
  * can open a native file picker; absent in web/preview environments.
  */
-interface DialogService {
+export interface DialogService {
   showSaveDialog(options: ShowSaveDialogOptions): Promise<ShowSaveDialogResult>;
 }
 //#endregion
-export { DialogService, FileFilter, ShowSaveDialogOptions, ShowSaveDialogResult };
 //# sourceMappingURL=index.d.ts.map

package/dist/dialog/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/dialog/index.ts"],"mappings":";;AAIA;;;UAAiB,UAAA;EACf,IAAA;EACA,UAAU;AAAA;;;;;;UAQK,qBAAA;EACf,eAAA;EACA,OAAA,GAAU,UAAU;EACpB,KAAA;AAAA;;UAIe,oBAAA;EACf,QAAA;EACA,IAAI;AAAA;;;;;UAOW,aAAA;EACf,cAAA,CAAe,OAAA,EAAS,qBAAA,GAAwB,OAAA,CAAQ,oBAAA;AAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/dialog/index.ts"],"mappings":";;;;;iBAIiB;EACf;EACA;;;;;;;iBAQe;EACf;EACA,UAAU;EACV;;;iBAIe;EACf;EACA;;;;;;iBAOe;EACf,eAAe,SAAS,wBAAwB,QAAQ"}

package/dist/driver_kit.d.ts

@@ -2,9 +2,10 @@ import { BlobDriver } from "./drivers/blob.js";
 import { LogsDriver } from "./drivers/log.js";
 import { PFrameDriver } from "./drivers/pframe/driver.js";
 import { LsDriver } from "./drivers/ls.js";
+import "./drivers/index.js";
 //#region src/driver_kit.d.ts
 /** Set of all drivers exposed in UI SDK via the platforma object. */
-interface DriverKit {
+export interface DriverKit {
   /** Driver allowing to retrieve blob data */
   readonly blobDriver: BlobDriver;
   /** Driver allowing to dynamically work with logs */
@@ -22,5 +23,4 @@ interface DriverKit {
   readonly pFrameDriver: PFrameDriver;
 }
 //#endregion
-export { DriverKit };
 //# sourceMappingURL=driver_kit.d.ts.map

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":";;;;;;;iBAGiB;;WAEN,YAAY;;WAGZ,WAAW;;;;;;;;;WAUX,UAAU;;WAGV,cAAc"}

package/dist/drivers/ChunkedStreamReader.d.ts

@@ -1,5 +1,4 @@
 import { RangeBytes } from "./blob.js";
-
 //#region src/drivers/ChunkedStreamReader.d.ts
 /**
  * Status returned by onError handler to indicate what action to take
@@ -7,11 +6,11 @@ import { RangeBytes } from "./blob.js";
  * - 'error': Error the stream (calls controller.error, aborts ongoing fetches)
  * - 'cancel': Cancel the stream gracefully (calls controller.close, aborts ongoing fetches)
  */
-type ErrorHandlerStatus = "continue" | "error" | "cancel";
+export type ErrorHandlerStatus = "continue" | "error" | "cancel";
 /**
  * Options for creating a ChunkedStreamReader
  */
-interface ChunkedStreamReaderOptions {
+export interface ChunkedStreamReaderOptions {
   /**
    * Function to fetch a chunk of data. Optionally accepts an AbortSignal to cancel the fetch.
    */
@@ -39,7 +38,7 @@ interface ChunkedStreamReaderOptions {
  * in fixed-size chunks. This is useful for streaming large files without loading
  * them entirely into memory.
  */
-declare class ChunkedStreamReader {
+export declare class ChunkedStreamReader {
   private currentPosition;
   private _read;
   private _canceled;
@@ -117,5 +116,4 @@ declare class ChunkedStreamReader {
   isComplete(): boolean;
 }
 //#endregion
-export { ChunkedStreamReader, ChunkedStreamReaderOptions, ErrorHandlerStatus };
 //# sourceMappingURL=ChunkedStreamReader.d.ts.map

package/dist/drivers/ChunkedStreamReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChunkedStreamReader.d.ts","names":[],"sources":["../../src/drivers/ChunkedStreamReader.ts"],"mappings":";;;;;AAQA;;;;KAAY,kBAAA;AAKZ;;;AAAA,UAAiB,0BAAA;EAI0B;;;EAAzC,UAAA,GAAa,KAAA,EAAO,UAAA,EAAY,MAAA,GAAS,WAAA,KAAgB,OAAA,CAAQ,UAAA;EAoBnC;;;EAf9B,SAAA;EALoB;;;EAUpB,SAAA;EAVyD;;;;;;;;EAoBzD,OAAA,IAAW,KAAA,cAAmB,OAAA,CAAQ,kBAAA;AAAA;AAQxC;;;;;AAAA,cAAa,mBAAA;EAAA,QACH,eAAA;EAAA,QACA,KAAA;EAAA,QACA,SAAA;EAAA,QACA,QAAA;EAAA,QACA,eAAA;EAAA,iBACS,OAAA;EADT;;;;EAAA,QAOD,WAAA;EAsCK;;;EAAA,YAdA,UAAA;EA2CE;;;EAAA,YApCF,SAAA;EA6CJ;;;EAAA,YAtCI,SAAA;EAoKZ;;;EAAA,YA7JY,OAAA;;;;;;;;;;;;;;;;;;;SAsBL,MAAA,CAAO,OAAA,EAAS,0BAAA,GAA6B,cAAA,CAAe,UAAA;EAAA,QAK3D,SAAA;EAAA,QAIA,QAAA;EAAA,QAIM,OAAA;;;;;;;;UAsEN,YAAA;;;;;;EA2CR,kBAAA;;;;;;EASA,iBAAA;;;;;;EASA,UAAA;AAAA"}
+{"version":3,"file":"ChunkedStreamReader.d.ts","names":[],"sources":["../../src/drivers/ChunkedStreamReader.ts"],"mappings":";;;;;;;;YAQY;;;;iBAKK;;;;EAIf,aAAa,OAAO,YAAY,SAAS,gBAAgB,QAAQ;;;;EAKjE;;;;EAKA;;;;;;;;;EAUA,WAAW,mBAAmB,QAAQ;;;;;;;qBAQ3B;UACH;UACA;UACA;UACA;UACA;mBACS;;;;;UAMV;;;;cAwBK;;;;cAOA;;;;cAOA;;;;cAOA;;;;;;;;;;;;;;;;;;;SAsBL,OAAO,SAAS,6BAA6B,eAAe;UAK3D;UAIA;UAIM;;;;;;;;UAsEN;;;;;;EA2CR;;;;;;EASA;;;;;;EASA"}

package/dist/drivers/blob.d.ts

@@ -1,24 +1,25 @@
 import { Branded } from "../branding.js";
 import { z } from "zod";
-
 //#region src/drivers/blob.d.ts
 /** Handle of locally downloaded blob. This handle is issued only after the
  * blob's content is downloaded locally, and ready for quick access. */
-type LocalBlobHandle = Branded<string, "LocalBlobHandle">;
+export type LocalBlobHandle = Branded<string, "LocalBlobHandle">;
 /** Handle of remote blob. This handle is issued as soon as the data becomes
  * available on the remote server. */
-type RemoteBlobHandle = Branded<string, "RemoteBlobHandle">;
+export type RemoteBlobHandle = Branded<string, "RemoteBlobHandle">;
 /** Being configured inside the output structure provides information about
  * blob's content and means to retrieve it when needed. */
-interface BlobHandleAndSize<H extends LocalBlobHandle | RemoteBlobHandle = LocalBlobHandle | RemoteBlobHandle> {
+export interface BlobHandleAndSize<H extends LocalBlobHandle | RemoteBlobHandle = LocalBlobHandle | RemoteBlobHandle> {
   /** Handle to retrieve block content using {@link BlobDriver.getContent()} */
   readonly handle: H;
   /** Blob size in bytes. */
   readonly size: number;
 }
 /** Range in bytes, from should be less than to. */
-declare const RangeBytes: z.ZodObject<{
-  /** Included left border. */from: z.ZodNumber; /** Excluded right border. */
+export declare const RangeBytes: z.ZodObject<{
+  /** Included left border. */
+  from: z.ZodNumber;
+  /** Excluded right border. */
   to: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
   from: number;
@@ -27,25 +28,27 @@ declare const RangeBytes: z.ZodObject<{
   from: number;
   to: number;
 }>;
-type RangeBytes = z.infer<typeof RangeBytes>;
-declare function newRangeBytesOpt(from?: number, to?: number): RangeBytes | undefined;
-declare function validateRangeBytes(range: RangeBytes, errMsg: string): void;
+export type RangeBytes = z.infer<typeof RangeBytes>;
+export declare function newRangeBytesOpt(from?: number, to?: number): RangeBytes | undefined;
+export declare function validateRangeBytes(range: RangeBytes, errMsg: string): void;
 /** Being configured inside the output structure provides information about
  * locally downloaded blob and means to retrieve it's content when needed. This
  * structure is created only after the blob's content is downloaded locally, and
  * ready for quick access. */
-type LocalBlobHandleAndSize = BlobHandleAndSize<LocalBlobHandle>;
+export type LocalBlobHandleAndSize = BlobHandleAndSize<LocalBlobHandle>;
 /** Being configured inside the output structure provides information about
  * remote blob and means to retrieve it's content when needed. This structure
  * is created as soon as remote blob becomes available. */
-type RemoteBlobHandleAndSize = BlobHandleAndSize<RemoteBlobHandle>;
-type GetContentOptions = {
-  /** Byte range in [from, to) format. */range?: RangeBytes; /** Signal to abort the operation early. */
+export type RemoteBlobHandleAndSize = BlobHandleAndSize<RemoteBlobHandle>;
+export type GetContentOptions = {
+  /** Byte range in [from, to) format. */
+  range?: RangeBytes;
+  /** Signal to abort the operation early. */
   signal?: AbortSignal;
 };
-type ContentHandler<T> = (content: ReadableStream, size: number) => Promise<T>;
+export type ContentHandler<T> = (content: ReadableStream, size: number) => Promise<T>;
 /** Defines API of blob driver as it is seen from the block UI code. */
-interface BlobDriver {
+export interface BlobDriver {
   /**
    * Given the blob handle returns its content.
    * Depending on the handle type, content will be served from locally downloaded file,
@@ -56,17 +59,25 @@ interface BlobDriver {
 /**
  * Operational metrics of the blob download driver.
  */
-type BlobDriverMetrics = {
-  /** Downloads that bypassed the ranges (sparse) cache. Counted when issued, so failed downloads still count. */uncachedRequests: number; /** Bytes actually streamed off the wire on the uncached path. */
-  uncachedRequestBytes: number; /** Currently active remote downloads. */
-  downloadsInFlight: number; /** Sum of known sizes of active downloads — progress-bar denominator. */
-  inFlightBytesTotal: number; /** Sum of bytes received so far across active downloads — progress-bar numerator. */
-  inFlightBytesReceived: number; /** Cached presigned URL was used and the download started successfully (one gRPC sign call avoided). */
-  presignedUrlCacheHits: number; /** No cached presigned URL; a fresh one was fetched. */
-  presignedUrlCacheMisses: number; /** Cached presigned URL was rejected (HTTP 400) and re-fetched — signals the TTL safety margin is too loose. */
-  presignedUrlStaleHits: number; /** Total latency of presigned-URL fetch calls (misses + stale hits); divide by their count for the mean cost a hit avoids. */
+export type BlobDriverMetrics = {
+  /** Downloads that bypassed the ranges (sparse) cache. Counted when issued, so failed downloads still count. */
+  uncachedRequests: number;
+  /** Bytes actually streamed off the wire on the uncached path. */
+  uncachedRequestBytes: number;
+  /** Currently active remote downloads. */
+  downloadsInFlight: number;
+  /** Sum of known sizes of active downloads — progress-bar denominator. */
+  inFlightBytesTotal: number;
+  /** Sum of bytes received so far across active downloads — progress-bar numerator. */
+  inFlightBytesReceived: number;
+  /** Cached presigned URL was used and the download started successfully (one gRPC sign call avoided). */
+  presignedUrlCacheHits: number;
+  /** No cached presigned URL; a fresh one was fetched. */
+  presignedUrlCacheMisses: number;
+  /** Cached presigned URL was rejected (HTTP 400) and re-fetched — signals the TTL safety margin is too loose. */
+  presignedUrlStaleHits: number;
+  /** Total latency of presigned-URL fetch calls (misses + stale hits); divide by their count for the mean cost a hit avoids. */
   presignedUrlRequestSumLatencyMs: number;
 };
 //#endregion
-export { BlobDriver, BlobDriverMetrics, BlobHandleAndSize, ContentHandler, GetContentOptions, LocalBlobHandle, LocalBlobHandleAndSize, RangeBytes, RemoteBlobHandle, RemoteBlobHandleAndSize, newRangeBytesOpt, validateRangeBytes };
 //# sourceMappingURL=blob.d.ts.map

package/dist/drivers/blob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blob.d.ts","names":[],"sources":["../../src/drivers/blob.ts"],"mappings":";;;;;;KAKY,eAAA,GAAkB,OAAO;;;KAIzB,gBAAA,GAAmB,OAAO;AAJD;AAIrC;AAJqC,UAQpB,iBAAA,WACL,eAAA,GAAkB,gBAAA,GAAmB,eAAA,GAAkB,gBAAA;;WAGxD,MAAA,EAAQ,CAAA;EARmB;EAAA,SAW3B,IAAA;AAAA;;cAIE,UAAA,EAAU,CAAA,CAAA,SAAA;EAVO,+CAAqC;;;;;;;;;KAiBvD,UAAA,GAAa,CAAA,CAAE,KAAK,QAAQ,UAAA;AAAA,iBAExB,gBAAA,CAAiB,IAAA,WAAe,EAAA,YAAc,UAAU;AAAA,iBAWxD,kBAAA,CAAmB,KAAA,EAAO,UAAU,EAAE,MAAA;;AAxBvC;AAIf;;KA8BY,sBAAA,GAAyB,iBAAiB,CAAC,eAAA;;;;KAK3C,uBAAA,GAA0B,iBAAiB,CAAC,gBAAA;AAAA,KAE5C,iBAAA;EArCW,uCAuCrB,KAAA,GAAQ,UAAA,EAvCa;EAyCrB,MAAA,GAAS,WAAW;AAAA;AAAA,KAGV,cAAA,OAAqB,OAAA,EAAS,cAAA,EAAgB,IAAA,aAAiB,OAAA,CAAQ,CAAA;;UAGlE,UAAA;;;;;;EAMf,UAAA,CAAW,MAAA,EAAQ,eAAA,GAAkB,gBAAA,EAAkB,KAAA,GAAQ,UAAA,GAAa,OAAA,CAAQ,UAAA;AAAA;;;AA9CtF;KAoDY,iBAAA;iHAEV,gBAAA,UAtDuB;EAwDvB,oBAAA,UAxDsC;EA0DtC,iBAAA,UA1DgD;EA4DhD,kBAAA,UA1D8B;EA4D9B,qBAAA,UA5DsE;EA8DtE,qBAAA,UA9D8C;EAgE9C,uBAAA,UAhEsE;EAkEtE,qBAAA,UAvDc;EAyDd,+BAAA;AAAA"}
+{"version":3,"file":"blob.d.ts","names":[],"sources":["../../src/drivers/blob.ts"],"mappings":";;;;;YAKY,kBAAkB;;;YAIlB,mBAAmB;;;iBAId,kBACf,UAAU,kBAAkB,mBAAmB,kBAAkB;;WAGxD,QAAQ;;WAGR;;;qBAIE,YAAU,EAAA;;;;;;;;;;;;YAOX,aAAa,EAAE,aAAa;wBAExB,iBAAiB,eAAe,cAAc;wBAW9C,mBAAmB,OAAO,YAAY;;;;;YAU1C,yBAAyB,kBAAkB;;;;YAK3C,0BAA0B,kBAAkB;YAE5C;;EAEV,QAAQ;;EAER,SAAS;;YAGC,eAAe,MAAM,SAAS,gBAAgB,iBAAiB,QAAQ;;iBAGlE;;;;;;EAMf,WAAW,QAAQ,kBAAkB,kBAAkB,QAAQ,aAAa,QAAQ;;;;;YAM1E;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA"}