@platforma-sdk/model 1.82.0 → 1.83.9

package/dist/block_model.js

@@ -4,12 +4,12 @@ import { BlockStorageFacadeCallbacks, BlockStorageFacadeHandles, registerFacadeC
 import { BLOCK_SERVICE_FLAGS } from "./services/block_services.js";
 import { BlockRenderCtx, PluginRenderCtx } from "./render/api.js";
 import "./render/index.js";
+import { CREATE_PLUGIN_MODEL } from "./plugin_model.js";
 import { PlatformaSDKVersion } from "./version.js";
+import { applyStorageUpdate, createInitialStorage, createInitialStorageFromParams, deriveArgsFromStorage, derivePrerunArgsFromStorage, deriveTemplateParamsFromStorage, getStorageDebugView, migrateStorage, validateTemplateParamsJson } from "./block_storage_callbacks.js";
 import { isConfigLambda } from "./bconfig/types.js";
 import { downgradeCfgOrLambda } from "./bconfig/normalization.js";
 import "./bconfig/index.js";
-import { CREATE_PLUGIN_MODEL } from "./plugin_model.js";
-import { applyStorageUpdate, createInitialStorage, createInitialStorageFromParams, deriveArgsFromStorage, derivePrerunArgsFromStorage, deriveTemplateParamsFromStorage, getStorageDebugView, migrateStorage, validateTemplateParamsJson } from "./block_storage_callbacks.js";
 import { REQUIRES_PFRAMES_VERSION, formatKindRef } from "@milaboratories/pl-model-common";
 //#region src/block_model.ts
 /**

package/dist/block_state_patch.d.ts

@@ -1,15 +1,15 @@
 import { BlockOutputsBase, BlockState } from "@milaboratories/pl-model-common";
-
 //#region src/block_state_patch.d.ts
 /** Patch for the structural object */
-type Patch<K, V> = {
-  /** Field name to patch */readonly key: K; /** New value for the field */
+export type Patch<K, V> = {
+  /** Field name to patch */
+  readonly key: K;
+  /** New value for the field */
   readonly value: V;
 };
 /** Creates union type of all possible shallow patches for the given structure */
-type Unionize<T extends Record<string, unknown>> = { [K in keyof T]: Patch<K, T[K]> }[keyof T];
+export type Unionize<T extends Record<string, unknown>> = { [K in keyof T]: Patch<K, T[K]>; }[keyof T];
 /** Patch for the BlockState, pushed by onStateUpdates method in SDK. */
-type BlockStatePatch<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = Unionize<BlockState<Args, Outputs, UiState, Href>>;
+export type BlockStatePatch<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = Unionize<BlockState<Args, Outputs, UiState, Href>>;
 //#endregion
-export { BlockStatePatch, Patch, Unionize };
 //# sourceMappingURL=block_state_patch.d.ts.map

package/dist/block_state_patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_state_patch.d.ts","names":[],"sources":["../src/block_state_patch.ts"],"mappings":";;;;KAGY,KAAA;EAAA,mCAED,GAAA,EAAK,CAAA,EAFC;EAAA,SAIN,KAAA,EAAO,CAAC;AAAA;;KAIP,QAAA,WAAmB,MAAA,mCACjB,CAAA,GAAI,KAAA,CAAM,CAAA,EAAG,CAAA,CAAE,CAAA,WACrB,CAAA;;KAGI,eAAA,iCAEM,gBAAA,GAAmB,gBAAA,iEAGjC,QAAA,CAAS,UAAA,CAAW,IAAA,EAAM,OAAA,EAAS,OAAA,EAAS,IAAA"}
+{"version":3,"file":"block_state_patch.d.ts","names":[],"sources":["../src/block_state_patch.ts"],"mappings":";;;YAGY,MAAM,GAAG;;WAEV,KAAK;;WAEL,OAAO;;;YAIN,SAAS,UAAU,8BAC5B,WAAW,IAAI,MAAM,GAAG,EAAE,aACrB;;YAGI,gBACV,gBACA,gBAAgB,mBAAmB,kBACnC,mBACA,4CACE,SAAS,WAAW,MAAM,SAAS,SAAS"}

package/dist/block_state_util.d.ts

@@ -1,18 +1,16 @@
 import { BlockOutputsBase, OutputWithStatus } from "@milaboratories/pl-model-common";
 import { ErrorLike } from "@milaboratories/pl-error-like";
-
 //#region src/block_state_util.d.ts
-declare class OutputError extends Error {
+export declare class OutputError extends Error {
   readonly errors: ErrorLike[];
   readonly moreErrors: boolean;
   constructor(errors: ErrorLike[], moreErrors: boolean);
 }
-declare function readOutput<T>(outputValue: OutputWithStatus<T>): T;
+export declare function readOutput<T>(outputValue: OutputWithStatus<T>): T;
 type ExtractValueType<V extends OutputWithStatus<unknown>> = Extract<V, {
   ok: true;
 }>["value"];
-type SimpleOutputs<Outputs extends BlockOutputsBase> = { [Key in keyof Outputs]: ExtractValueType<Outputs[Key]> };
-declare function wrapOutputs<Outputs extends BlockOutputsBase>(outputs: Outputs): SimpleOutputs<Outputs>;
+type SimpleOutputs<Outputs extends BlockOutputsBase> = { [Key in keyof Outputs]: ExtractValueType<Outputs[Key]>; };
+export declare function wrapOutputs<Outputs extends BlockOutputsBase>(outputs: Outputs): SimpleOutputs<Outputs>;
 //#endregion
-export { OutputError, readOutput, wrapOutputs };
 //# sourceMappingURL=block_state_util.d.ts.map

package/dist/block_state_util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_state_util.d.ts","names":[],"sources":["../src/block_state_util.ts"],"mappings":";;;;cAGa,WAAA,SAAoB,KAAA;EAAA,SAEb,MAAA,EAAQ,SAAA;EAAA,SACR,UAAA;cADA,MAAA,EAAQ,SAAA,IACR,UAAA;AAAA;AAAA,iBAMJ,UAAA,IAAc,WAAA,EAAa,gBAAA,CAAiB,CAAA,IAAK,CAAA;AAAA,KAK5D,gBAAA,WAA2B,gBAAA,aAA6B,OAAA,CAAQ,CAAA;EAAK,EAAA;AAAA;AAAA,KACrE,aAAA,iBAA8B,gBAAA,oBACnB,OAAA,GAAU,gBAAA,CAAiB,OAAA,CAAQ,GAAA;AAAA,iBAGnC,WAAA,iBAA4B,gBAAA,EAC1C,OAAA,EAAS,OAAA,GACR,aAAA,CAAc,OAAA"}
+{"version":3,"file":"block_state_util.d.ts","names":[],"sources":["../src/block_state_util.ts"],"mappings":";;;qBAGa,oBAAoB;WAEb,QAAQ;WACR;EAFlB,YACkB,QAAQ,aACR;;wBAMJ,WAAW,GAAG,aAAa,iBAAiB,KAAK;KAK5D,iBAAiB,UAAU,6BAA6B,QAAQ;EAAK;;KACrE,cAAc,gBAAgB,uBAChC,aAAa,UAAU,iBAAiB,QAAQ;wBAGnC,YAAY,gBAAgB,kBAC1C,SAAS,UACR,cAAc"}

package/dist/block_storage.d.ts

@@ -1,32 +1,31 @@
 import { InferFactoryData, PluginFactoryLike, PluginHandle } from "./plugin_handle.js";
 import { DataVersioned, TransferRecord } from "./block_migrations.js";
 import { Branded } from "@milaboratories/pl-model-common";
-
 //#region src/block_storage.d.ts
 /**
  * Discriminator key for BlockStorage format detection.
  * This unique hash-based key identifies data as BlockStorage vs legacy formats.
  */
-declare const BLOCK_STORAGE_KEY = "__pl_a7f3e2b9__";
+export declare const BLOCK_STORAGE_KEY = "__pl_a7f3e2b9__";
 /**
  * Type for valid schema versions
  */
-type BlockStorageSchemaVersion = "v1";
+export type BlockStorageSchemaVersion = "v1";
 /**
  * Branded type for plugin names - globally unique plugin type identifiers.
  * Using a branded type enforces explicit casting (`as PluginName`) which makes
  * it easy to find all plugin name definitions in the codebase and verify uniqueness.
  */
-type PluginName = Branded<string, "PluginName">;
+export type PluginName = Branded<string, "PluginName">;
 /**
  * Plugin registry - maps pluginId (unique within a block) to pluginName (globally unique plugin type).
  * Using a Record highlights that pluginIds must be unique within a block.
  */
-type PluginRegistry = Record<PluginHandle, PluginName>;
+export type PluginRegistry = Record<PluginHandle, PluginName>;
 /**
  * Versioned data - used for both block data and plugin data
  */
-interface VersionedData<TData = unknown> {
+export interface VersionedData<TData = unknown> {
   /** Version of the data, used for migrations */
   __dataVersion: string;
   /** The persistent data */
@@ -40,16 +39,19 @@ interface VersionedData<TData = unknown> {
  * - __pluginRegistry: Map from pluginId to pluginName (optional)
  * - __plugins: Plugin-specific data keyed by pluginId (optional)
  */
-type BlockStorage<TState = unknown> = {
-  /** Schema version - the key itself is the discriminator */readonly [BLOCK_STORAGE_KEY]: BlockStorageSchemaVersion; /** Registry of plugins: pluginId -> pluginName */
-  __pluginRegistry?: PluginRegistry; /** Plugin-specific data, keyed by plugin handle */
+export type BlockStorage<TState = unknown> = {
+  /** Schema version - the key itself is the discriminator */
+  readonly [BLOCK_STORAGE_KEY]: BlockStorageSchemaVersion;
+  /** Registry of plugins: pluginId -> pluginName */
+  __pluginRegistry?: PluginRegistry;
+  /** Plugin-specific data, keyed by plugin handle */
   __plugins?: Record<PluginHandle, VersionedData<unknown>>;
 } & VersionedData<TState>;
 /**
  * Type guard to check if a value is a valid BlockStorage object.
  * Checks for the discriminator key and valid schema version.
  */
-declare function isBlockStorage(value: unknown): value is BlockStorage;
+export declare function isBlockStorage(value: unknown): value is BlockStorage;
 /**
  * Creates a BlockStorage with the given initial data
  *
@@ -57,7 +59,7 @@ declare function isBlockStorage(value: unknown): value is BlockStorage;
  * @param version - The initial data version key (defaults to DATA_MODEL_LEGACY_VERSION)
  * @returns A new BlockStorage instance with discriminator key
  */
-declare function createBlockStorage<TState = unknown>(initialData?: TState, version?: string): BlockStorage<TState>;
+export declare function createBlockStorage<TState = unknown>(initialData?: TState, version?: string): BlockStorage<TState>;
 /**
  * Normalizes raw storage data to BlockStorage format.
  * If the input is already a BlockStorage, returns it as-is (with defaults for missing fields).
@@ -66,14 +68,14 @@ declare function createBlockStorage<TState = unknown>(initialData?: TState, vers
  * @param raw - Raw storage data (may be legacy format or BlockStorage)
  * @returns Normalized BlockStorage
  */
-declare function normalizeBlockStorage<TState = unknown>(raw: unknown): BlockStorage<TState>;
+export declare function normalizeBlockStorage<TState = unknown>(raw: unknown): BlockStorage<TState>;
 /**
  * Gets the data from BlockStorage
  *
  * @param storage - The BlockStorage instance
  * @returns The data value
  */
-declare function getStorageData<TState>(storage: BlockStorage<TState>): TState;
+export declare function getStorageData<TState>(storage: BlockStorage<TState>): TState;
 /**
  * Derives data from raw block storage.
  * This function is meant to be called from sdk/ui-vue to extract
@@ -85,9 +87,9 @@ declare function getStorageData<TState>(storage: BlockStorage<TState>): TState;
  * @param rawStorage - Raw storage data from middle layer (may be any format)
  * @returns The extracted data value, or undefined if storage is undefined/null
  */
-declare function deriveDataFromStorage<TData = unknown>(rawStorage: unknown): TData;
+export declare function deriveDataFromStorage<TData = unknown>(rawStorage: unknown): TData;
 /** Payload for storage mutation operations. SDK defines specific operations. */
-type MutateStoragePayload<T = unknown> = {
+export type MutateStoragePayload<T = unknown> = {
   operation: "update-block-data";
   value: T;
 } | {
@@ -102,11 +104,11 @@ type MutateStoragePayload<T = unknown> = {
  * @param payload - The update payload with operation and value
  * @returns A new BlockStorage with updated data
  */
-declare function updateStorageData<TValue = unknown>(storage: BlockStorage<TValue>, payload: MutateStoragePayload<TValue>): BlockStorage<TValue>;
+export declare function updateStorageData<TValue = unknown>(storage: BlockStorage<TValue>, payload: MutateStoragePayload<TValue>): BlockStorage<TValue>;
 /**
  * Result of a successful atomic migration.
  */
-interface MigrationSuccess<TState> {
+export interface MigrationSuccess<TState> {
   success: true;
   /** The fully migrated storage - commit this to persist */
   storage: BlockStorage<TState>;
@@ -115,20 +117,20 @@ interface MigrationSuccess<TState> {
  * Result of a failed atomic migration.
  * The original storage is untouched - user must choose to abort or reset.
  */
-interface MigrationFailure {
+export interface MigrationFailure {
   success: false;
   /** Description of what failed */
   error: string;
   /** Which step failed: 'block' or pluginId */
   failedAt: string;
 }
-type MigrationResult<TState> = MigrationSuccess<TState> | MigrationFailure;
+export type MigrationResult<TState> = MigrationSuccess<TState> | MigrationFailure;
 /**
  * Configuration for atomic block storage migration.
  * Callbacks use DataVersioned format (the DataModel API format).
  * Conversion to internal VersionedData format is handled by migrateBlockStorage().
  */
-interface MigrateBlockStorageConfig {
+export interface MigrateBlockStorageConfig {
   /** Migrate block data from any version to latest. Returns migrated data and transfers. */
   migrateBlockData: (versioned: DataVersioned<unknown>) => DataVersioned<unknown> & {
     transfers: TransferRecord;
@@ -181,7 +183,7 @@ interface MigrateBlockStorageConfig {
  *   // else: abort, keep original
  * }
  */
-declare function migrateBlockStorage(storage: BlockStorage<unknown>, config: MigrateBlockStorageConfig): MigrationResult<unknown>;
+export declare function migrateBlockStorage(storage: BlockStorage<unknown>, config: MigrateBlockStorageConfig): MigrationResult<unknown>;
 /**
  * Gets plugin-specific data from block storage.
  * Accepts raw storage (any format) and normalizes internally.
@@ -194,7 +196,6 @@ declare function migrateBlockStorage(storage: BlockStorage<unknown>, config: Mig
  * @returns The plugin data, typed via factory inference
  * @throws If plugin is not found in storage
  */
-declare function getPluginData<F extends PluginFactoryLike>(rawStorage: unknown, handle: PluginHandle<F>): InferFactoryData<F>;
+export declare function getPluginData<F extends PluginFactoryLike>(rawStorage: unknown, handle: PluginHandle<F>): InferFactoryData<F>;
 //#endregion
-export { BLOCK_STORAGE_KEY, BlockStorage, BlockStorageSchemaVersion, MigrateBlockStorageConfig, MigrationFailure, MigrationResult, MigrationSuccess, MutateStoragePayload, PluginName, PluginRegistry, VersionedData, createBlockStorage, deriveDataFromStorage, getPluginData, getStorageData, isBlockStorage, migrateBlockStorage, normalizeBlockStorage, updateStorageData };
 //# sourceMappingURL=block_storage.d.ts.map

package/dist/block_storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_storage.d.ts","names":[],"sources":["../src/block_storage.ts"],"mappings":";;;;;;AA4CqC;AAOrC;;cAxBa,iBAAA;;;;KAiBD,yBAAA;AAagD;AAK5D;;;;AAL4D,KANhD,UAAA,GAAa,OAAO;;;;;KAMpB,cAAA,GAAiB,MAAA,CAAO,YAAA,EAAc,UAAA;AAoBlD;;;AAAA,UAfiB,aAAA;EAiBL;EAfV,aAAA;EAmBmB;EAjBnB,MAAA,EAAQ,KAAK;AAAA;;;;;;;;;KAWH,YAAA;EAMV,qEAJU,iBAAA,GAAoB,yBAAA,EAIX;EAFnB,gBAAA,GAAmB,cAAA,EAGjB;EADF,SAAA,GAAY,MAAA,CAAO,YAAA,EAAc,aAAA;AAAA,IAC/B,aAAA,CAAc,MAAA;AAAM;AAMxB;;;AANwB,iBAMR,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,YAAY;;;;;AAAA;AAmBrE;;iBAAgB,kBAAA,mBACd,WAAA,GAAa,MAAA,EACb,OAAA,YACC,YAAA,CAAa,MAAA;;;;;;;;;iBAkBA,qBAAA,mBAAwC,GAAA,YAAe,YAAY,CAAC,MAAA;;;;AAlB9D;AAkBtB;;iBA6BgB,cAAA,SAAuB,OAAA,EAAS,YAAA,CAAa,MAAA,IAAU,MAAA;;;;;;;AA7BmB;AA6B1F;;;;iBAegB,qBAAA,kBAAuC,UAAA,YAAsB,KAAK;;KAOtE,oBAAA;EACN,SAAA;EAAgC,KAAA,EAAO,CAAA;AAAA;EACvC,SAAA;EAAiC,QAAA,EAAU,YAAY;EAAE,KAAA;AAAA;AAxBc;AAe7E;;;;;;AAf6E,iBAiC7D,iBAAA,mBACd,OAAA,EAAS,YAAA,CAAa,MAAA,GACtB,OAAA,EAAS,oBAAA,CAAqB,MAAA,IAC7B,YAAA,CAAa,MAAA;;AArBkE;AAOlF;UA8CiB,gBAAA;EACf,OAAA;EA7C2D;EA+C3D,OAAA,EAAS,YAAY,CAAC,MAAA;AAAA;;;;;UAOP,gBAAA;EACf,OAAA;EAvDkE;EAyDlE,KAAA;EAhDc;EAkDd,QAAA;AAAA;AAAA,KAGU,eAAA,WAA0B,gBAAA,CAAiB,MAAA,IAAU,gBAAA;;;;;;UAOhD,yBAAA;EAzDF;EA2Db,gBAAA,GAAmB,SAAA,EAAW,aAAA,cAA2B,aAAA;IACvD,SAAA,EAAW,cAAA;EAAA;EA9Db;EAiEA,iBAAA,GACE,MAAA,EAAQ,YAAA,EACR,SAAA,EAAW,aAAA,cACR,aAAA;EAnEyB;EAqE9B,iBAAA,EAAmB,cAAA;EApElB;;EAuED,gBAAA,GACE,MAAA,EAAQ,YAAA,EACR,QAAA,GAAW,aAAA,cACR,aAAA;AAAA;AA1CP;;;;;;;;;;AAG8B;AAO9B;;;;;;;;AAKU;AAGV;;;;;;;;;;;;;AAAiF;AAOjF;;;;;;AAzBA,iBAqFgB,mBAAA,CACd,OAAA,EAAS,YAAA,WACT,MAAA,EAAQ,yBAAA,GACP,eAAA;;;;;;;;;;;;;iBAyGa,aAAA,WAAwB,iBAAA,EACtC,UAAA,WACA,MAAA,EAAQ,YAAA,CAAa,CAAA,IACpB,gBAAA,CAAiB,CAAA"}
+{"version":3,"file":"block_storage.d.ts","names":[],"sources":["../src/block_storage.ts"],"mappings":";;;;;;;;qBA2Ba;;;;YAiBD;;;;;;YAOA,aAAa;;;;;YAMb,iBAAiB,OAAO,cAAc;;;;iBAKjC,cAAc;;EAE7B;;EAEA,QAAQ;;;;;;;;;;YAWE,aAAa;;YAEb,oBAAoB;;EAE9B,mBAAmB;;EAEnB,YAAY,OAAO,cAAc;IAC/B,cAAc;;;;;wBAMF,eAAe,iBAAiB,SAAS;;;;;;;;wBAmBzC,mBAAmB,kBACjC,cAAa,QACb,mBACC,aAAa;;;;;;;;;wBAkBA,sBAAsB,kBAAkB,eAAe,aAAa;;;;;;;wBA6BpE,eAAe,QAAQ,SAAS,aAAa,UAAU;;;;;;;;;;;;wBAevD,sBAAsB,iBAAiB,sBAAsB;;YAOjE,qBAAqB;EAC3B;EAAgC,OAAO;;EACvC;EAAiC,UAAU;EAAc;;;;;;;;;wBAS/C,kBAAkB,kBAChC,SAAS,aAAa,SACtB,SAAS,qBAAqB,UAC7B,aAAa;;;;iBAgCC,iBAAiB;EAChC;;EAEA,SAAS,aAAa;;;;;;iBAOP;EACf;;EAEA;;EAEA;;YAGU,gBAAgB,UAAU,iBAAiB,UAAU;;;;;;iBAOhD;;EAEf,mBAAmB,WAAW,2BAA2B;IACvD,WAAW;;;EAGb,oBACE,QAAQ,cACR,WAAW,2BACR;;EAEL,mBAAmB;;;EAGnB,mBACE,QAAQ,cACR,WAAW,2BACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CS,oBACd,SAAS,uBACT,QAAQ,4BACP;;;;;;;;;;;;;wBAyGa,cAAc,UAAU,mBACtC,qBACA,QAAQ,aAAa,KACpB,iBAAiB"}

package/dist/block_storage_facade.d.ts

@@ -1,13 +1,13 @@
 import { MutateStoragePayload } from "./block_storage.js";
 import { ConfigRenderLambda } from "./bconfig/lambdas.js";
+import "./bconfig/index.js";
 import { StringifiedJson } from "@milaboratories/pl-model-common";
-
 //#region src/block_storage_facade.d.ts
 /**
  * The current facade version. This value is used for `requiresModelAPIVersion`
  * feature flag in BlockModelV3.
  */
-declare const BLOCK_STORAGE_FACADE_VERSION = 2;
+export declare const BLOCK_STORAGE_FACADE_VERSION = 2;
 /**
  * All facade callback names as constants.
  * These are the source of truth - the interface is derived from these.
@@ -17,7 +17,7 @@ declare const BLOCK_STORAGE_FACADE_VERSION = 2;
  * 2. Add the callback signature to FacadeCallbackTypes below
  * 3. The BlockStorageFacade type will automatically include it
  */
-declare const BlockStorageFacadeCallbacks: {
+export declare const BlockStorageFacadeCallbacks: {
   readonly StorageApplyUpdate: "__pl_storage_applyUpdate";
   readonly StorageDebugView: "__pl_storage_debugView";
   readonly StorageMigrate: "__pl_storage_migrate";
@@ -32,16 +32,16 @@ declare const BlockStorageFacadeCallbacks: {
  * Lambda handles for facade callbacks.
  * Used by the middle layer to invoke callbacks via executeSingleLambda().
  */
-declare const BlockStorageFacadeHandles: {
-  __pl_storage_applyUpdate: ConfigRenderLambda<unknown>;
-  __pl_storage_debugView: ConfigRenderLambda<unknown>;
-  __pl_storage_migrate: ConfigRenderLambda<unknown>;
+export declare const BlockStorageFacadeHandles: {
   __pl_args_derive: ConfigRenderLambda<unknown>;
+  __pl_initializationParams_derive: ConfigRenderLambda<unknown>;
+  __pl_initializationParams_validate: ConfigRenderLambda<unknown>;
   __pl_prerunArgs_derive: ConfigRenderLambda<unknown>;
+  __pl_storage_applyUpdate: ConfigRenderLambda<unknown>;
+  __pl_storage_debugView: ConfigRenderLambda<unknown>;
   __pl_storage_initial: ConfigRenderLambda<unknown>;
-  __pl_initializationParams_derive: ConfigRenderLambda<unknown>;
   __pl_storage_initialFromParams: ConfigRenderLambda<unknown>;
-  __pl_initializationParams_validate: ConfigRenderLambda<unknown>;
+  __pl_storage_migrate: ConfigRenderLambda<unknown>;
 };
 /**
  * The complete facade interface between bundled blocks (SDK) and middle layer.
@@ -63,7 +63,7 @@ declare const BlockStorageFacadeHandles: {
  * - Parameter descriptions
  * - Return value description
  */
-interface BlockStorageFacade {
+export interface BlockStorageFacade {
   /**
    * Apply state update to storage.
    * Called when UI updates block state (setState) or plugin data.
@@ -220,7 +220,6 @@ interface BlockStorageFacade {
   };
 }
 /** Register all facade callbacks at once. Ensures all required callbacks are provided. */
-declare function registerFacadeCallbacks(callbacks: BlockStorageFacade): void;
+export declare function registerFacadeCallbacks(callbacks: BlockStorageFacade): void;
 //#endregion
-export { BLOCK_STORAGE_FACADE_VERSION, BlockStorageFacade, BlockStorageFacadeCallbacks, BlockStorageFacadeHandles, registerFacadeCallbacks };
 //# sourceMappingURL=block_storage_facade.d.ts.map

package/dist/block_storage_facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_storage_facade.d.ts","names":[],"sources":["../src/block_storage_facade.ts"],"mappings":";;;;;;;;;cA8Da,4BAAA;;;;;AAqEb;;;;;cAtDa,2BAAA;EAAA;;;;;;;;;;;;;;cA4BA,yBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA0BI,kBAAA;EAkCT;;;;;;;EAAA,CA1BL,2BAAA,CAA4B,kBAAA,IAC3B,kBAAA,EAAoB,eAAA,EACpB,OAAA,EAAS,oBAAA,KACN,eAAA;EAkCyC;;;;;;EAAA,CA1B7C,2BAAA,CAA4B,gBAAA,IAC3B,WAAA,EAAa,eAAA,iBACV,eAAA;EAkCsB;;;;;;EAAA,CA1B1B,2BAAA,CAA4B,cAAA,IAAkB,kBAAA,EAAoB,eAAA;IAC7D,KAAA;EAAA;IAEA,KAAA;IACA,cAAA,EAAgB,eAAA;IAChB,IAAA;EAAA;EAgDwC;;;;;;EAAA,CAvC7C,2BAAA,CAA4B,UAAA,IAC3B,WAAA,EAAa,eAAA;IACR,KAAA;EAAA;IAAoB,KAAA;IAAmB,KAAA;EAAA;EA2G7C;;;;;;EAAA,CAnGA,2BAAA,CAA4B,gBAAA,IAC3B,WAAA,EAAa,eAAA;IACR,KAAA;EAAA;IAAoB,KAAA;IAAmB,KAAA;EAAA;EAuGG;AAAkB;;;;EAAlB,CAhGhD,2BAAA,CAA4B,cAAA,SAAuB,eAAA;;;;;;;;;;;;;;;;;GAkBnD,2BAAA,CAA4B,0BAAA,IAC3B,WAAA,EAAa,eAAA;IACR,KAAA;EAAA;IAAoB,KAAA;IAAmB,KAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6C7C,2BAAA,CAA4B,wBAAA,IAC3B,UAAA,EAAY,eAAA,EACZ,YAAA,EAAc,eAAA;IACT,KAAA;EAAA;IAAoB,KAAA;IAAmB,WAAA,EAAa,eAAA;EAAA;;;;;;;;;;;;;;;;;;;;;GAsB1D,2BAAA,CAA4B,4BAAA,IAC3B,UAAA,EAAY,eAAA;IACP,KAAA;EAAA;IAAoB,KAAA;EAAA;AAAA;;iBAIb,uBAAA,CAAwB,SAA6B,EAAlB,kBAAkB"}
+{"version":3,"file":"block_storage_facade.d.ts","names":[],"sources":["../src/block_storage_facade.ts"],"mappings":";;;;;;;;;qBA8Da;;;;;;;;;;qBAeA;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;;;;qBAmBW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BI;;;;;;;;GAQd,4BAA4B,sBAC3B,oBAAoB,iBACpB,SAAS,yBACN;;;;;;;GAQJ,4BAA4B,oBAC3B,aAAa,gCACV;;;;;;;GAQJ,4BAA4B,kBAAkB,oBAAoB;IAC7D;;IAEA;IACA,gBAAgB;IAChB;;;;;;;;GASL,4BAA4B,cAC3B,aAAa;IACR;;IAAoB;IAAmB;;;;;;;;GAQ7C,4BAA4B,oBAC3B,aAAa;IACR;;IAAoB;IAAmB;;;;;;;GAO7C,4BAA4B,uBAAuB;;;;;;;;;;;;;;;;;GAkBnD,4BAA4B,8BAC3B,aAAa;IACR;;IAAoB;IAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6C7C,4BAA4B,4BAC3B,YAAY,iBACZ,cAAc;IACT;;IAAoB;IAAmB,aAAa;;;;;;;;;;;;;;;;;;;;;;GAsB1D,4BAA4B,gCAC3B,YAAY;IACP;;IAAoB;;;;wBAIb,wBAAwB,WAAW"}

package/dist/columns/column.d.ts

@@ -1,12 +1,12 @@
 import { GlobalCfgRenderCtx } from "../render/internal.js";
 import { TreeNodeAccessor } from "../render/accessor.js";
+import "../render/index.js";
 import { ColumnRecipeId } from "./column_recipes/types.js";
 import { ColumnData, DataColumnRecipe } from "./data_column.js";
 import { ColumnRecipe } from "./column_recipes/index.js";
 import { ColumnUniversalId, LeafEntry, PColumn, PObjectId, PlRef } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column.d.ts
-type ColumnSource = PObjectId | ColumnUniversalId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnData> | DataColumnRecipe<PObjectId>;
+export type ColumnSource = PObjectId | ColumnUniversalId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnData> | DataColumnRecipe<PObjectId>;
 /**
  * Unified entry point — routes between the two top-level dispatchers:
  *   - string id (`PObjectId` / `ColumnUniversalId`) → {@link ColumnRecipe}
@@ -15,16 +15,15 @@ type ColumnSource = PObjectId | ColumnUniversalId | PlRef | LeafEntry<TreeNodeAc
  * `DataColumnRecipe` is itself a `ColumnRecipe<PObjectId>`, so the return type is
  * the common `ColumnRecipe`.
  */
-declare function Column(source: ColumnSource, opts?: {
+export declare function Column(source: ColumnSource, opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): undefined | ColumnRecipe;
-type Column<ID extends ColumnRecipeId = ColumnRecipeId> = ColumnRecipe<ID>;
+export type Column<ID extends ColumnRecipeId = ColumnRecipeId> = ColumnRecipe<ID>;
 /**
  * Type-guard for the `Column` type — currently aliased to `ColumnRecipe`, so
  * this is equivalent to {@link isColumnRecipe}. Kept as a separate export to
  * mirror the `Column` / `ColumnRecipe` / `DataColumnRecipe` factory triple.
  */
-declare function isColumn(value: unknown): value is Column;
+export declare function isColumn(value: unknown): value is Column;
 //#endregion
-export { Column, ColumnSource, isColumn };
 //# sourceMappingURL=column.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"column.d.ts","names":[],"sources":["../../src/columns/column.ts"],"mappings":";;;;;;;;KAkBY,YAAA,GACR,SAAA,GACA,iBAAA,GACA,KAAA,GACA,SAAA,CAAU,gBAAA,IACV,OAAA,CAAQ,UAAA,IACR,gBAAA,CAAiB,SAAA;;;;AANrB;;;;;iBAgBgB,MAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAS,GAAA,GAAM,kBAAA;AAAA,gBACF,YAAA;AAAA,KAKH,MAAA,YAAkB,cAAA,GAAiB,cAAA,IAAkB,YAAA,CAAa,EAAA;;;;;;iBAO9D,QAAA,CAAS,KAAA,YAAiB,KAAA,IAAS,MAAM"}
+{"version":3,"file":"column.d.ts","names":[],"sources":["../../src/columns/column.ts"],"mappings":";;;;;;;;YAkBY,eACR,YACA,oBACA,QACA,UAAU,oBACV,QAAQ,cACR,iBAAiB;;;;;;;;;wBAUL,OACd,QAAQ,cACR;EAAS,MAAM;gBACF;YAKH,OAAO,WAAW,iBAAiB,kBAAkB,aAAa;;;;;;wBAO9D,SAAS,iBAAiB,SAAS"}

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

@@ -3,7 +3,6 @@ import { TreeNodeAccessor } from "../../render/accessor.js";
 import { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl } from "./providers.js";
 import { ColumnsSource } from "./types.js";
 import { ColumnEntriesProvider } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column_providers/index.d.ts
 /**
  * Build the default set of ColumnsProviders for the ambient render ctx:
@@ -19,12 +18,12 @@ import { ColumnEntriesProvider } from "@milaboratories/pl-model-common";
  * also LRU-memoised by their content keys, so even a cache miss here doesn't
  * re-walk the trees.
  */
-declare const _ctxProvidersCache: WeakMap<GlobalCfgRenderCtx, (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[]>;
-declare function getCtxProviders(deps?: {
+export declare const _ctxProvidersCache: WeakMap<GlobalCfgRenderCtx, (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[]>;
+export declare function getCtxProviders(deps?: {
   ctx?: GlobalCfgRenderCtx;
 }): (ColumnEntriesProvider<TreeNodeAccessor> & ColumnsProvider)[];
-declare function isColumnProvider(source: unknown): source is ColumnsProvider;
-declare function toColumnProvider(source: ColumnsSource): ColumnsProvider;
+export declare function isColumnProvider(source: unknown): source is ColumnsProvider;
+export declare function toColumnProvider(source: ColumnsSource): ColumnsProvider;
 //#endregion
-export { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ColumnsSource, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl, _ctxProvidersCache, getCtxProviders, isColumnProvider, toColumnProvider };
+export { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ColumnsSource, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/columns/column_providers/index.ts"],"mappings":";;;;;;;AA8BA;;;;;;;;;;;;;;AAAA,cAAa,kBAAA,EAAkB,OAAA,CAAA,kBAAA,GAAA,qBAAA,CAAA,gBAAA,IAAA,eAAA;AAAA,iBAKf,eAAA,CAAgB,IAAA;EAC9B,GAAA,GAAM,kBAAA;AAAA,KACH,qBAAA,CAAsB,gBAAA,IAAoB,eAAA;AAAA,iBAwB/B,gBAAA,CAAiB,MAAA,YAAkB,MAAA,IAAU,eAAe;AAAA,iBAM5D,gBAAA,CAAiB,MAAA,EAAQ,aAAA,GAAgB,eAAe"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/columns/column_providers/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBA8Ba,oBAAkB,QAAA,qBAAA,sBAAA,oBAAA;wBAKf,gBAAgB;EAC9B,MAAM;KACH,sBAAsB,oBAAoB;wBAwB/B,iBAAiB,kBAAkB,UAAU;wBAM7C,iBAAiB,QAAQ,gBAAgB"}

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

@@ -1,8 +1,8 @@
 import { AccessorHandle, PColumnDataUniversal } from "../../render/internal.js";
 import { TreeNodeAccessor } from "../../render/accessor.js";
+import "../../render/index.js";
 import { DataColumnRecipe } from "../data_column.js";
 import { AccessorEntriesProvider, PColumn, PObjectId, ResultPoolEntriesProvider, UpstreamBlockCtx } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column_providers/providers.d.ts
 /**
  * Data source for sandbox column-list builders. Has nothing to say about
@@ -12,7 +12,7 @@ import { AccessorEntriesProvider, PColumn, PObjectId, ResultPoolEntriesProvider,
  * Same name as the factory function below — they merge into one TS
  * declaration: `ColumnsProvider` is callable AND the interface type.
  */
-interface ColumnsProvider {
+export interface ColumnsProvider {
   /** Returns all currently known PColumn columns as lazy views. */
   getColumns(): DataColumnRecipe<PObjectId>[];
   /** Whether the provider has finished enumerating all its columns. */
@@ -30,15 +30,15 @@ interface ColumnsProvider {
  * Both branches return cached instances within their LRU window, so repeated
  * calls with the same source skip re-walking / re-hashing.
  */
-declare function ColumnsProvider(source?: TreeNodeAccessor | ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>): ResultPoolColumnsProviderImpl | AccessorColumnsProviderImpl;
-declare function AccessorColumnsProvider(root: TreeNodeAccessor): AccessorColumnsProvider;
-declare function ResultPoolColumnsProvider(rawPool?: ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>): ResultPoolColumnsProvider;
+export declare function ColumnsProvider(source?: TreeNodeAccessor | ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>): AccessorColumnsProviderImpl | ResultPoolColumnsProviderImpl;
+export declare function AccessorColumnsProvider(root: TreeNodeAccessor): AccessorColumnsProvider;
+export declare function ResultPoolColumnsProvider(rawPool?: ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>): ResultPoolColumnsProvider;
 /**
  * Simple provider wrapping an array of PColumns. Sandbox-only —
  * implements {@link ColumnsProvider} (lazy-view enumeration). It is *not* an
  * id-index source — `ColumnRegistry` does not consume it.
  */
-declare class ArrayColumnsProvider implements ColumnsProvider {
+export declare class ArrayColumnsProvider implements ColumnsProvider {
   private readonly _isFinal;
   private readonly columns;
   constructor(columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | DataColumnRecipe<PObjectId>>, _isFinal: boolean);
@@ -51,25 +51,24 @@ declare class ArrayColumnsProvider implements ColumnsProvider {
  * and adds `getColumns()` returning {@link DataColumnRecipe<PObjectId>}s on top of the generic
  * entries index.
  */
-declare class AccessorColumnsProviderImpl extends AccessorEntriesProvider<TreeNodeAccessor> implements ColumnsProvider {
+export declare class AccessorColumnsProviderImpl extends AccessorEntriesProvider<TreeNodeAccessor> implements ColumnsProvider {
   private cachedColumns?;
   constructor(root: TreeNodeAccessor);
   getColumns(): DataColumnRecipe<PObjectId>[];
 }
 /** Public type alias — value of the same name is the memoised factory above. */
-type AccessorColumnsProvider = AccessorColumnsProviderImpl;
+export type AccessorColumnsProvider = AccessorColumnsProviderImpl;
 /**
  * Sandbox-specific result-pool provider. Accepts the raw handle-shaped blocks
  * returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx} and
  * wraps them into {@link TreeNodeAccessor}s, then adds `getColumns()`.
  */
-declare class ResultPoolColumnsProviderImpl extends ResultPoolEntriesProvider<TreeNodeAccessor> implements ColumnsProvider {
+export declare class ResultPoolColumnsProviderImpl extends ResultPoolEntriesProvider<TreeNodeAccessor> implements ColumnsProvider {
   private cachedColumns?;
   constructor(rawPool?: ReadonlyArray<UpstreamBlockCtx<AccessorHandle>>);
   getColumns(): DataColumnRecipe<PObjectId>[];
 }
 /** Public type alias — value of the same name is the memoised factory above. */
-type ResultPoolColumnsProvider = ResultPoolColumnsProviderImpl;
+export type ResultPoolColumnsProvider = ResultPoolColumnsProviderImpl;
 //#endregion
-export { AccessorColumnsProvider, AccessorColumnsProviderImpl, ArrayColumnsProvider, ColumnsProvider, ResultPoolColumnsProvider, ResultPoolColumnsProviderImpl };
 //# sourceMappingURL=providers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"providers.d.ts","names":[],"sources":["../../../src/columns/column_providers/providers.ts"],"mappings":";;;;;;;;;;AAqBA;;;;UAAiB,eAAA;EAED;EAAd,UAAA,IAAc,gBAAgB,CAAC,SAAA;EAE/B;EAAA,OAAA;AAAA;AAeF;;;;;;;;;;;;AAAA,iBAAgB,eAAA,CACd,MAAA,GAAS,gBAAA,GAAmB,aAAA,CAAc,gBAAA,CAAiB,cAAA,KAAgB,6BAAA,GAAA,2BAAA;AAAA,iBAmB7D,uBAAA,CAAwB,IAAA,EAAM,gBAAA,GAAmB,uBAAuB;AAAA,iBAexE,yBAAA,CACd,OAAA,GAAS,aAAA,CACP,gBAAA,CAAiB,cAAA,KAElB,yBAAA;;;;;AAtC0E;cAqDhE,oBAAA,YAAgC,eAAA;EAAA,iBAKxB,QAAA;EAAA,iBAJF,OAAA;cAGf,OAAA,EAAS,aAAA,CAAc,OAAA,aAAoB,oBAAA,IAAwB,gBAAA,CAAiB,SAAA,IACnE,QAAA;EAKnB,UAAA,IAAc,gBAAA,CAAiB,SAAA;EAI/B,OAAA;AAAA;;AAhDsF;AAexF;;;;cA4Ca,2BAAA,SACH,uBAAA,CAAwB,gBAAA,aACrB,eAAA;EAAA,QAEH,aAAA;cAEI,IAAA,EAAM,gBAAA;EAIlB,UAAA,IAAc,gBAAA,CAAiB,SAAA;AAAA;;KASrB,uBAAA,GAA0B,2BAA2B;;;;;AA3DrC;cAkEf,6BAAA,SACH,yBAAA,CAA0B,gBAAA,aACvB,eAAA;EAAA,QAEH,aAAA;cAGN,OAAA,GAAS,aAAA,CACP,gBAAA,CAAiB,cAAA;EAoBrB,UAAA,IAAc,gBAAA,CAAiB,SAAA;AAAA;;KASrB,yBAAA,GAA4B,6BAA6B"}
+{"version":3,"file":"providers.d.ts","names":[],"sources":["../../../src/columns/column_providers/providers.ts"],"mappings":";;;;;;;;;;;;;;iBAqBiB;;EAEf,cAAc,iBAAiB;;EAE/B;;;;;;;;;;;;;;wBAec,gBACd,SAAS,mBAAmB,cAAc,iBAAiB,mBAAgB,8BAAA;wBAmB7D,wBAAwB,MAAM,mBAAmB;wBAejD,0BACd,UAAS,cACP,iBAAiB,mBAElB;;;;;;qBAeU,gCAAgC;mBAKxB;mBAJF;EAEjB,YACE,SAAS,cAAc,oBAAoB,wBAAwB,iBAAiB,aACnE;EAKnB,cAAc,iBAAiB;EAI/B;;;;;;;;qBAWW,oCACH,wBAAwB,6BACrB;UAEH;EAER,YAAY,MAAM;EAIlB,cAAc,iBAAiB;;;YASrB,0BAA0B;;;;;;qBAOzB,sCACH,0BAA0B,6BACvB;UAEH;EAER,YACE,UAAS,cACP,iBAAiB;EAoBrB,cAAc,iBAAiB;;;YASrB,4BAA4B"}

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

@@ -1,10 +1,10 @@
 import { PColumnDataUniversal } from "../../render/internal.js";
 import { TreeNodeAccessor } from "../../render/accessor.js";
+import "../../render/index.js";
 import { DataColumnRecipe } from "../data_column.js";
 import { ColumnRecipe } from "../column_recipes/index.js";
 import { ColumnsProvider } from "./providers.js";
 import { PColumn } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column_providers/types.d.ts
 /**
  * Union of types that can serve as column sources for helpers and builders.
@@ -14,10 +14,9 @@ import { PColumn } from "@milaboratories/pl-model-common";
  * {@link DataColumnRecipe} leaves, or any {@link ColumnRecipe} — builders only
  * need each entry's `id` for serialization.
  */
-type ColumnsSource = ColumnsProvider | TreeNodeAccessor | {
+export type ColumnsSource = ColumnsProvider | TreeNodeAccessor | {
   readonly columns: ReadonlyArray<PColumn<undefined | PColumnDataUniversal> | DataColumnRecipe | ColumnRecipe>;
   readonly isFinal: boolean;
 };
 //#endregion
-export { ColumnsSource };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/columns/column_providers/types.ts"],"mappings":";;;;;;;;;;;AAeA;;;;;KAAY,aAAA,GACR,eAAA,GACA,gBAAA;EAAA,SAEW,OAAA,EAAS,aAAA,CAChB,OAAA,aAAoB,oBAAA,IAAwB,gBAAA,GAAmB,YAAA;EAAA,SAExD,OAAA;AAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/columns/column_providers/types.ts"],"mappings":";;;;;;;;;;;;;;;;YAeY,gBACR,kBACA;WAEW,SAAS,cAChB,oBAAoB,wBAAwB,mBAAmB;WAExD"}

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

@@ -2,7 +2,6 @@ import { GlobalCfgRenderCtx } from "../../render/internal.js";
 import { ColumnFieldStatus, ColumnResolutionStatus } from "./types.js";
 import { ColumnRecipe } from "./index.js";
 import { AxisQualification, ColumnDiscoveredId, ColumnDiscoveredKey, ColumnUniversalId, PColumnSpec, PObjectId, SpecOverrides, SpecQuery } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column_recipes/column_discovered_recipe.d.ts
 /**
  * Recipe for columns identified by a {@link ColumnDiscoveredKey}: a base
@@ -19,7 +18,7 @@ import { AxisQualification, ColumnDiscoveredId, ColumnDiscoveredKey, ColumnUnive
  *    no engine round-trip is needed (mirrors the Discovered branch of
  *    `reconstructSpecFromId` on the host side).
  */
-declare class ColumnDiscoveredRecipe implements ColumnRecipe<ColumnDiscoveredId> {
+export declare class ColumnDiscoveredRecipe implements ColumnRecipe<ColumnDiscoveredId> {
   private readonly key;
   private readonly columns;
   /**
@@ -116,5 +115,4 @@ declare class ColumnDiscoveredRecipe implements ColumnRecipe<ColumnDiscoveredId>
   private buildSpecQuery;
 }
 //#endregion
-export { ColumnDiscoveredRecipe };
 //# sourceMappingURL=column_discovered_recipe.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"column_discovered_recipe.d.ts","names":[],"sources":["../../../src/columns/column_recipes/column_discovered_recipe.ts"],"mappings":";;;;;;;;AAoCA;;;;;;;;;;;;;cAAa,sBAAA,YAAkC,YAAA,CAAa,kBAAA;EAAA,iBAiDvC,GAAA;EAAA,iBACA,OAAA;EA0BS;;;;;;;;EAAA,OAnErB,OAAA,CACL,GAAA,EAAK,mBAAA,EACL,IAAA;IAAQ,GAAA,GAAM,kBAAA;EAAA,gBACD,sBAAA;EAZ2C;;;;;;EAAA,OA6BnD,cAAA,CACL,GAAA,EAAK,mBAAA,EACL,IAAA;IAAQ,GAAA,GAAM,kBAAA;EAAA,IACb,sBAAA;EAAA,SAWM,EAAA,EAAI,kBAAA;EAAA,QACL,SAAA;EAAA,QACA,UAAA;EAAA,QACA,eAAA;EAAA,QAED,WAAA;EAjBS;;;;;EA6BhB,QAAA,IAAY,iBAAA;EAfJ;;;;EAuBR,uBAAA,aAAoC,iBAAA;EAApC;;;;EAQA,wBAAA,IAA4B,QAAA,CAAS,MAAA,CAAO,SAAA,EAAW,iBAAA;EAAX;;;;;;EAU5C,gBAAA,IAAoB,SAAA;EAuBR;;;;;;;;EAXZ,OAAA,IAAW,WAAA;EAkEW;EAvDtB,QAAA,IAAY,SAAA;EAOZ,aAAA,IAAiB,iBAAA;;;;;;EAmBjB,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;UA6B7B,cAAA;AAAA"}
+{"version":3,"file":"column_discovered_recipe.d.ts","names":[],"sources":["../../../src/columns/column_recipes/column_discovered_recipe.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAoCa,kCAAkC,aAAa;mBAiDvC;mBACA;;;;;;;;;SAzCZ,QACL,KAAK,qBACL;IAAQ,MAAM;kBACD;;;;;;;SAiBR,eACL,KAAK,qBACL;IAAQ,MAAM;MACb;WAWM,IAAI;UACL;UACA;UACA;UAED;;;;;;EAYP,YAAY;;;;;EAQZ,oCAAoC;;;;;EAQpC,4BAA4B,SAAS,OAAO,WAAW;;;;;;;EAUvD,oBAAoB;;;;;;;;;EAYpB,WAAW;;EAWX,YAAY;EAOZ,iBAAiB;;;;;;EAmBjB,UAAU,WAAW,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;UA6B7B"}

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

@@ -2,7 +2,6 @@ import { GlobalCfgRenderCtx } from "../../render/internal.js";
 import { ColumnFieldStatus, ColumnResolutionStatus } from "./types.js";
 import { ColumnRecipe } from "./index.js";
 import { AxisFilterByIdx, ColumnFilteredId, ColumnFilteredKey, PColumnSpec, PObjectId, SpecOverrides, SpecQuery } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column_recipes/column_filtered_recipe.d.ts
 /**
  * Recipe wrapper that fixes the values of selected axes of an inner recipe
@@ -17,7 +16,7 @@ import { AxisFilterByIdx, ColumnFilteredId, ColumnFilteredKey, PColumnSpec, PObj
  * The reverse layering (`Filtered<Overridden<...>>`) is not reachable via
  * the public interface.
  */
-declare class ColumnFilteredRecipe implements ColumnRecipe<ColumnFilteredId> {
+export declare class ColumnFilteredRecipe implements ColumnRecipe<ColumnFilteredId> {
   private readonly inner;
   private readonly axisFilters;
   /**
@@ -71,5 +70,4 @@ declare class ColumnFilteredRecipe implements ColumnRecipe<ColumnFilteredId> {
   withSpecs(overrides: SpecOverrides): ColumnRecipe;
 }
 //#endregion
-export { ColumnFilteredRecipe };
 //# sourceMappingURL=column_filtered_recipe.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"column_filtered_recipe.d.ts","names":[],"sources":["../../../src/columns/column_recipes/column_filtered_recipe.ts"],"mappings":";;;;;;;;AAgCA;;;;;;;;;;;cAAa,oBAAA,YAAgC,YAAA,CAAa,gBAAA;EAAA,iBAiErC,KAAA;EAAA,iBACA,WAAA;EA8BR;;;;;;;;;;;;;EAAA,OAlFJ,IAAA,CAAK,GAAA,EAAK,YAAA,EAAc,WAAA,EAAa,eAAA,KAAoB,oBAAA;EAApB;;;;;EAAA,OAiCrC,cAAA,CACL,GAAA,EAAK,iBAAA,EACL,IAAA;IAAQ,GAAA,GAAM,kBAAA;EAAA,IACb,sBAAA;EAAA,SASM,EAAA,EAAI,gBAAA;EAAA,QACL,SAAA;EAAA,QACA,UAAA;EAAA,QACA,eAAA;EAAA,QAED,WAAA;EAHC;EAcR,QAAA,IAAY,YAAA;EAXL;EAgBP,gBAAA,IAAoB,SAAA;EAIpB,aAAA,IAAiB,iBAAA;EAJjB;;;;;EAgBA,OAAA,IAAW,WAAA;EAYX;;;;;EAAA,QAAA,IAAY,SAAA;EA6BqC;AAAA;;;EAAjD,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,YAAA;AAAA"}
+{"version":3,"file":"column_filtered_recipe.d.ts","names":[],"sources":["../../../src/columns/column_recipes/column_filtered_recipe.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAgCa,gCAAgC,aAAa;mBAiErC;mBACA;;;;;;;;;;;;;;SApDZ,KAAK,KAAK,cAAc,aAAa,oBAAoB;;;;;;SAiCzD,eACL,KAAK,mBACL;IAAQ,MAAM;MACb;WASM,IAAI;UACL;UACA;UACA;UAED;;EAWP,YAAY;;EAKZ,oBAAoB;EAIpB,iBAAiB;;;;;;EAYjB,WAAW;;;;;;EAYX,YAAY;;;;;EA6BZ,UAAU,WAAW,gBAAgB"}

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

@@ -1,9 +1,9 @@
 import { GlobalCfgRenderCtx } from "../../render/internal.js";
 import { ColumnFieldStatus, ColumnResolutionStatus } from "./types.js";
+import "../data_column.js";
 import { Column } from "../column.js";
 import { ColumnRecipe } from "./index.js";
 import { ColumnOverriddenId, ColumnOverriddenKey, ColumnUniversalId, PColumnSpec, PObjectId, SpecOverrides, SpecQuery } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column_recipes/column_overrided_recipe.d.ts
 /**
  * A recipe whose id is not an Overridden wrap — valid `source` for Overridden.
@@ -21,7 +21,7 @@ type NonOverriddenColumn = Column<Exclude<ColumnUniversalId, ColumnOverriddenId>
  * This invariant matches the one enforced inside `unwrapOverrides` from
  * pl-model-common: it explicitly throws on a nested override-wrap.
  */
-declare class ColumnOverriddenRecipe implements ColumnRecipe<ColumnOverriddenId> {
+export declare class ColumnOverriddenRecipe implements ColumnRecipe<ColumnOverriddenId> {
   private readonly inner;
   private readonly overrides;
   /**
@@ -96,5 +96,4 @@ declare class ColumnOverriddenRecipe implements ColumnRecipe<ColumnOverriddenId>
   withSpecs(overrides: SpecOverrides): Column;
 }
 //#endregion
-export { ColumnOverriddenRecipe };
 //# sourceMappingURL=column_overrided_recipe.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"column_overrided_recipe.d.ts","names":[],"sources":["../../../src/columns/column_recipes/column_overrided_recipe.ts"],"mappings":";;;;;;;;;AAgBmC;;KAO9B,mBAAA,GAAsB,MAAA,CAAO,OAAA,CAAQ,iBAAA,EAAmB,kBAAA;;;;;;;;;;;;cAahD,sBAAA,YAAkC,YAAA,CAAa,kBAAA;EAAA,iBAgEvC,KAAA;EAAA,iBACA,SAAA;;;;;;;SA1DZ,IAAA,CAAK,GAAA,EAAK,MAAA,EAAQ,SAAA,EAAW,aAAA,GAAgB,sBAAA;EA+CjD;;;;;;;;;;;;;;;;;;;;EAAA,eAjBY,KAAA;EA9BqB;;;;;EAAA,OA4C7B,cAAA,CACL,GAAA,EAAK,mBAAA,EACL,IAAA;IAAQ,GAAA,GAAM,kBAAA;EAAA,IACb,sBAAA;EAAA,SAIM,EAAA,EAAI,kBAAA;EAAA,QACL,SAAA;EAAA,QACA,UAAA;EAAA,QACA,eAAA;EAAA,UAEC,WAAA,CACU,KAAA,EAAO,mBAAA,EACP,SAAA,EAAW,aAAA;EANtB;EAeR,QAAA,IAAY,MAAA;EAbJ;;;;EAqBR,gBAAA,IAAoB,SAAA;EAIpB,aAAA,IAAiB,iBAAA;EAZjB;;;;EAuBA,OAAA,IAAW,WAAA;EAXM;;;;;;;;;;EA4BjB,QAAA,IAAY,SAAA;;;;;EAsBZ,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,MAAA;AAAA"}
+{"version":3,"file":"column_overrided_recipe.d.ts","names":[],"sources":["../../../src/columns/column_recipes/column_overrided_recipe.ts"],"mappings":";;;;;;;;;;;KAuBK,sBAAsB,OAAO,QAAQ,mBAAmB;;;;;;;;;;;;qBAahD,kCAAkC,aAAa;mBAgEvC;mBACA;;;;;;;SA1DZ,KAAK,KAAK,QAAQ,WAAW,gBAAgB;;;;;;;;;;;;;;;;;;;;;iBA8BrC;;;;;;SAcR,eACL,KAAK,qBACL;IAAQ,MAAM;MACb;WAIM,IAAI;UACL;UACA;UACA;YAEC,YACU,OAAO,qBACP,WAAW;;EAS9B,YAAY;;;;;EAQZ,oBAAoB;EAIpB,iBAAiB;;;;;EAWjB,WAAW;;;;;;;;;;;EAiBX,YAAY;;;;;EAsBZ,UAAU,WAAW,gBAAgB"}