@platforma-sdk/model 1.82.0 → 1.83.9

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

@@ -5,9 +5,8 @@ import { ColumnDiscoveredRecipe } from "./column_discovered_recipe.js";
 import { ColumnFilteredRecipe } from "./column_filtered_recipe.js";
 import { ColumnOverriddenRecipe } from "./column_overrided_recipe.js";
 import { ColumnUniversalId } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column_recipes/index.d.ts
-interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> extends ColumnRecipe$1<ID> {}
+export interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> extends ColumnRecipe$1<ID> {}
 /**
  * Build a `ColumnRecipe` from a stringified id. Dispatches to the matching
  * concrete recipe variant based on the id's encoding and recurses on
@@ -37,9 +36,9 @@ declare function ColumnRecipeBuild(id: ColumnUniversalId, opts?: {
 declare function ColumnRecipeGetStatus(id: ColumnUniversalId, opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): ColumnResolutionStatus;
-declare const ColumnRecipe: typeof ColumnRecipeBuild & {
+export declare const ColumnRecipe: typeof ColumnRecipeBuild & {
   readonly getStatus: typeof ColumnRecipeGetStatus;
 };
 //#endregion
-export { ColumnDiscoveredRecipe, ColumnFilteredRecipe, ColumnOverriddenRecipe, ColumnRecipe, type ColumnRecipeId, type SpecQuery$1 as SpecQuery };
+export { ColumnDiscoveredRecipe, ColumnFilteredRecipe, ColumnOverriddenRecipe, type ColumnRecipeId, type SpecQuery$1 as SpecQuery };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/columns/column_recipes/index.ts"],"mappings":";;;;;;;;;UA+BiB,YAAA,YACJ,cAAA,GAAiB,cAAA,UACpB,cAAA,CAAiB,EAAA;;;;;;;;;;;;;;;AAAE;AAAI;iBAkBxB,iBAAA,CACP,EAAA,EAAI,iBAAA,EACJ,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,gBACD,YAAA;;;;;;;;iBAyCN,qBAAA,CACP,EAAA,EAAI,iBAAA,EACJ,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,IACb,sBAAA;AAAA,cASU,YAAA,SAAqB,iBAAA;EAAA,SACvB,SAAA,SAAkB,qBAAqB;AAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/columns/column_recipes/index.ts"],"mappings":";;;;;;;;iBA+BiB,aACf,WAAW,iBAAiB,wBACpB,eAAiB;;;;;;;;;;;;;;;;;iBAkBlB,kBACP,IAAI,mBACJ;EAAQ,MAAM;gBACD;;;;;;;;iBAyCN,sBACP,IAAI,mBACJ;EAAQ,MAAM;IACb;qBASU,qBAAqB;WACvB,kBAAkB"}

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

@@ -1,5 +1,4 @@
 import { ColumnUniversalId, PColumnSpec, PObjectId, SpecOverrides, SpecQuery as SpecQuery$1 } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column_recipes/types.d.ts
 /**
  * Stable identifier of a recipe: either the canonical {@link PObjectId} of a
@@ -9,7 +8,7 @@ import { ColumnUniversalId, PColumnSpec, PObjectId, SpecOverrides, SpecQuery as
  * Recipes are equivalent as value-objects iff their `id`s match (structurally,
  * after canonicalization).
  */
-type ColumnRecipeId = ColumnUniversalId;
+export type ColumnRecipeId = ColumnUniversalId;
 /**
  * Aggregate data status of a recipe: the "worst" status across every
  * PObjectId the recipe references (the leaf itself plus any refs inside
@@ -18,7 +17,7 @@ type ColumnRecipeId = ColumnUniversalId;
  * "All or nothing" semantics: spec/query built from a recipe are meaningful
  * only when every referenced column is `present`.
  */
-type ColumnFieldStatus = "resolving" | "absent" | "present";
+export type ColumnFieldStatus = "resolving" | "absent" | "present";
 /**
  * Resolution status of a recipe — whether the recipe is meaningful in the
  * active render ctx. Aggregates spec readiness (the recipe can be
@@ -34,7 +33,7 @@ type ColumnFieldStatus = "resolving" | "absent" | "present";
  * status only. {@link ColumnResolutionStatus} also folds in spec/registry
  * readiness, so the recipe interface exposes both.
  */
-type ColumnResolutionStatus = "present" | "resolving" | "absent";
+export type ColumnResolutionStatus = "present" | "resolving" | "absent";
 /**
  * Base contract of a column recipe — an immutable description of HOW to
  * obtain a column, not the column itself.
@@ -55,7 +54,7 @@ type ColumnResolutionStatus = "present" | "resolving" | "absent";
  * Consumers that need to decompose call utilities from `pl-model-common`
  * over `recipe.id`.
  */
-interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> {
+export interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> {
   /** Canonical recipe identifier. */
   readonly id: ID;
   /** PObjectIds referenced by this recipe (leaf + any nested refs). */
@@ -97,5 +96,5 @@ interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> {
   withSpecs(overrides: SpecOverrides): ColumnRecipe;
 }
 //#endregion
-export { ColumnFieldStatus, ColumnRecipe, ColumnRecipeId, ColumnResolutionStatus, type SpecQuery$1 as SpecQuery };
+export type { SpecQuery$1 as SpecQuery };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/columns/column_recipes/types.ts"],"mappings":";;;;AAkBA;;;;AAA8C;AAU9C;;KAVY,cAAA,GAAiB,iBAAiB;;AAUjB;AAiB7B;;;;AAAkC;AAsBlC;KAvCY,iBAAA;;;;;;;;;;;;;;;;KAiBA,sBAAA;;;;;;;;;;;;;;;AAkEuC;;;;;;UA5ClC,YAAA,YAAwB,cAAA,GAAiB,cAAA;;WAE/C,EAAA,EAAI,EAAA;;EAGb,gBAAA,IAAoB,SAAA;;;;;;;;;;EAWpB,OAAA,IAAW,WAAA;;;;;;;;;;EAWX,QAAA,IAAY,WAAA;;;;;;;EAQZ,aAAA,IAAiB,iBAAA;;;;;;;;EASjB,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,YAAA;AAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/columns/column_recipes/types.ts"],"mappings":";;;;;;;;;;YAkBY,iBAAiB;;;;;;;;;YAUjB;;;;;;;;;;;;;;;;YAiBA;;;;;;;;;;;;;;;;;;;;;iBAsBK,aAAa,WAAW,iBAAiB;;WAE/C,IAAI;;EAGb,oBAAoB;;;;;;;;;;EAWpB,WAAW;;;;;;;;;;EAWX,YAAY;;;;;;;EAQZ,iBAAiB;;;;;;;;EASjB,UAAU,WAAW,gBAAgB"}

package/dist/columns/columns_collection.d.ts

@@ -1,10 +1,10 @@
 import { GlobalCfgRenderCtx } from "../render/internal.js";
 import { ColumnRecipe } from "./column_recipes/index.js";
 import { ColumnsSource } from "./column_providers/types.js";
+import "./column_providers/index.js";
 import { CollectionHandle, ColumnUniversalId, ColumnsCollectionDriverModel, ColumnsDiscoverOptions, ColumnsFilterOptions } from "@milaboratories/pl-model-common";
-
 //#region src/columns/columns_collection.d.ts
-interface ColumnsCollectionDeps {
+export interface ColumnsCollectionDeps {
   /** Render ctx used both for service resolution and for default ctx sources. */
   readonly ctx?: GlobalCfgRenderCtx;
   /** Override the resolved `columnsCollection` service — primarily for tests. */
@@ -18,7 +18,7 @@ interface ColumnsCollectionDeps {
  * - `"current_block"` – main outputs + prerun (staging) accessors of the
  *   current block, when present.
  */
-type ColumnsSourceShorthand = "result_pool" | "current_block";
+export type ColumnsSourceShorthand = "result_pool" | "current_block";
 /**
  * Build a {@link ColumnsCollection} from sandbox-side source descriptors.
  * Resolves the `columnsCollection` driver (either from `deps.driver` or via
@@ -29,8 +29,8 @@ type ColumnsSourceShorthand = "result_pool" | "current_block";
  * `sources` accepts {@link ColumnsSourceShorthand} string literals
  * (`"result_pool"`, `"current_block"`) for the common ctx-derived sources.
  */
-declare function ColumnsCollection(sources?: (ColumnsCollection | ColumnsSource | ColumnsSourceShorthand)[], deps?: ColumnsCollectionDeps): ColumnsCollection;
-declare function isColumnsCollection(value: unknown): value is ColumnsCollection;
+export declare function ColumnsCollection(sources?: (ColumnsCollection | ColumnsSource | ColumnsSourceShorthand)[], deps?: ColumnsCollectionDeps): ColumnsCollection;
+export declare function isColumnsCollection(value: unknown): value is ColumnsCollection;
 /**
  * Sandbox proxy over the host-side `ColumnsCollection` driver. The driver
  * owns all column-set state; this object only carries an opaque
@@ -45,7 +45,7 @@ declare function isColumnsCollection(value: unknown): value is ColumnsCollection
  * host — the host VM bridge pins it to the active render ctx, so the sandbox
  * never has to manage refcounts.
  */
-declare class ColumnsCollectionImpl {
+export declare class ColumnsCollectionImpl {
   readonly handle: CollectionHandle;
   private readonly driver;
   constructor(handle: CollectionHandle, driver: ColumnsCollectionDriverModel);
@@ -58,7 +58,6 @@ declare class ColumnsCollectionImpl {
   filter(options: ColumnsFilterOptions): ColumnsCollection;
 }
 /** Public type alias — value of the same name is the factory function above. */
-type ColumnsCollection = ColumnsCollectionImpl;
+export type ColumnsCollection = ColumnsCollectionImpl;
 //#endregion
-export { ColumnsCollection, ColumnsCollectionDeps, ColumnsCollectionImpl, ColumnsSourceShorthand, isColumnsCollection };
 //# sourceMappingURL=columns_collection.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"columns_collection.d.ts","names":[],"sources":["../../src/columns/columns_collection.ts"],"mappings":";;;;;;UAkBiB,qBAAA;;WAEN,GAAA,GAAM,kBAAA;EAFA;EAAA,SAIN,MAAA,GAAS,4BAA4B;AAAA;;;;;;;AAAA;AAWhD;KAAY,sBAAA;;;AAAsB;AAYlC;;;;;;;iBAAgB,iBAAA,CACd,OAAA,IAAW,iBAAA,GAAoB,aAAA,GAAgB,sBAAA,KAC/C,IAAA,GAAO,qBAAA,GACN,iBAAA;AAAA,iBAQa,mBAAA,CAAoB,KAAA,YAAiB,KAAA,IAAS,iBAAiB;;;;;;;;;;AAR3D;AAQpB;;;;cAkBa,qBAAA;EAAA,SAEO,MAAA,EAAQ,gBAAA;EAAA,iBACP,MAAA;cADD,MAAA,EAAQ,gBAAA,EACP,MAAA,EAAQ,4BAAA;EAG3B,OAAA;EAIA,OAAA;EAIA,YAAA,IAAgB,iBAAA;EAIhB,UAAA,IAAc,YAAA;EAMd,SAAA,CAAU,MAAA,EAAQ,aAAA,GAAgB,iBAAA,GAAoB,iBAAA;EAOtD,QAAA,CAAS,OAAA,EAAS,sBAAA,GAAyB,iBAAA;EAI3C,MAAA,CAAO,OAAA,EAAS,oBAAA,GAAuB,iBAAA;AAAA;;KAM7B,iBAAA,GAAoB,qBAAqB"}
+{"version":3,"file":"columns_collection.d.ts","names":[],"sources":["../../src/columns/columns_collection.ts"],"mappings":";;;;;;iBAkBiB;;WAEN,MAAM;;WAEN,SAAS;;;;;;;;;;YAWR;;;;;;;;;;;wBAYI,kBACd,WAAW,oBAAoB,gBAAgB,2BAC/C,OAAO,wBACN;wBAQa,oBAAoB,iBAAiB,SAAS;;;;;;;;;;;;;;;qBAkBjD;WAEO,QAAQ;mBACP;EAFnB,YACkB,QAAQ,kBACP,QAAQ;EAG3B;EAIA;EAIA,gBAAgB;EAIhB,cAAc;EAMd,UAAU,QAAQ,gBAAgB,oBAAoB;EAOtD,SAAS,SAAS,yBAAyB;EAI3C,OAAO,SAAS,uBAAuB;;;YAM7B,oBAAoB"}

package/dist/columns/data_column.d.ts

@@ -1,11 +1,11 @@
 import { GlobalCfgRenderCtx, PColumnDataUniversal } from "../render/internal.js";
 import { TreeNodeAccessor } from "../render/accessor.js";
+import "../render/index.js";
 import { ColumnFieldStatus, ColumnRecipe, ColumnRecipeId, ColumnResolutionStatus } from "./column_recipes/types.js";
 import { ColumnUniversalId, LeafEntry, PColumn, PColumnSpec, PObjectId, PlRef, SpecOverrides, SpecQuery } from "@milaboratories/pl-model-common";
-
 //#region src/columns/data_column.d.ts
-type DataColumnId = PObjectId;
-type ColumnData = undefined | PColumnDataUniversal;
+export type DataColumnId = PObjectId;
+export type ColumnData = undefined | PColumnDataUniversal;
 /**
  * A {@link ColumnRecipe} that can be read directly in the sandbox: its
  * {@link getData} is guaranteed to be consistent with {@link getSpec}.
@@ -21,7 +21,7 @@ type ColumnData = undefined | PColumnDataUniversal;
  * class — which recipe classes exist is an implementation detail behind
  * `recipe.id`.
  */
-interface DataColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> extends ColumnRecipe<ID> {
+export interface DataColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> extends ColumnRecipe<ID> {
   /** Column data, consistent with {@link ColumnRecipe.getSpec}. */
   getData(): ColumnData;
 }
@@ -36,7 +36,7 @@ interface DataColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> extends C
  * when partial absence should be surfaced to the user rather than silently
  * producing an empty result.
  */
-declare class ColumnAbsentError extends Error {
+export declare class ColumnAbsentError extends Error {
   readonly id: ColumnUniversalId;
   constructor(id: ColumnUniversalId);
 }
@@ -49,7 +49,7 @@ declare class ColumnAbsentError extends Error {
  * Internal — consumers hold the {@link DataColumnRecipe} interface and construct
  * through the {@link DataColumnRecipe} dispatcher.
  */
-declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
+export declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
   readonly id: PObjectId;
   private readonly options;
   private specCache?;
@@ -76,9 +76,7 @@ declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
    * and the column did not appear — the column will not exist in this ctx.
    * Data and dataStatus stay lazy.
    */
-  static fromId(id: PObjectId, {
-    ctx
-  }?: {
+  static fromId(id: PObjectId, { ctx }?: {
     ctx?: GlobalCfgRenderCtx;
   }): undefined | DataColumnRecipe<PObjectId>;
   /** {@link PlRef} wrapper over {@link fromId}. */
@@ -100,9 +98,7 @@ declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
    * when the id has no entry — only then we can say `absent` instead of
    * `resolving`.
    */
-  static getStatusById(id: PObjectId, {
-    ctx
-  }?: {
+  static getStatusById(id: PObjectId, { ctx }?: {
     ctx?: GlobalCfgRenderCtx;
   }): ColumnResolutionStatus;
   /** {@link PlRef} wrapper over {@link getStatusById}. */
@@ -113,7 +109,7 @@ declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
   static getStatusByAccessor(entry: LeafEntry<TreeNodeAccessor>): ColumnResolutionStatus;
 }
 /** Anything the {@link DataColumnRecipe} dispatcher can build a leaf from. */
-type DataColumnSource = PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnData> | DataColumnRecipe<PObjectId>;
+export type DataColumnSource = PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnData> | DataColumnRecipe<PObjectId>;
 /**
  * Unified dispatcher — picks the right `DataColumnImpl.fromX` by source
  * shape. For ambiguous inputs callers can still use the explicit factories
@@ -132,7 +128,7 @@ declare function DataColumnDispatch(source: DataColumnSource, opts?: {
 declare function DataColumnGetStatus(source: DataColumnSource, opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): ColumnResolutionStatus;
-declare const DataColumn: typeof DataColumnDispatch & {
+export declare const DataColumn: typeof DataColumnDispatch & {
   fromId: typeof DataColumnImpl.fromId;
   fromPlRef: typeof DataColumnImpl.fromPlRef;
   fromAccessor: typeof DataColumnImpl.fromAccessor;
@@ -146,7 +142,7 @@ declare const DataColumn: typeof DataColumnDispatch & {
  * Type-guard narrowing to a bare leaf — a {@link DataColumnRecipe} whose `id` is a
  * plain {@link PObjectId}.
  */
-declare function isDataColumn(value: unknown): value is DataColumnRecipe<PObjectId>;
+export declare function isDataColumn(value: unknown): value is DataColumnRecipe<PObjectId>;
 //#endregion
-export { ColumnAbsentError, ColumnData, type ColumnFieldStatus, type ColumnResolutionStatus, DataColumn, DataColumnId, DataColumnImpl, DataColumnRecipe, DataColumnSource, isDataColumn };
+export type { ColumnFieldStatus, ColumnResolutionStatus };
 //# sourceMappingURL=data_column.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"data_column.d.ts","names":[],"sources":["../../src/columns/data_column.ts"],"mappings":";;;;;;KA2BY,YAAA,GAAe,SAAS;AAAA,KACxB,UAAA,eAAyB,oBAAoB;AADzD;;;;AAAoC;AACpC;;;;AAAyD;AAkBzD;;;;;AAnBA,UAmBiB,gBAAA,YACJ,cAAA,GAAiB,cAAA,UACpB,YAAA,CAAa,EAAA;EAEV;EAAX,OAAA,IAAW,UAAA;AAAA;;;;;;;;;;AAAU;AAcvB;cAAa,iBAAA,SAA0B,KAAA;EAAA,SACT,EAAA,EAAI,iBAAA;cAAJ,EAAA,EAAI,iBAAA;AAAA;;;;;;;;;;cAerB,cAAA,YAA0B,gBAAA,CAAiB,SAAA;EAAA,SAMpC,EAAA,EAAI,SAAA;EAAA,iBACH,OAAA;EAAA,QANX,SAAA;EAAA,QACA,SAAA;EAAA,QACA,eAAA;EAAA,QAED,WAAA;EAUa;EAApB,gBAAA,IAAoB,SAAA;EAIpB,OAAA,IAAW,WAAA;EAYA;EAJX,QAAA,IAAY,SAAA;EAIZ,OAAA,IAAW,UAAA;EAKX,aAAA,IAAiB,iBAAA;EAwBX;;;;;EAZN,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,YAAA;EAmCsB;;;;;;;EAAA,OAxBpD,MAAA,CACL,EAAA,EAAI,SAAA;IACF;EAAA;IAAS,GAAA,GAAM,kBAAA;EAAA,gBACJ,gBAAA,CAAiB,SAAA;EAkDZ;EAAA,OA7Bb,SAAA,CAAU,GAAA,EAAK,KAAA,eAAoB,gBAAA,CAAiB,SAAA;EAkDrD;;;;;EAAA,OAzCC,YAAA,CAAa,KAAA,EAAO,SAAA,CAAU,gBAAA,gBAAgC,gBAAA,CAAiB,SAAA;EAsDnF;;;;EAAA,OApCI,UAAA,CACL,MAAA,EAAQ,OAAA,CAAQ,UAAA,IAAc,gBAAA,CAAiB,SAAA,IAC9C,gBAAA,CAAiB,SAAA;EAhHiC;;;;;;EAAA,OAoI9C,aAAA,CACL,EAAA,EAAI,SAAA;IACF;EAAA;IAAS,GAAA,GAAM,kBAAA;EAAA,IAChB,sBAAA;EApIK;EAAA,OA4ID,gBAAA,CACL,GAAA,EAAK,KAAA,EACL,IAAA;IAAQ,GAAA,GAAM,kBAAA;EAAA,IACb,sBAAA;EA/HH;EAAA,OAoIO,mBAAA,CAAoB,KAAA,EAAO,SAAA,CAAU,gBAAA,IAAoB,sBAAA;AAAA;;KAMtD,gBAAA,GACR,SAAA,GACA,KAAA,GACA,SAAA,CAAU,gBAAA,IACV,OAAA,CAAQ,UAAA,IACR,gBAAA,CAAiB,SAAA;;;;;;;iBAQZ,kBAAA,CACP,MAAA,EAAQ,gBAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,gBACD,gBAAA,CAAiB,SAAA;;;;;;;iBAkBvB,mBAAA,CACP,MAAA,EAAQ,gBAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,IACb,sBAAA;AAAA,cAUU,UAAA,SAAU,kBAAA;;;;;;;;;;;;;;iBAeP,YAAA,CAAa,KAAA,YAAiB,KAAA,IAAS,gBAAgB,CAAC,SAAA"}
+{"version":3,"file":"data_column.d.ts","names":[],"sources":["../../src/columns/data_column.ts"],"mappings":";;;;;;YA2BY,eAAe;YACf,yBAAyB;;;;;;;;;;;;;;;;iBAkBpB,iBACf,WAAW,iBAAiB,wBACpB,aAAa;;EAErB,WAAW;;;;;;;;;;;;;qBAcA,0BAA0B;WACT,IAAI;EAAhC,YAA4B,IAAI;;;;;;;;;;;qBAerB,0BAA0B,iBAAiB;WAMpC,IAAI;mBACH;UANX;UACA;UACA;UAED;;EAUP,oBAAoB;EAIpB,WAAW;;EAQX,YAAY;EAIZ,WAAW;EAKX,iBAAiB;;;;;;EAYjB,UAAU,WAAW,gBAAgB;;;;;;;;SAW9B,OACL,IAAI,aACF;IAAS,MAAM;kBACJ,iBAAiB;;SAqBzB,UAAU,KAAK,oBAAoB,iBAAiB;;;;;;SASpD,aAAa,OAAO,UAAU,gCAAgC,iBAAiB;;;;;SAkB/E,WACL,QAAQ,QAAQ,cAAc,iBAAiB,aAC9C,iBAAiB;;;;;;;SAoBb,cACL,IAAI,aACF;IAAS,MAAM;MAChB;;SAQI,iBACL,KAAK,OACL;IAAQ,MAAM;MACb;;SAKI,oBAAoB,OAAO,UAAU,oBAAoB;;;YAMtD,mBACR,YACA,QACA,UAAU,oBACV,QAAQ,cACR,iBAAiB;;;;;;;iBAQZ,mBACP,QAAQ,kBACR;EAAQ,MAAM;gBACD,iBAAiB;;;;;;;iBAkBvB,oBACP,QAAQ,kBACR;EAAQ,MAAM;IACb;qBAUU,mBAAU;;;;;;;;;;;;;;wBAeP,aAAa,iBAAiB,SAAS,iBAAiB"}

package/dist/columns/derive_axis_values_labels.d.ts

@@ -1,8 +1,8 @@
 import { GlobalCfgRenderCtx } from "../render/internal.js";
 import { ColumnsSource } from "./column_providers/types.js";
+import "./column_providers/index.js";
 import { ColumnsCollection } from "./columns_collection.js";
 import { AxisId } from "@milaboratories/pl-model-common";
-
 //#region src/columns/derive_axis_values_labels.d.ts
 /**
  * Build an `axisValuesLabels` callback by discovering `pl7.app/label` columns
@@ -22,9 +22,8 @@ import { AxisId } from "@milaboratories/pl-model-common";
  *  - label columns whose data resource type isn't `PColumnData/Json` /
  *    `PColumnData/JsonPartitioned`.
  */
-declare function deriveAxisValuesLabels(source?: ColumnsCollection | (ColumnsCollection | ColumnsSource)[], opts?: {
+export declare function deriveAxisValuesLabels(source?: ColumnsCollection | (ColumnsCollection | ColumnsSource)[], opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): (axisId: AxisId) => Record<string | number, string> | undefined;
 //#endregion
-export { deriveAxisValuesLabels };
 //# sourceMappingURL=derive_axis_values_labels.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"derive_axis_values_labels.d.ts","names":[],"sources":["../../src/columns/derive_axis_values_labels.ts"],"mappings":";;;;;;;;;AA6BA;;;;;;;;;;;;;;;iBAAgB,sBAAA,CACd,MAAA,GAAS,iBAAA,IAAqB,iBAAA,GAAoB,aAAA,KAClD,IAAA;EAAS,GAAA,GAAM,kBAAA;AAAA,KACb,MAAA,EAAQ,MAAA,KAAW,MAAA"}
+{"version":3,"file":"derive_axis_values_labels.d.ts","names":[],"sources":["../../src/columns/derive_axis_values_labels.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;wBA6BgB,uBACd,SAAS,qBAAqB,oBAAoB,kBAClD;EAAS,MAAM;KACb,QAAQ,WAAW"}

package/dist/columns/split_by_axes.d.ts

@@ -1,13 +1,12 @@
 import { Column } from "./column.js";
 import { ColumnRecipe } from "./column_recipes/index.js";
 import { AxisId } from "@milaboratories/pl-model-common";
-
 //#region src/columns/split_by_axes.d.ts
-interface SplitAxis {
+export interface SplitAxis {
   /** Index of the axis in the column's axesSpec to split by. */
   readonly idx: number;
 }
-interface SplitByAxesOpts {
+export interface SplitByAxesOpts {
   /**
    * Resolve axis values to human-readable labels.
    *
@@ -41,7 +40,6 @@ interface SplitByAxesOpts {
  * Returns `undefined` when any input's `getData()` is not a
  * {@link TreeNodeAccessor} — partition inspection is not yet possible.
  */
-declare function splitByAxes(inputs: Column[], splitAxes: SplitAxis[], opts?: SplitByAxesOpts): ColumnRecipe[] | undefined;
+export declare function splitByAxes(inputs: Column[], splitAxes: SplitAxis[], opts?: SplitByAxesOpts): ColumnRecipe[] | undefined;
 //#endregion
-export { SplitAxis, SplitByAxesOpts, splitByAxes };
 //# sourceMappingURL=split_by_axes.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"split_by_axes.d.ts","names":[],"sources":["../../src/columns/split_by_axes.ts"],"mappings":";;;;;UAwBiB,SAAA;;WAEN,GAAG;AAAA;AAAA,UAGG,eAAA;EAHH;AAAA;AAGd;;;;;;EASE,gBAAA,IAAoB,MAAA,EAAQ,MAAA,iBAAuB,MAAM;AAAA;;AAAA;AA8B3D;;;;;;;;;;;;;;;;;AAIe;;;;iBAJC,WAAA,CACd,MAAA,EAAQ,MAAA,IACR,SAAA,EAAW,SAAA,IACX,IAAA,GAAO,eAAA,GACN,YAAA"}
+{"version":3,"file":"split_by_axes.d.ts","names":[],"sources":["../../src/columns/split_by_axes.ts"],"mappings":";;;;iBAwBiB;;WAEN;;iBAGM;;;;;;;;;EASf,oBAAoB,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BrC,YACd,QAAQ,UACR,WAAW,aACX,OAAO,kBACN"}

package/dist/columns/utils.d.ts

@@ -5,7 +5,6 @@ import { DataColumnRecipe } from "./data_column.js";
 import { ColumnsSource } from "./column_providers/types.js";
 import { ColumnsCollection } from "./columns_collection.js";
 import { AxisQualification, ColumnUniversalId, PObjectId } from "@milaboratories/pl-model-common";
-
 //#region src/columns/utils.d.ts
 /**
  * PObjectIds of every non-hit column referenced by `recipe.getQuery()`,
@@ -16,13 +15,13 @@ import { AxisQualification, ColumnUniversalId, PObjectId } from "@milaboratories
  * Pure query walk — no registry access. Use {@link collectLinkerColumns} for
  * the resolved {@link DataColumnRecipe} variant.
  */
-declare function collectLinkerIds(recipe: ColumnRecipe): PObjectId[];
+export declare function collectLinkerIds(recipe: ColumnRecipe): PObjectId[];
 /**
  * {@link collectLinkerIds} resolved against the ambient context as
  * {@link DataColumnRecipe} leaves. Throws if any id fails to resolve —
  * matches the contract of the legacy `resolveLinkers` it replaces.
  */
-declare function collectLinkerColumns(recipe: ColumnRecipe, opts?: {
+export declare function collectLinkerColumns(recipe: ColumnRecipe, opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): DataColumnRecipe<PObjectId>[];
 /**
@@ -33,7 +32,7 @@ declare function collectLinkerColumns(recipe: ColumnRecipe, opts?: {
  * `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise
  * returns `[]`. Pure recipe walk — no query-tree introspection.
  */
-declare function hitQualifications(recipe: ColumnRecipe): readonly AxisQualification[];
+export declare function hitQualifications(recipe: ColumnRecipe): readonly AxisQualification[];
 /**
  * Per-primary-column axis qualifications for the recipe — applied to the
  * outer primary anchors on this recipe's group side. Keyed by the external
@@ -41,7 +40,7 @@ declare function hitQualifications(recipe: ColumnRecipe): readonly AxisQualifica
  *
  * Same walk strategy as {@link hitQualifications}.
  */
-declare function queriesQualifications(recipe: ColumnRecipe): Readonly<Record<PObjectId, AxisQualification[]>>;
+export declare function queriesQualifications(recipe: ColumnRecipe): Readonly<Record<PObjectId, AxisQualification[]>>;
 /**
  * Whether the recipe's underlying data resources actually carry bytes —
  * strictly stronger than `getDataStatus() === "present"`, which only tells
@@ -56,7 +55,7 @@ declare function queriesQualifications(recipe: ColumnRecipe): Readonly<Record<PO
  * "not yet ready") rather than throwing — this is a UI-facing predicate, not
  * a contract assertion.
  */
-declare function hasColumnData(recipe: ColumnRecipe, opts?: {
+export declare function hasColumnData(recipe: ColumnRecipe, opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): boolean;
 /**
@@ -78,13 +77,13 @@ declare function hasColumnData(recipe: ColumnRecipe, opts?: {
  * through the whole wrapper chain, so no class walk is involved and foreign
  * `ColumnRecipe` implementations are handled too.
  */
-declare function hasSingleDataColumn(recipe: ColumnRecipe): boolean;
+export declare function hasSingleDataColumn(recipe: ColumnRecipe): boolean;
 /**
  * @deprecated Renamed to {@link hasSingleDataColumn} — "leaf" read as "you can
  * get data out of it", which is a different question (see
  * {@link hasReachableData}). Same semantics.
  */
-declare const isLeafColumn: typeof hasSingleDataColumn;
+export declare const isLeafColumn: typeof hasSingleDataColumn;
 /**
  * Whether the column's data can be read here and now, consistent with its
  * spec — narrows to {@link DataColumnRecipe}, which exposes `getData()`.
@@ -101,9 +100,9 @@ declare const isLeafColumn: typeof hasSingleDataColumn;
  * result narrows to a value that really has the method, and there is no
  * throwing path behind the guard.
  */
-declare function hasReachableData(recipe: ColumnRecipe): recipe is DataColumnRecipe;
+export declare function hasReachableData(recipe: ColumnRecipe): recipe is DataColumnRecipe;
 /** Drop-down option built over a {@link ColumnsCollection} — universal-id valued. */
-type ColumnOption = {
+export type ColumnOption = {
   readonly id: ColumnUniversalId;
   readonly label: string;
 };
@@ -115,7 +114,6 @@ type ColumnOption = {
  * accessor, column array, or `"result_pool"` / `"current_block"` shorthand)
  * to be wrapped on the fly.
  */
-declare function deriveColumnOptions(source: ColumnsCollection | ColumnsSource[], labelOptions?: DeriveLabelsOptions): ColumnOption[];
+export declare function deriveColumnOptions(source: ColumnsCollection | ColumnsSource[], labelOptions?: DeriveLabelsOptions): ColumnOption[];
 //#endregion
-export { ColumnOption, collectLinkerColumns, collectLinkerIds, deriveColumnOptions, hasColumnData, hasReachableData, hasSingleDataColumn, hitQualifications, isLeafColumn, queriesQualifications };
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/columns/utils.ts"],"mappings":";;;;;;;;;;;AAiCA;;;;;;;iBAAgB,gBAAA,CAAiB,MAAA,EAAQ,YAAA,GAAe,SAAS;AAAA;AAsBjE;;;;AAtBiE,iBAsBjD,oBAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,IACb,gBAAA,CAAiB,SAAA;;;;;;;;;iBAgBJ,iBAAA,CAAkB,MAAA,EAAQ,YAAA,YAAwB,iBAAiB;;AAhBtD;AAgB7B;;;;;iBAYgB,qBAAA,CACd,MAAA,EAAQ,YAAA,GACP,QAAA,CAAS,MAAA,CAAO,SAAA,EAAW,iBAAA;;;AAdqD;AAYnF;;;;;;;;;;;iBAqBgB,aAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAkB;AAAA;;;;AArBa;AAmB/C;;;;;;;;;;AAEyC;AAiEzC;;;;iBAAgB,mBAAA,CAAoB,MAAoB,EAAZ,YAAY;AASxD;;;;AAA+C;AAA/C,cAAa,YAAA,SAAY,mBAAsB;;;;;;;;;AAkBmC;AAKlF;;;;;;;iBALgB,gBAAA,CAAiB,MAAA,EAAQ,YAAA,GAAe,MAAA,IAAU,gBAAgB;AAOlE;AAAA,KAFJ,YAAA;EAAA,SACD,EAAA,EAAI,iBAAiB;EAAA,SACrB,KAAA;AAAA;;;;;;;;;iBAWK,mBAAA,CACd,MAAA,EAAQ,iBAAA,GAAoB,aAAA,IAC5B,YAAA,GAAc,mBAAA,GACb,YAAA"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/columns/utils.ts"],"mappings":";;;;;;;;;;;;;;;;;wBAiCgB,iBAAiB,QAAQ,eAAe;;;;;;wBAsBxC,qBACd,QAAQ,cACR;EAAQ,MAAM;IACb,iBAAiB;;;;;;;;;wBAgBJ,kBAAkB,QAAQ,wBAAwB;;;;;;;;wBAYlD,sBACd,QAAQ,eACP,SAAS,OAAO,WAAW;;;;;;;;;;;;;;;wBAmBd,cACd,QAAQ,cACR;EAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;wBAiEA,oBAAoB,QAAQ;;;;;;qBAS/B,qBAAY;;;;;;;;;;;;;;;;;wBAkBT,iBAAiB,QAAQ,eAAe,UAAU;;YAKtD;WACD,IAAI;WACJ;;;;;;;;;;wBAWK,oBACd,QAAQ,oBAAoB,iBAC5B,eAAc,sBACb"}

package/dist/components/PFrameForGraphs.d.ts

@@ -1,11 +1,11 @@
 import { PColumnDataUniversal } from "../render/internal.js";
 import { RenderCtxBase } from "../render/api.js";
+import "../render/index.js";
 import { AxesVault, enrichCompatible, getAvailableWithLinkersAxes } from "../pframe_utils/axes.js";
 import { PColumn, PColumnSpec, PFrameHandle } from "@milaboratories/pl-model-common";
-
 //#region src/components/PFrameForGraphs.d.ts
-declare function isHiddenFromGraphColumn(column: PColumnSpec): boolean;
-declare function isHiddenFromUIColumn(column: PColumnSpec): boolean;
+export declare function isHiddenFromGraphColumn(column: PColumnSpec): boolean;
+export declare function isHiddenFromUIColumn(column: PColumnSpec): boolean;
 /**
  The aim of createPFrameForGraphs: to create pframe with block’s columns and all compatible columns from result pool
  (including linker columns and all label columns).
@@ -18,7 +18,7 @@ declare function isHiddenFromUIColumn(column: PColumnSpec): boolean;
  of partially matched axis we add to pframe a copy of this column with modified axis (with filled missed domains)
  and modified label (with added domain values in case if more than one copy with different domains exist).
  */
-declare function createPFrameForGraphs<A, U>(ctx: RenderCtxBase<A, U>, blockColumns?: PColumn<undefined | PColumnDataUniversal>[]): PFrameHandle | undefined;
+export declare function createPFrameForGraphs<A, U>(ctx: RenderCtxBase<A, U>, blockColumns?: PColumn<undefined | PColumnDataUniversal>[]): PFrameHandle | undefined;
 //#endregion
-export { type AxesVault, createPFrameForGraphs, enrichCompatible, getAvailableWithLinkersAxes, isHiddenFromGraphColumn, isHiddenFromUIColumn };
+export { type AxesVault, enrichCompatible, getAvailableWithLinkersAxes };
 //# sourceMappingURL=PFrameForGraphs.d.ts.map

package/dist/components/PFrameForGraphs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PFrameForGraphs.d.ts","names":[],"sources":["../../src/components/PFrameForGraphs.ts"],"mappings":";;;;;;iBAOgB,uBAAA,CAAwB,MAAmB,EAAX,WAAW;AAAA,iBAI3C,oBAAA,CAAqB,MAAmB,EAAX,WAAW;;AAJxD;;;;AAA2D;AAI3D;;;;AAAwD;AAgBxD;iBAAgB,qBAAA,OACd,GAAA,EAAK,aAAA,CAAc,CAAA,EAAG,CAAA,GACtB,YAAA,GAAe,OAAA,aAAoB,oBAAA,MAClC,YAAA"}
+{"version":3,"file":"PFrameForGraphs.d.ts","names":[],"sources":["../../src/components/PFrameForGraphs.ts"],"mappings":";;;;;;wBAOgB,wBAAwB,QAAQ;wBAIhC,qBAAqB,QAAQ;;;;;;;;;;;;;wBAgB7B,sBAAsB,GAAG,GACvC,KAAK,cAAc,GAAG,IACtB,eAAe,oBAAoB,0BAClC"}