@milaboratories/pl-model-common 1.47.3 → 1.49.0

package/dist/author_marker.d.ts

@@ -1,7 +1,7 @@
 //#region src/author_marker.d.ts
 /** Structure to help resolve conflicts if multiple participants writes to
  * the same state */
-interface AuthorMarker {
+export interface AuthorMarker {
   /** Unique identifier of client or even a specific window that sets this
    * particular state */
   authorId: string;
@@ -9,5 +9,4 @@ interface AuthorMarker {
   localVersion: number;
 }
 //#endregion
-export { AuthorMarker };
 //# sourceMappingURL=author_marker.d.ts.map

package/dist/author_marker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"author_marker.d.ts","names":[],"sources":["../src/author_marker.ts"],"mappings":";;AAEA;UAAiB,YAAA;;;EAGf,QAAA;;EAGA,YAAY;AAAA"}
+{"version":3,"file":"author_marker.d.ts","names":[],"sources":["../src/author_marker.ts"],"mappings":";;;iBAEiB;;;EAGf;;EAGA"}

package/dist/base64.d.ts

@@ -1,12 +1,10 @@
 import { WithImplicitCoercion } from "node:buffer";
-
 //#region src/base64.d.ts
-type Base64Compatible<T> = T extends WithImplicitCoercion<Uint8Array | readonly number[] | string> ? T : never;
-type Base64Encoded<T = unknown> = Base64Compatible<T> extends never ? never : string & {
+export type Base64Compatible<T> = T extends WithImplicitCoercion<Uint8Array | readonly number[] | string> ? T : never;
+export type Base64Encoded<T = unknown> = Base64Compatible<T> extends never ? never : string & {
   __base64_encoded: T;
 };
-declare function base64Encode<T>(value: Base64Compatible<T>): Base64Encoded<T>;
-declare function base64Decode<T extends string>(value: Base64Encoded<T>): T;
+export declare function base64Encode<T>(value: Base64Compatible<T>): Base64Encoded<T>;
+export declare function base64Decode<T extends string>(value: Base64Encoded<T>): T;
 //#endregion
-export { Base64Compatible, Base64Encoded, base64Decode, base64Encode };
 //# sourceMappingURL=base64.d.ts.map

package/dist/base64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base64.d.ts","names":[],"sources":["../src/base64.ts"],"mappings":";;;KAEY,gBAAA,MACV,CAAA,SAAU,oBAAA,CAAqB,UAAA,iCAA2C,CAAA;AAAA,KAEhE,aAAA,gBACV,gBAAA,CAAiB,CAAA;EAGX,gBAAA,EAAkB,CAAA;AAAA;AAAA,iBAGV,YAAA,IAAgB,KAAA,EAAO,gBAAA,CAAiB,CAAA,IAAK,aAAA,CAAc,CAAA;AAAA,iBAI3D,YAAA,mBAA+B,KAAA,EAAO,aAAA,CAAc,CAAA,IAAK,CAAA"}
+{"version":3,"file":"base64.d.ts","names":[],"sources":["../src/base64.ts"],"mappings":";;YAEY,iBAAiB,KAC3B,UAAU,qBAAqB,2CAA2C;YAEhE,cAAc,eACxB,iBAAiB;EAGX,kBAAkB;;wBAGV,aAAa,GAAG,OAAO,iBAAiB,KAAK,cAAc;wBAI3D,aAAa,kBAAkB,OAAO,cAAc,KAAK"}

package/dist/block_state.d.ts

@@ -2,7 +2,6 @@ import { AuthorMarker } from "./author_marker.js";
 import { BlockOutputsBase } from "./common_types.js";
 import { NavigationState } from "./navigation.js";
 import { StringifiedJson } from "./json.js";
-
 //#region src/block_state.d.ts
 /**
  * @template Args    sets type of block arguments passed to the workflow
@@ -12,21 +11,26 @@ import { StringifiedJson } from "./json.js";
  *                   to the workflow
  * @template Href    typed href to represent navigation state
  */
-type BlockState<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = {
-  /** Block arguments passed to the workflow */args: Args;
+export type BlockState<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = {
+  /** Block arguments passed to the workflow */
+  args: Args;
   /** UI State persisted in the block state but not passed to the backend
    * template */
-  ui: UiState; /** Outputs rendered with block config */
-  outputs: Outputs; /** Current navigation state */
+  ui: UiState;
+  /** Outputs rendered with block config */
+  outputs: Outputs;
+  /** Current navigation state */
   navigationState: NavigationState<Href>;
   readonly author: AuthorMarker | undefined;
 };
-type BlockStateV3<_Data = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, Href extends `/${string}` = `/${string}`> = {
-  /** Block storage persisted in the block state */blockStorage: StringifiedJson; /** Outputs rendered with block config */
-  outputs: Outputs; /** Current navigation state */
+export type BlockStateV3<_Data = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, Href extends `/${string}` = `/${string}`> = {
+  /** Block storage persisted in the block state */
+  blockStorage: StringifiedJson;
+  /** Outputs rendered with block config */
+  outputs: Outputs;
+  /** Current navigation state */
   navigationState: NavigationState<Href>;
   readonly author: AuthorMarker | undefined;
 };
 //#endregion
-export { BlockState, BlockStateV3 };
 //# sourceMappingURL=block_state.d.ts.map

package/dist/block_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_state.d.ts","names":[],"sources":["../src/block_state.ts"],"mappings":";;;;;;;;AAaA;;;;;;KAAY,UAAA,iCAEM,gBAAA,GAAmB,gBAAA;EAY1B,6CAPT,IAAA,EAAM,IAAA;EAUW;;EANjB,EAAA,EAAI,OAAA,EAQyB;EAL7B,OAAA,EAAS,OAAA,EAZT;EAeA,eAAA,EAAiB,eAAA,CAAgB,IAAA;EAAA,SAExB,MAAA,EAAQ,YAAA;AAAA;AAAA,KAGP,YAAA,kCAEM,gBAAA,GAAmB,gBAAA;EAjBnC,iDAqBA,YAAA,EAAc,eAAA,EAjBd;EAoBA,OAAA,EAAS,OAAA,EAjBT;EAoBA,eAAA,EAAiB,eAAA,CAAgB,IAAA;EAAA,SAExB,MAAA,EAAQ,YAAA;AAAA"}
+{"version":3,"file":"block_state.d.ts","names":[],"sources":["../src/block_state.ts"],"mappings":";;;;;;;;;;;;;YAaY,WACV,gBACA,gBAAgB,mBAAmB,kBACnC,mBACA;;EAGA,MAAM;;;EAIN,IAAI;;EAGJ,SAAS;;EAGT,iBAAiB,gBAAgB;WAExB,QAAQ;;YAGP,aACV,iBACA,gBAAgB,mBAAmB,kBACnC;;EAGA,cAAc;;EAGd,SAAS;;EAGT,iBAAiB,gBAAgB;WAExB,QAAQ"}

package/dist/bmodel/block_config.d.ts

@@ -1,41 +1,57 @@
 import { BlockCodeFeatureFlags } from "../flags/block_flags.js";
+import "../flags/index.js";
 import { BlockCodeWithInfo, Code } from "./code.js";
 import { BlockRenderingMode } from "./types.js";
-
 //#region src/bmodel/block_config.d.ts
 /**
  * BroadActiveHandleDescriptor = TypedConfigOrConfigLambda,
  * NarrowActiveHandleDescriptor = ConfigRenderLambda
  */
-type BlockConfigV4Generic<_Args = unknown, _Data extends Record<string, unknown> = Record<string, unknown>, BroadActiveHandleDescriptor = unknown, NarrowActiveHandleDescriptor extends BroadActiveHandleDescriptor = BroadActiveHandleDescriptor, Outputs extends Record<string, BroadActiveHandleDescriptor> = Record<string, BroadActiveHandleDescriptor>> = {
-  /** Discriminator to identify config version */readonly configVersion: 4;
-  readonly modelAPIVersion: 2; /** SDK version used by the block */
-  readonly sdkVersion: string; /** Main rendering mode for the block */
-  readonly renderingMode: BlockRenderingMode; /** Lambda to derive list of sections for the left overview panel */
-  readonly sections: NarrowActiveHandleDescriptor; /** Lambda to derive block title */
-  readonly title?: NarrowActiveHandleDescriptor; /** Lambda to derive block subtitle, shown below the title */
-  readonly subtitle?: NarrowActiveHandleDescriptor; /** Lambda returning array of tags for search functionality */
+export type BlockConfigV4Generic<_Args = unknown, _Data extends Record<string, unknown> = Record<string, unknown>, BroadActiveHandleDescriptor = unknown, NarrowActiveHandleDescriptor extends BroadActiveHandleDescriptor = BroadActiveHandleDescriptor, Outputs extends Record<string, BroadActiveHandleDescriptor> = Record<string, BroadActiveHandleDescriptor>> = {
+  /** Discriminator to identify config version */
+  readonly configVersion: 4;
+  readonly modelAPIVersion: 2;
+  /** SDK version used by the block */
+  readonly sdkVersion: string;
+  /** Main rendering mode for the block */
+  readonly renderingMode: BlockRenderingMode;
+  /** Lambda to derive list of sections for the left overview panel */
+  readonly sections: NarrowActiveHandleDescriptor;
+  /** Lambda to derive block title */
+  readonly title?: NarrowActiveHandleDescriptor;
+  /** Lambda to derive block subtitle, shown below the title */
+  readonly subtitle?: NarrowActiveHandleDescriptor;
+  /** Lambda returning array of tags for search functionality */
   readonly tags?: BroadActiveHandleDescriptor;
   /**
    * Lambda returning list of upstream blocks this block enriches with its exports,
    * influences dependency graph construction
    * */
-  readonly enrichmentTargets?: NarrowActiveHandleDescriptor; /** Configuration for the output cells */
-  readonly outputs: Outputs; /** Config code bundle */
-  readonly code?: Code; /** Feature flags for the block Model and UI code. */
-  readonly featureFlags?: BlockCodeFeatureFlags; /** Facade callbacks supported by this block (for pre-execution validation) */
+  readonly enrichmentTargets?: NarrowActiveHandleDescriptor;
+  /** Configuration for the output cells */
+  readonly outputs: Outputs;
+  /** Config code bundle */
+  readonly code?: Code;
+  /** Feature flags for the block Model and UI code. */
+  readonly featureFlags?: BlockCodeFeatureFlags;
+  /** Facade callbacks supported by this block (for pre-execution validation) */
   readonly blockLifecycleCallbacks: Record<string, NarrowActiveHandleDescriptor>;
 };
 /**
  * BroadActiveHandleDescriptor = TypedConfigOrConfigLambda,
  * NarrowActiveHandleDescriptor = ConfigRenderLambda
  */
-type BlockConfigV3Generic<Args = unknown, UiState = unknown, BroadActiveHandleDescriptor = unknown, NarrowActiveHandleDescriptor extends BroadActiveHandleDescriptor = BroadActiveHandleDescriptor, Outputs extends Record<string, BroadActiveHandleDescriptor> = Record<string, BroadActiveHandleDescriptor>> = {
-  /** Discriminator to identify config version */readonly configVersion: 3;
-  readonly modelAPIVersion: 1; /** SDK version used by the block */
-  readonly sdkVersion: string; /** Main rendering mode for the block */
-  readonly renderingMode: BlockRenderingMode; /** Initial value for the args when block is added to the project */
-  readonly initialArgs: Args; /** Initial value for the args when block is added to the project */
+export type BlockConfigV3Generic<Args = unknown, UiState = unknown, BroadActiveHandleDescriptor = unknown, NarrowActiveHandleDescriptor extends BroadActiveHandleDescriptor = BroadActiveHandleDescriptor, Outputs extends Record<string, BroadActiveHandleDescriptor> = Record<string, BroadActiveHandleDescriptor>> = {
+  /** Discriminator to identify config version */
+  readonly configVersion: 3;
+  readonly modelAPIVersion: 1;
+  /** SDK version used by the block */
+  readonly sdkVersion: string;
+  /** Main rendering mode for the block */
+  readonly renderingMode: BlockRenderingMode;
+  /** Initial value for the args when block is added to the project */
+  readonly initialArgs: Args;
+  /** Initial value for the args when block is added to the project */
   readonly initialUiState: UiState;
   /**
    * Config to determine whether the block can be executed with current
@@ -43,22 +59,28 @@ type BlockConfigV3Generic<Args = unknown, UiState = unknown, BroadActiveHandleDe
    *
    * Optional to support earlier SDK version configs.
    */
-  readonly inputsValid: BroadActiveHandleDescriptor; /** Configuration to derive list of section for the left overview panel */
-  readonly sections: BroadActiveHandleDescriptor; /** Lambda to derive block title */
-  readonly title?: NarrowActiveHandleDescriptor; /** Lambda to derive block subtitle, shown below the title */
-  readonly subtitle?: NarrowActiveHandleDescriptor; /** Lambda returning array of tags for search functionality */
+  readonly inputsValid: BroadActiveHandleDescriptor;
+  /** Configuration to derive list of section for the left overview panel */
+  readonly sections: BroadActiveHandleDescriptor;
+  /** Lambda to derive block title */
+  readonly title?: NarrowActiveHandleDescriptor;
+  /** Lambda to derive block subtitle, shown below the title */
+  readonly subtitle?: NarrowActiveHandleDescriptor;
+  /** Lambda returning array of tags for search functionality */
   readonly tags?: BroadActiveHandleDescriptor;
   /**
    * Lambda returning list of upstream blocks this block enriches with its exports,
    * influences dependency graph construction
    */
-  readonly enrichmentTargets?: NarrowActiveHandleDescriptor; /** Configuration for the output cells */
-  readonly outputs: Outputs; /** Config code bundle */
-  readonly code?: Code; /** Feature flags for the block Model and UI code. */
+  readonly enrichmentTargets?: NarrowActiveHandleDescriptor;
+  /** Configuration for the output cells */
+  readonly outputs: Outputs;
+  /** Config code bundle */
+  readonly code?: Code;
+  /** Feature flags for the block Model and UI code. */
   readonly featureFlags?: BlockCodeFeatureFlags;
 };
-type BlockConfigGeneric = BlockConfigV3Generic | BlockConfigV4Generic;
-declare function extractCodeWithInfo(cfg: BlockConfigGeneric): BlockCodeWithInfo;
+export type BlockConfigGeneric = BlockConfigV3Generic | BlockConfigV4Generic;
+export declare function extractCodeWithInfo(cfg: BlockConfigGeneric): BlockCodeWithInfo;
 //#endregion
-export { BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, extractCodeWithInfo };
 //# sourceMappingURL=block_config.d.ts.map

package/dist/bmodel/block_config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_config.d.ts","names":[],"sources":["../../src/bmodel/block_config.ts"],"mappings":";;;;;;;;AAUA;KAAY,oBAAA,gCAEI,MAAA,oBAA0B,MAAA,+FAEH,2BAAA,GAA8B,2BAAA,kBACnD,MAAA,SAAe,2BAAA,IAA+B,MAAA,SAE5D,2BAAA;EAP4B,wDAWrB,aAAA;EAAA,SAEA,eAAA,KAT4B;EAAA,SAY5B,UAAA,UAXsB;EAAA,SActB,aAAA,EAAe,kBAAA,EAZtB;EAAA,SAeO,QAAA,EAAU,4BAAA,EAHK;EAAA,SAMf,KAAA,GAAQ,4BAAA,EAAA;EAAA,SAGR,QAAA,GAAW,4BAAA,EAGJ;EAAA,SAAP,IAAA,GAAO,2BAAA;EASE;;;;EAAA,SAHT,iBAAA,GAAoB,4BAAA,EAYW;EAAA,SAT/B,OAAA,EAAS,OAAA,EAvClB;EAAA,SA0CS,IAAA,GAAO,IAAA,EAzCF;EAAA,SA4CL,YAAA,GAAe,qBAAA,EA3CxB;EAAA,SA8CS,uBAAA,EAAyB,MAAA,SAAe,4BAAA;AAAA;;;;;KAOvC,oBAAA,gHAI2B,2BAAA,GAA8B,2BAAA,kBACnD,MAAA,SAAe,2BAAA,IAA+B,MAAA,SAE5D,2BAAA;EAxDA,wDA4DO,aAAA;EAAA,SAEA,eAAA,KArDA;EAAA,SAwDA,UAAA,UArDe;EAAA,SAwDf,aAAA,EAAe,kBAAA,EArDL;EAAA,SAwDV,WAAA,EAAa,IAAA,EArDL;EAAA,SAwDR,cAAA,EAAgB,OAAA;EArDL;;;;;;EAAA,SA6DX,WAAA,EAAa,2BAAA,EA9Cb;EAAA,SAiDA,QAAA,EAAU,2BAAA,EA9CV;EAAA,SAiDA,KAAA,GAAQ,4BAAA,EA9CR;EAAA,SAiDA,QAAA,GAAW,4BAAA,EAjD6B;EAAA,SAoDxC,IAAA,GAAO,2BAAA;EApD6D;AAO/E;;;EAP+E,SA0DpE,iBAAA,GAAoB,4BAAA,EA/CsC;EAAA,SAkD1D,OAAA,EAAS,OAAA,EAjDF;EAAA,SAoDP,IAAA,GAAO,IAAA,EApD8C;EAAA,SAuDrD,YAAA,GAAe,qBAAA;AAAA;AAAA,KAGd,kBAAA,GAAqB,oBAAA,GAAuB,oBAAoB;AAAA,iBAE5D,mBAAA,CAAoB,GAAA,EAAK,kBAAA,GAAqB,iBAAiB"}
+{"version":3,"file":"block_config.d.ts","names":[],"sources":["../../src/bmodel/block_config.ts"],"mappings":";;;;;;;;;YAUY,qBACV,iBACA,cAAc,0BAA0B,yBACxC,uCACA,qCAAqC,8BAA8B,6BACnE,gBAAgB,eAAe,+BAA+B,eAE5D;;WAIO;WAEA;;WAGA;;WAGA,eAAe;;WAGf,UAAU;;WAGV,QAAQ;;WAGR,WAAW;;WAGX,OAAO;;;;;WAMP,oBAAoB;;WAGpB,SAAS;;WAGT,OAAO;;WAGP,eAAe;;WAGf,yBAAyB,eAAe;;;;;;YAOvC,qBACV,gBACA,mBACA,uCACA,qCAAqC,8BAA8B,6BACnE,gBAAgB,eAAe,+BAA+B,eAE5D;;WAIO;WAEA;;WAGA;;WAGA,eAAe;;WAGf,aAAa;;WAGb,gBAAgB;;;;;;;WAQhB,aAAa;;WAGb,UAAU;;WAGV,QAAQ;;WAGR,WAAW;;WAGX,OAAO;;;;;WAMP,oBAAoB;;WAGpB,SAAS;;WAGT,OAAO;;WAGP,eAAe;;YAGd,qBAAqB,uBAAuB;wBAExC,oBAAoB,KAAK,qBAAqB"}

package/dist/bmodel/block_kind_ref.cjs

@@ -0,0 +1,45 @@
+//#region src/bmodel/block_kind_ref.ts
+/**
+* Compose a {@link BlockKindReference} from a kind's `name`/`version`.
+*
+* The single place that decides how the reference is assembled. If global
+* uniqueness later requires the name segment to be org-qualified, this is the
+* one line that changes.
+*/
+const formatKindRef = (k) => `${k.name}@${k.version}`;
+/**
+* Split a `{name}@{version}` string on its version separator.
+*
+* The one place that decides where the name ends. Uses the LAST `@` so an
+* org-qualified npm name that itself starts with `@` (e.g.
+* `@platforma-open/pkg.kind`) keeps its whole name. A leading/absent separator
+* (`lastIndexOf("@") <= 0`) means the string carries no version segment —
+* malformed — so this throws rather than returning a silently version-less
+* result.
+*
+* Shared with the template layer, whose `{name}@{selector}` references use the
+* same split and differ only in how the right half is interpreted (see
+* `parseKindSelectorReference`). `what` names the thing being parsed so the
+* error message stays specific to the caller's reference type.
+*/
+const splitVersionedName = (ref, what = "block kind reference", expected = "{name}@{version}") => {
+	const at = ref.lastIndexOf("@");
+	if (at <= 0) throw new Error(`Malformed ${what} (expected '${expected}'): ${ref}`);
+	return {
+		name: ref.slice(0, at),
+		version: ref.slice(at + 1)
+	};
+};
+/**
+* Split a {@link BlockKindReference} back into `{ name, version }`.
+*
+* Throws on a reference with no version segment — see
+* {@link splitVersionedName}, which owns the split rule.
+*/
+const parseKindRef = (ref) => splitVersionedName(ref);
+//#endregion
+exports.formatKindRef = formatKindRef;
+exports.parseKindRef = parseKindRef;
+exports.splitVersionedName = splitVersionedName;
+
+//# sourceMappingURL=block_kind_ref.cjs.map

package/dist/bmodel/block_kind_ref.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_kind_ref.cjs","names":[],"sources":["../../src/bmodel/block_kind_ref.ts"],"sourcesContent":["import type { Branded } from \"@milaboratories/helpers\";\n\n/**\n * On-wire reference to a block kind, canonically the string `{name}@{version}`.\n *\n * A branded string: readers overwhelmingly need identity equality (\"does block\n * X implement kind Y?\"), for which an opaque canonical string is ideal. Any\n * reader that needs the parts calls {@link parseKindRef}; any writer composes\n * the reference through {@link formatKindRef}. Keeping composition in a single\n * function localizes the one open decision — whether the name segment has to be\n * org-qualified for global uniqueness — to one place.\n */\nexport type BlockKindReference = Branded<string, \"BlockKindReference\">;\n\n/**\n * Compose a {@link BlockKindReference} from a kind's `name`/`version`.\n *\n * The single place that decides how the reference is assembled. If global\n * uniqueness later requires the name segment to be org-qualified, this is the\n * one line that changes.\n */\nexport const formatKindRef = (k: { name: string; version: string }): BlockKindReference =>\n  `${k.name}@${k.version}` as BlockKindReference;\n\n/**\n * Split a `{name}@{version}` string on its version separator.\n *\n * The one place that decides where the name ends. Uses the LAST `@` so an\n * org-qualified npm name that itself starts with `@` (e.g.\n * `@platforma-open/pkg.kind`) keeps its whole name. A leading/absent separator\n * (`lastIndexOf(\"@\") <= 0`) means the string carries no version segment —\n * malformed — so this throws rather than returning a silently version-less\n * result.\n *\n * Shared with the template layer, whose `{name}@{selector}` references use the\n * same split and differ only in how the right half is interpreted (see\n * `parseKindSelectorReference`). `what` names the thing being parsed so the\n * error message stays specific to the caller's reference type.\n */\nexport const splitVersionedName = (\n  ref: string,\n  what = \"block kind reference\",\n  expected = \"{name}@{version}\",\n): { name: string; version: string } => {\n  const at = ref.lastIndexOf(\"@\");\n  if (at <= 0) {\n    throw new Error(`Malformed ${what} (expected '${expected}'): ${ref}`);\n  }\n  return { name: ref.slice(0, at), version: ref.slice(at + 1) };\n};\n\n/**\n * Split a {@link BlockKindReference} back into `{ name, version }`.\n *\n * Throws on a reference with no version segment — see\n * {@link splitVersionedName}, which owns the split rule.\n */\nexport const parseKindRef = (ref: BlockKindReference): { name: string; version: string } =>\n  splitVersionedName(ref);\n"],"mappings":";;;;;;;;AAqBA,MAAa,iBAAiB,MAC5B,GAAG,EAAE,KAAK,GAAG,EAAE;;;;;;;;;;;;;;;;AAiBjB,MAAa,sBACX,KACA,OAAO,wBACP,WAAW,uBAC2B;CACtC,MAAM,KAAK,IAAI,YAAY,GAAG;CAC9B,IAAI,MAAM,GACR,MAAM,IAAI,MAAM,aAAa,KAAK,cAAc,SAAS,MAAM,KAAK;CAEtE,OAAO;EAAE,MAAM,IAAI,MAAM,GAAG,EAAE;EAAG,SAAS,IAAI,MAAM,KAAK,CAAC;CAAE;AAC9D;;;;;;;AAQA,MAAa,gBAAgB,QAC3B,mBAAmB,GAAG"}

package/dist/bmodel/block_kind_ref.d.ts

@@ -0,0 +1,55 @@
+import { Branded } from "@milaboratories/helpers";
+//#region src/bmodel/block_kind_ref.d.ts
+/**
+ * On-wire reference to a block kind, canonically the string `{name}@{version}`.
+ *
+ * A branded string: readers overwhelmingly need identity equality ("does block
+ * X implement kind Y?"), for which an opaque canonical string is ideal. Any
+ * reader that needs the parts calls {@link parseKindRef}; any writer composes
+ * the reference through {@link formatKindRef}. Keeping composition in a single
+ * function localizes the one open decision — whether the name segment has to be
+ * org-qualified for global uniqueness — to one place.
+ */
+export type BlockKindReference = Branded<string, "BlockKindReference">;
+/**
+ * Compose a {@link BlockKindReference} from a kind's `name`/`version`.
+ *
+ * The single place that decides how the reference is assembled. If global
+ * uniqueness later requires the name segment to be org-qualified, this is the
+ * one line that changes.
+ */
+export declare const formatKindRef: (k: {
+  name: string;
+  version: string;
+}) => BlockKindReference;
+/**
+ * Split a `{name}@{version}` string on its version separator.
+ *
+ * The one place that decides where the name ends. Uses the LAST `@` so an
+ * org-qualified npm name that itself starts with `@` (e.g.
+ * `@platforma-open/pkg.kind`) keeps its whole name. A leading/absent separator
+ * (`lastIndexOf("@") <= 0`) means the string carries no version segment —
+ * malformed — so this throws rather than returning a silently version-less
+ * result.
+ *
+ * Shared with the template layer, whose `{name}@{selector}` references use the
+ * same split and differ only in how the right half is interpreted (see
+ * `parseKindSelectorReference`). `what` names the thing being parsed so the
+ * error message stays specific to the caller's reference type.
+ */
+export declare const splitVersionedName: (ref: string, what?: string, expected?: string) => {
+  name: string;
+  version: string;
+};
+/**
+ * Split a {@link BlockKindReference} back into `{ name, version }`.
+ *
+ * Throws on a reference with no version segment — see
+ * {@link splitVersionedName}, which owns the split rule.
+ */
+export declare const parseKindRef: (ref: BlockKindReference) => {
+  name: string;
+  version: string;
+};
+//#endregion
+//# sourceMappingURL=block_kind_ref.d.ts.map

package/dist/bmodel/block_kind_ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_kind_ref.d.ts","names":[],"sources":["../../src/bmodel/block_kind_ref.ts"],"mappings":";;;;;;;;;;;;YAYY,qBAAqB;;;;;;;;qBASpB,gBAAa;EAAS;EAAc;MAAoB;;;;;;;;;;;;;;;;qBAkBxD,qBAAkB,aAClB,eAAA;EAGR;EAAc;;;;;;;;qBAcN,eAAY,KAAS;EAAuB;EAAc"}

package/dist/bmodel/block_kind_ref.js

@@ -0,0 +1,43 @@
+//#region src/bmodel/block_kind_ref.ts
+/**
+* Compose a {@link BlockKindReference} from a kind's `name`/`version`.
+*
+* The single place that decides how the reference is assembled. If global
+* uniqueness later requires the name segment to be org-qualified, this is the
+* one line that changes.
+*/
+const formatKindRef = (k) => `${k.name}@${k.version}`;
+/**
+* Split a `{name}@{version}` string on its version separator.
+*
+* The one place that decides where the name ends. Uses the LAST `@` so an
+* org-qualified npm name that itself starts with `@` (e.g.
+* `@platforma-open/pkg.kind`) keeps its whole name. A leading/absent separator
+* (`lastIndexOf("@") <= 0`) means the string carries no version segment —
+* malformed — so this throws rather than returning a silently version-less
+* result.
+*
+* Shared with the template layer, whose `{name}@{selector}` references use the
+* same split and differ only in how the right half is interpreted (see
+* `parseKindSelectorReference`). `what` names the thing being parsed so the
+* error message stays specific to the caller's reference type.
+*/
+const splitVersionedName = (ref, what = "block kind reference", expected = "{name}@{version}") => {
+	const at = ref.lastIndexOf("@");
+	if (at <= 0) throw new Error(`Malformed ${what} (expected '${expected}'): ${ref}`);
+	return {
+		name: ref.slice(0, at),
+		version: ref.slice(at + 1)
+	};
+};
+/**
+* Split a {@link BlockKindReference} back into `{ name, version }`.
+*
+* Throws on a reference with no version segment — see
+* {@link splitVersionedName}, which owns the split rule.
+*/
+const parseKindRef = (ref) => splitVersionedName(ref);
+//#endregion
+export { formatKindRef, parseKindRef, splitVersionedName };
+
+//# sourceMappingURL=block_kind_ref.js.map

package/dist/bmodel/block_kind_ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_kind_ref.js","names":[],"sources":["../../src/bmodel/block_kind_ref.ts"],"sourcesContent":["import type { Branded } from \"@milaboratories/helpers\";\n\n/**\n * On-wire reference to a block kind, canonically the string `{name}@{version}`.\n *\n * A branded string: readers overwhelmingly need identity equality (\"does block\n * X implement kind Y?\"), for which an opaque canonical string is ideal. Any\n * reader that needs the parts calls {@link parseKindRef}; any writer composes\n * the reference through {@link formatKindRef}. Keeping composition in a single\n * function localizes the one open decision — whether the name segment has to be\n * org-qualified for global uniqueness — to one place.\n */\nexport type BlockKindReference = Branded<string, \"BlockKindReference\">;\n\n/**\n * Compose a {@link BlockKindReference} from a kind's `name`/`version`.\n *\n * The single place that decides how the reference is assembled. If global\n * uniqueness later requires the name segment to be org-qualified, this is the\n * one line that changes.\n */\nexport const formatKindRef = (k: { name: string; version: string }): BlockKindReference =>\n  `${k.name}@${k.version}` as BlockKindReference;\n\n/**\n * Split a `{name}@{version}` string on its version separator.\n *\n * The one place that decides where the name ends. Uses the LAST `@` so an\n * org-qualified npm name that itself starts with `@` (e.g.\n * `@platforma-open/pkg.kind`) keeps its whole name. A leading/absent separator\n * (`lastIndexOf(\"@\") <= 0`) means the string carries no version segment —\n * malformed — so this throws rather than returning a silently version-less\n * result.\n *\n * Shared with the template layer, whose `{name}@{selector}` references use the\n * same split and differ only in how the right half is interpreted (see\n * `parseKindSelectorReference`). `what` names the thing being parsed so the\n * error message stays specific to the caller's reference type.\n */\nexport const splitVersionedName = (\n  ref: string,\n  what = \"block kind reference\",\n  expected = \"{name}@{version}\",\n): { name: string; version: string } => {\n  const at = ref.lastIndexOf(\"@\");\n  if (at <= 0) {\n    throw new Error(`Malformed ${what} (expected '${expected}'): ${ref}`);\n  }\n  return { name: ref.slice(0, at), version: ref.slice(at + 1) };\n};\n\n/**\n * Split a {@link BlockKindReference} back into `{ name, version }`.\n *\n * Throws on a reference with no version segment — see\n * {@link splitVersionedName}, which owns the split rule.\n */\nexport const parseKindRef = (ref: BlockKindReference): { name: string; version: string } =>\n  splitVersionedName(ref);\n"],"mappings":";;;;;;;;AAqBA,MAAa,iBAAiB,MAC5B,GAAG,EAAE,KAAK,GAAG,EAAE;;;;;;;;;;;;;;;;AAiBjB,MAAa,sBACX,KACA,OAAO,wBACP,WAAW,uBAC2B;CACtC,MAAM,KAAK,IAAI,YAAY,GAAG;CAC9B,IAAI,MAAM,GACR,MAAM,IAAI,MAAM,aAAa,KAAK,cAAc,SAAS,MAAM,KAAK;CAEtE,OAAO;EAAE,MAAM,IAAI,MAAM,GAAG,EAAE;EAAG,SAAS,IAAI,MAAM,KAAK,CAAC;CAAE;AAC9D;;;;;;;AAQA,MAAa,gBAAgB,QAC3B,mBAAmB,GAAG"}

package/dist/bmodel/code.d.ts

@@ -1,8 +1,8 @@
 import { BlockCodeFeatureFlags } from "../flags/block_flags.js";
+import "../flags/index.js";
 import { z } from "zod";
-
 //#region src/bmodel/code.d.ts
-declare const Code: z.ZodObject<{
+export declare const Code: z.ZodObject<{
   type: z.ZodLiteral<"plain">;
   content: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -12,12 +12,11 @@ declare const Code: z.ZodObject<{
   type: "plain";
   content: string;
 }>;
-type Code = z.infer<typeof Code>;
-type BlockCodeWithInfo = {
+export type Code = z.infer<typeof Code>;
+export type BlockCodeWithInfo = {
   readonly code: Code;
   readonly sdkVersion: string;
   readonly featureFlags: BlockCodeFeatureFlags | undefined;
 };
 //#endregion
-export { BlockCodeWithInfo, Code };
 //# sourceMappingURL=code.d.ts.map

package/dist/bmodel/code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code.d.ts","names":[],"sources":["../../src/bmodel/code.ts"],"mappings":";;;;cAGa,IAAA,EAAI,CAAA,CAAA,SAAA;;;;;;;;;;KAKL,IAAA,GAAO,CAAA,CAAE,KAAK,QAAQ,IAAA;AAAA,KAEtB,iBAAA;EAAA,SACD,IAAA,EAAM,IAAA;EAAA,SACN,UAAA;EAAA,SACA,YAAA,EAAc,qBAAqB;AAAA"}
+{"version":3,"file":"code.d.ts","names":[],"sources":["../../src/bmodel/code.ts"],"mappings":";;;;qBAGa,MAAI,EAAA;;;;;;;;;;YAKL,OAAO,EAAE,aAAa;YAEtB;WACD,MAAM;WACN;WACA,cAAc"}

package/dist/bmodel/container.d.ts

@@ -1,13 +1,22 @@
 import { Code } from "./code.js";
 import { BlockRenderingMode } from "./types.js";
 import { BlockConfigV3Generic, BlockConfigV4Generic } from "./block_config.js";
-
+import { BlockKindReference } from "./block_kind_ref.js";
 //#region src/bmodel/container.d.ts
 /** Container simplifying maintenance of forward and backward compatibility */
-type BlockConfigContainer = {
-  readonly v4?: Omit<BlockConfigV4Generic, "code">; /** Actual config */
-  readonly v3?: Omit<BlockConfigV3Generic, "code">; /** Config code bundle. Actually is required, but we keep it optional for backward compatibility */
+export type BlockConfigContainer = {
+  readonly v4?: Omit<BlockConfigV4Generic, "code">;
+  /** Actual config */
+  readonly v3?: Omit<BlockConfigV3Generic, "code">;
+  /** Config code bundle. Actually is required, but we keep it optional for backward compatibility */
   readonly code?: Code;
+  /**
+   * Reference to the block kind this config implements, in `{name}@{version}`
+   * form. Version-independent block identity — lives at the container level
+   * beside {@link code}, orthogonal to which render envelope (`v3`/`v4`)
+   * applies. Optional for backward compatibility with kind-less blocks.
+   */
+  readonly kind?: BlockKindReference;
   /**
    * For backward compatibility
    * @deprecated
@@ -45,5 +54,4 @@ type BlockConfigContainer = {
   readonly outputs?: Record<string, unknown>;
 };
 //#endregion
-export { BlockConfigContainer };
 //# sourceMappingURL=container.d.ts.map

package/dist/bmodel/container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"container.d.ts","names":[],"sources":["../../src/bmodel/container.ts"],"mappings":";;;;;;KAKY,oBAAA;EAAA,SACD,EAAA,GAAK,IAAA,CAAK,oBAAA,WADW;EAAA,SAGrB,EAAA,GAAK,IAAA,CAAK,oBAAA,WAFA;EAAA,SAKV,IAAA,GAAO,IAAA;EAHG;;;;EAAA,SAaV,UAAA;EAoCgB;;;;EAAA,SA9BhB,aAAA,GAAgB,kBAAA;EAnBhB;;;;EAAA,SAyBA,WAAA;EAZA;;;;EAAA,SAkBA,MAAA;EAMA;;;;EAAA,SAAA,WAAA;EAYgB;;;;EAAA,SANhB,QAAA;;;;;WAMA,OAAA,GAAU,MAAA;AAAA"}
+{"version":3,"file":"container.d.ts","names":[],"sources":["../../src/bmodel/container.ts"],"mappings":";;;;;;YAMY;WACD,KAAK,KAAK;;WAEV,KAAK,KAAK;;WAGV,OAAO;;;;;;;WAQP,OAAO;;;;;WAUP;;;;;WAMA,gBAAgB;;;;;WAMhB;;;;;WAMA;;;;;WAMA;;;;;WAMA;;;;;WAMA,UAAU"}

package/dist/bmodel/index.cjs

@@ -1,6 +1,10 @@
 const require_block_config = require("./block_config.cjs");
 const require_code = require("./code.cjs");
+const require_block_kind_ref = require("./block_kind_ref.cjs");
 const require_normalization = require("./normalization.cjs");
 exports.Code = require_code.Code;
 exports.extractCodeWithInfo = require_block_config.extractCodeWithInfo;
 exports.extractConfigGeneric = require_normalization.extractConfigGeneric;
+exports.formatKindRef = require_block_kind_ref.formatKindRef;
+exports.parseKindRef = require_block_kind_ref.parseKindRef;
+exports.splitVersionedName = require_block_kind_ref.splitVersionedName;

package/dist/bmodel/index.d.ts

@@ -1,6 +1,7 @@
 import { BlockCodeWithInfo, Code } from "./code.js";
 import { BlockRenderingMode } from "./types.js";
 import { BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, extractCodeWithInfo } from "./block_config.js";
+import { BlockKindReference, formatKindRef, parseKindRef, splitVersionedName } from "./block_kind_ref.js";
 import { BlockConfigContainer } from "./container.js";
 import { extractConfigGeneric } from "./normalization.js";
-export { BlockCodeWithInfo, BlockConfigContainer, BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, BlockRenderingMode, Code, extractCodeWithInfo, extractConfigGeneric };
+export { BlockCodeWithInfo, BlockConfigContainer, BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, BlockKindReference, BlockRenderingMode, Code, extractCodeWithInfo, extractConfigGeneric, formatKindRef, parseKindRef, splitVersionedName };

package/dist/bmodel/index.js

@@ -1,4 +1,5 @@
 import { extractCodeWithInfo } from "./block_config.js";
 import { Code } from "./code.js";
+import { formatKindRef, parseKindRef, splitVersionedName } from "./block_kind_ref.js";
 import { extractConfigGeneric } from "./normalization.js";
-export { Code, extractCodeWithInfo, extractConfigGeneric };
+export { Code, extractCodeWithInfo, extractConfigGeneric, formatKindRef, parseKindRef, splitVersionedName };

package/dist/bmodel/normalization.d.ts

@@ -1,6 +1,5 @@
 import { BlockConfigGeneric } from "./block_config.js";
 import { BlockConfigContainer } from "./container.js";
-
 //#region src/bmodel/normalization.d.ts
 /**
  * Takes universal config, and converts it into latest config structure.
@@ -8,7 +7,6 @@ import { BlockConfigContainer } from "./container.js";
  * **Important**: This operation is not meant to be executed recursively.
  *                In no circumstance result of this function should be persisted!
  * */
-declare function extractConfigGeneric(cfg: BlockConfigContainer): BlockConfigGeneric;
+export declare function extractConfigGeneric(cfg: BlockConfigContainer): BlockConfigGeneric;
 //#endregion
-export { extractConfigGeneric };
 //# sourceMappingURL=normalization.d.ts.map

package/dist/bmodel/normalization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalization.d.ts","names":[],"sources":["../../src/bmodel/normalization.ts"],"mappings":";;;;;;AAiBA;;;;iBAAgB,oBAAA,CAAqB,GAAA,EAAK,oBAAA,GAAuB,kBAAkB"}
+{"version":3,"file":"normalization.d.ts","names":[],"sources":["../../src/bmodel/normalization.ts"],"mappings":";;;;;;;;;wBAiBgB,qBAAqB,KAAK,uBAAuB"}

package/dist/bmodel/types.d.ts

@@ -1,5 +1,4 @@
 //#region src/bmodel/types.d.ts
-type BlockRenderingMode = "Light" | "Heavy" | "DualContextHeavy";
+export type BlockRenderingMode = "Light" | "Heavy" | "DualContextHeavy";
 //#endregion
-export { BlockRenderingMode };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/bmodel/types.ts"],"mappings":";KAAY,kBAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/bmodel/types.ts"],"mappings":";YAAY"}

package/dist/branding.d.ts

@@ -1,6 +1,5 @@
 //#region src/branding.d.ts
-type Brand<B, K extends string = "__pl_model_brand__"> = { [key in K]: B };
-type Branded<T, B, K extends string = "__pl_model_brand__"> = T & Brand<B, K>;
+type Brand<B, K extends string = "__pl_model_brand__"> = { [key in K]: B; };
+export type Branded<T, B, K extends string = "__pl_model_brand__"> = T & Brand<B, K>;
 //#endregion
-export { Branded };
 //# sourceMappingURL=branding.d.ts.map

package/dist/branding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branding.d.ts","names":[],"sources":["../src/branding.ts"],"mappings":";KAAK,KAAA,yDAA8D,CAAA,GAAI,CAAC;AAAA,KAE5D,OAAA,kDAAyD,CAAA,GAAI,KAAA,CAAM,CAAA,EAAG,CAAA"}
+{"version":3,"file":"branding.d.ts","names":[],"sources":["../src/branding.ts"],"mappings":";KAAK,MAAM,GAAG,8CAA8C,OAAO,IAAI;YAE3D,QAAQ,GAAG,GAAG,2CAA2C,IAAI,MAAM,GAAG"}

package/dist/columns/accessor_traversal.d.ts

@@ -1,15 +1,14 @@
 import { AccessorLike, LeafEntry, UpstreamBlockCtx } from "./types.js";
-
 //#region src/columns/accessor_traversal.d.ts
 /** Resource types that hold column collections — DFS stops here and collects. */
-declare const COLLECT_TYPES: ReadonlyArray<string>;
+export declare const COLLECT_TYPES: ReadonlyArray<string>;
 /** Resource types DFS descends through when looking for PFrames. */
-declare const DESCEND_TYPES: ReadonlyArray<string>;
+export declare const DESCEND_TYPES: ReadonlyArray<string>;
 /**
  * Enumerate column names backing a PFrame accessor — derived from
  * `<name>.spec` field names, without resolving the spec resources.
  */
-declare function listColumnNames<A extends AccessorLike<A>>(accessor: A, prefix?: string): string[];
+export declare function listColumnNames<A extends AccessorLike<A>>(accessor: A, prefix?: string): string[];
 /**
  * One DFS hit — the accessor whose resource-type matched `collectTypes`, and
  * the field-name path from the DFS root used to reach it.
@@ -29,7 +28,7 @@ type DescendantHit<A extends AccessorLike<A>> = {
  *
  * Includes `root` itself in the walk.
  */
-declare function findDescendantsByType<A extends AccessorLike<A>>(opts: {
+export declare function findDescendantsByType<A extends AccessorLike<A>>(opts: {
   root: A;
   rootPath: ReadonlyArray<string>;
   collectTypes: ReadonlyArray<string>;
@@ -40,13 +39,12 @@ declare function findDescendantsByType<A extends AccessorLike<A>>(opts: {
  * Ids are {@link createLocalPObjectId}-shaped: `{resolvePath, name}`. The
  * `resolvePath` is derived from `rootPath` extended by the DFS traversal.
  */
-declare function indexAccessorRoot<A extends AccessorLike<A>>(root: A, rootPath: ReadonlyArray<string>): LeafEntry<A>[];
+export declare function indexAccessorRoot<A extends AccessorLike<A>>(root: A, rootPath: ReadonlyArray<string>): LeafEntry<A>[];
 /**
  * Walk one upstream-block ctx pair (`prodCtx` then `stagingCtx`) and return one
  * {@link LeafEntry} per column. First-wins dedup by name (prod precedes staging).
  * Ids are {@link createGlobalPObjectId}-shaped — `resolvePath` is not involved.
  */
-declare function indexPoolBlock<A extends AccessorLike<A>>(block: UpstreamBlockCtx<A>): LeafEntry<A>[];
+export declare function indexPoolBlock<A extends AccessorLike<A>>(block: UpstreamBlockCtx<A>): LeafEntry<A>[];
 //#endregion
-export { COLLECT_TYPES, DESCEND_TYPES, findDescendantsByType, indexAccessorRoot, indexPoolBlock, listColumnNames };
 //# sourceMappingURL=accessor_traversal.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"accessor_traversal.d.ts","names":[],"sources":["../../src/columns/accessor_traversal.ts"],"mappings":";;;;cAKa,aAAA,EAAe,aAAa;AAAzC;AAAA,cAGa,aAAA,EAAe,aAAa;;;AAHA;AAGzC;iBASgB,eAAA,WAA0B,YAAA,CAAa,CAAA,GACrD,QAAA,EAAU,CAAA,EACV,MAAA;;;AAXuC;AASzC;KAmBK,aAAA,WAAwB,YAAA,CAAa,CAAA;EAAA,SAC/B,IAAA,EAAM,CAAA;EAAA,SACN,IAAA,EAAM,aAAA;AAAA;;;;;;;;;;;AAnBI;iBAiCL,qBAAA,WAAgC,YAAA,CAAa,CAAA,GAAI,IAAA;EAC/D,IAAA,EAAM,CAAA;EACN,QAAA,EAAU,aAAA;EACV,YAAA,EAAc,aAAA;EACd,YAAA,GAAe,aAAA;AAAA,IACb,aAAA,CAAc,CAAA;;;;;;iBAiCF,iBAAA,WAA4B,YAAA,CAAa,CAAA,GACvD,IAAA,EAAM,CAAA,EACN,QAAA,EAAU,aAAA,WACT,SAAA,CAAU,CAAA;;;;;;iBAwBG,cAAA,WAAyB,YAAA,CAAa,CAAA,GACpD,KAAA,EAAO,gBAAA,CAAiB,CAAA,IACvB,SAAA,CAAU,CAAA"}
+{"version":3,"file":"accessor_traversal.d.ts","names":[],"sources":["../../src/columns/accessor_traversal.ts"],"mappings":";;;qBAKa,eAAe;;qBAGf,eAAe;;;;;wBASZ,gBAAgB,UAAU,aAAa,IACrD,UAAU,GACV;;;;;KAiBG,cAAc,UAAU,aAAa;WAC/B,MAAM;WACN,MAAM;;;;;;;;;;;;;wBAcD,sBAAsB,UAAU,aAAa,IAAI;EAC/D,MAAM;EACN,UAAU;EACV,cAAc;EACd,eAAe;IACb,cAAc;;;;;;wBAiCF,kBAAkB,UAAU,aAAa,IACvD,MAAM,GACN,UAAU,wBACT,UAAU;;;;;;wBAwBG,eAAe,UAAU,aAAa,IACpD,OAAO,iBAAiB,KACvB,UAAU"}

package/dist/columns/column_registry.d.ts

@@ -1,6 +1,6 @@
 import { PObjectId } from "../pool/spec.js";
+import "../pool/index.js";
 import { AccessorLike, ColumnEntriesProvider, LeafEntry } from "./types.js";
-
 //#region src/columns/column_registry.d.ts
 /**
  * Id-index over a set of {@link ColumnEntriesProvider}s. Sole job:
@@ -13,7 +13,7 @@ import { AccessorLike, ColumnEntriesProvider, LeafEntry } from "./types.js";
  * directly at the call site that has the providers; there is no ambient
  * singleton.
  */
-declare class ColumnRegistry<A extends AccessorLike<A>> {
+export declare class ColumnRegistry<A extends AccessorLike<A>> {
   private readonly providers;
   constructor(providers: ReadonlyArray<ColumnEntriesProvider<A>>);
   /**
@@ -27,5 +27,4 @@ declare class ColumnRegistry<A extends AccessorLike<A>> {
   private lookupById;
 }
 //#endregion
-export { ColumnRegistry };
 //# sourceMappingURL=column_registry.d.ts.map