@milaboratories/pl-model-common 1.47.3 → 1.49.0

package/dist/resource_types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource_types.d.ts","names":[],"sources":["../src/resource_types.ts"],"mappings":";;cACa,gBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2CA,kBAAA;EAAA"}
+{"version":3,"file":"resource_types.d.ts","names":[],"sources":["../src/resource_types.ts"],"mappings":";;qBACa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;qBAIW;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA"}

package/dist/services/node_service_handlers.d.ts

@@ -1,8 +1,6 @@
 import { DriverKit } from "../driver_kit.js";
 import { NodeServiceHandlerMap } from "./service_injectors.js";
-
 //#region src/services/node_service_handlers.d.ts
-declare function createNodeServiceHandlers(driverKit: DriverKit): NodeServiceHandlerMap;
+export declare function createNodeServiceHandlers(driverKit: DriverKit): NodeServiceHandlerMap;
 //#endregion
-export { createNodeServiceHandlers };
 //# sourceMappingURL=node_service_handlers.d.ts.map

package/dist/services/node_service_handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node_service_handlers.d.ts","names":[],"sources":["../../src/services/node_service_handlers.ts"],"mappings":";;;;iBAiBgB,yBAAA,CAA0B,SAAA,EAAW,SAAA,GAAY,qBAAqB"}
+{"version":3,"file":"node_service_handlers.d.ts","names":[],"sources":["../../src/services/node_service_handlers.ts"],"mappings":";;;wBAiBgB,0BAA0B,WAAW,YAAY"}

package/dist/services/service_capabilities.d.ts

@@ -1,33 +1,31 @@
 import { Services } from "./service_declarations.js";
 import { ServiceName, ServiceRequireFlags } from "./service_types.js";
 import { SupportedRequirement } from "../flags/flag_utils.js";
-
 //#region src/services/service_capabilities.d.ts
 /**
  * All service-related `requires*` capability flag names, auto-derived from Services.
  * Single source of truth — use this everywhere runtime capabilities are registered.
  */
-declare const SERVICE_CAPABILITY_FLAGS: readonly SupportedRequirement[];
+export declare const SERVICE_CAPABILITY_FLAGS: readonly SupportedRequirement[];
 /**
  * Register all service capability flags with the given callback.
  * Works with both `RuntimeCapabilities.addSupportedRequirement`
  * and `MiddleLayer.addRuntimeCapability`.
  */
-declare function registerServiceCapabilities(register: (flag: SupportedRequirement, value: true) => void): void;
+export declare function registerServiceCapabilities(register: (flag: SupportedRequirement, value: true) => void): void;
 /**
  * Resolve which services are required by the given feature flags.
  * Accepts Record<string, unknown> so it works with both BlockCodeKnownFeatureFlags
  * (from middle layer) and Zod-parsed records (from preload).
  */
-declare function resolveRequiredServices(flags: Record<string, unknown> | undefined): ServiceName[];
-type KnownServiceName = (typeof Services)[keyof typeof Services] & string;
-declare function isKnownServiceName(name: string): name is KnownServiceName;
+export declare function resolveRequiredServices(flags: Record<string, unknown> | undefined): ServiceName[];
+export type KnownServiceName = (typeof Services)[keyof typeof Services] & string;
+export declare function isKnownServiceName(name: string): name is KnownServiceName;
 /** All service require flags set to true, auto-generated from Services.
  *  Used to distinguish service-related feature flags from non-service flags. */
-declare const SERVICE_FEATURE_FLAGS: { readonly [K in keyof ServiceRequireFlags]-?: true };
+export declare const SERVICE_FEATURE_FLAGS: { readonly [K in keyof ServiceRequireFlags]-?: true; };
 /** Introspect method names on an instance (including prototype chain).
  *  Uses Object.getOwnPropertyDescriptor to avoid triggering getters. */
-declare function getMethodNames<T extends object>(instance: T): string[];
+export declare function getMethodNames<T extends object>(instance: T): string[];
 //#endregion
-export { KnownServiceName, SERVICE_CAPABILITY_FLAGS, SERVICE_FEATURE_FLAGS, getMethodNames, isKnownServiceName, registerServiceCapabilities, resolveRequiredServices };
 //# sourceMappingURL=service_capabilities.d.ts.map

package/dist/services/service_capabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service_capabilities.d.ts","names":[],"sources":["../../src/services/service_capabilities.ts"],"mappings":";;;;;;;AAQA;;cAAa,wBAAA,WAAmC,oBAAoB;;AAAA;AASpE;;;iBAAgB,2BAAA,CACd,QAAA,GAAW,IAAA,EAAM,oBAAoB,EAAE,KAAA;;;;;;iBAYzB,uBAAA,CAAwB,KAAA,EAAO,MAAA,gCAAsC,WAAW;AAAA,KAOpF,gBAAA,WAA2B,QAAA,eAAuB,QAAQ;AAAA,iBAEtD,kBAAA,CAAmB,IAAA,WAAe,IAAA,IAAQ,gBAAgB;;;cAM7D,qBAAA,yBAA8C,mBAAmB;;AAfkB;iBAoBhF,cAAA,mBAAiC,QAAA,EAAU,CAAC"}
+{"version":3,"file":"service_capabilities.d.ts","names":[],"sources":["../../src/services/service_capabilities.ts"],"mappings":";;;;;;;;qBAQa,mCAAmC;;;;;;wBAShC,4BACd,WAAW,MAAM,sBAAsB;;;;;;wBAYzB,wBAAwB,OAAO,sCAAsC;YAOzE,2BAA2B,uBAAuB;wBAE9C,mBAAmB,eAAe,QAAQ;;;qBAM7C,mCAAmC,WAAW;;;wBAK3C,eAAe,kBAAkB,UAAU"}

package/dist/services/service_declarations.d.ts

@@ -6,13 +6,13 @@ import { PFrameSpecDriver } from "../drivers/pframe/spec_driver.js";
 import { PFrameDriver, PFrameModelDriver } from "../drivers/pframe/driver.js";
 import { ColumnsCollectionDriver, ColumnsCollectionDriverModel } from "../drivers/columns/columns_collection_driver.js";
 import { ServiceTypesLike } from "./service_types.js";
+import "../index.js";
 //#region src/services/service_declarations.d.ts
-declare const Services: {
+export declare const Services: {
   PFrameSpec: Branded<"pframeSpec", ServiceTypesLike<PFrameSpecDriver, PFrameSpecDriver, "wasm", PFrameSpecDriver, PFrameSpecDriver>>;
   PFrame: Branded<"pframe", ServiceTypesLike<PFrameModelDriver<PColumn<string | PColumnValues | DataInfo<string>>>, PFrameDriver, "node", PFrameModelDriver<PColumn<string | PColumnValues | DataInfo<string>>>, PFrameDriver>>;
   Dialog: Branded<"dialog", ServiceTypesLike<Record<string, never>, DialogService, "main", Record<string, never>, DialogService>>;
   ColumnsCollection: Branded<"columnsCollection", ServiceTypesLike<ColumnsCollectionDriverModel, ColumnsCollectionDriverModel, "wasm", ColumnsCollectionDriver, ColumnsCollectionDriver>>;
 };
 //#endregion
-export { Services };
 //# sourceMappingURL=service_declarations.d.ts.map

package/dist/services/service_declarations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service_declarations.d.ts","names":[],"sources":["../../src/services/service_declarations.ts"],"mappings":";;;;;;;;;cAkCa,QAAA"}
+{"version":3,"file":"service_declarations.d.ts","names":[],"sources":["../../src/services/service_declarations.ts"],"mappings":";;;;;;;;;;qBAkCa;EACX,YAAU,sBAAA,iBAAA,kBAAA,0BAAA,kBAAA;EA8BV,QAAM,kBAAA,iBAAA,kBAAA,iBA9BI,gBA8BJ,oBAAA,sBAAA,kBAAA,iBAAA,gBAAA,oBAAA;EAiBN,QAAM,kBAAA,iBAAA,uBAAA,uBAAA,uBAAA;EAMN,mBAAiB,6BAAA,iBAAA,8BAAA,sCAAA,yBAAA"}

package/dist/services/service_injectors.d.ts

@@ -2,33 +2,32 @@ import { Services } from "./service_declarations.js";
 import { InferServiceKind, InferServiceUi, ServiceBrand, ServiceName } from "./service_types.js";
 import { DriverKit } from "../driver_kit.js";
 import { createNodeServiceHandlers } from "./node_service_handlers.js";
-
 //#region src/services/service_injectors.d.ts
-type NodeServiceKeys = { [K in keyof typeof Services]: InferServiceKind<ServiceBrand<(typeof Services)[K]>> extends "node" ? K : never }[keyof typeof Services];
+type NodeServiceKeys = { [K in keyof typeof Services]: InferServiceKind<ServiceBrand<(typeof Services)[K]>> extends "node" ? K : never; }[keyof typeof Services];
 /**
  * Auto-derived map of node service keys to their UI-facing interfaces.
  * Fulfilled by real driver wrappers in the worker. Main services are
  * dispatched by the Electron main-process router and never reach this
  * map; wasm services are instantiated locally on each consumer.
  */
-type NodeServiceHandlerMap = { [K in NodeServiceKeys]: InferServiceUi<ServiceBrand<(typeof Services)[K]>> };
+export type NodeServiceHandlerMap = { [K in NodeServiceKeys]: InferServiceUi<ServiceBrand<(typeof Services)[K]>>; };
 /**
  * Resolve the worker-side handler object for a given service ID. Caches
  * per DriverKit reference. Called from the worker's IPC dispatch path.
  */
-declare function resolveNodeServiceHandler(driverKit: DriverKit, serviceId: ServiceName): NodeServiceHandlerMap[keyof NodeServiceHandlerMap] | null;
+export declare function resolveNodeServiceHandler(driverKit: DriverKit, serviceId: ServiceName): NodeServiceHandlerMap[keyof NodeServiceHandlerMap] | null;
 /**
  * UI-side method names per service. Drives ServiceProxy forwarder
  * construction in the renderer.
  */
-declare const SERVICE_METHOD_MAP: Readonly<Record<string, string[]>>;
+export declare const SERVICE_METHOD_MAP: Readonly<Record<string, string[]>>;
 /**
  * Model-side method names per service. Drives the workflow VM bridge
  * (see pl-middle-layer js_render).
  */
-declare const MODEL_SERVICE_METHOD_MAP: Readonly<Record<string, string[]>>;
+export declare const MODEL_SERVICE_METHOD_MAP: Readonly<Record<string, string[]>>;
 /** Build service info for a block from its feature flags. */
-declare function buildServiceInfo(featureFlags: Record<string, unknown>): Record<ServiceName, string[]>;
+export declare function buildServiceInfo(featureFlags: Record<string, unknown>): Record<ServiceName, string[]>;
 //#endregion
-export { MODEL_SERVICE_METHOD_MAP, NodeServiceHandlerMap, SERVICE_METHOD_MAP, buildServiceInfo, createNodeServiceHandlers, resolveNodeServiceHandler };
+export { createNodeServiceHandlers };
 //# sourceMappingURL=service_injectors.d.ts.map

package/dist/services/service_injectors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service_injectors.d.ts","names":[],"sources":["../../src/services/service_injectors.ts"],"mappings":";;;;;;KAmBK,eAAA,wBACgB,QAAA,GAAW,gBAAA,CAAiB,YAAA,SAAqB,QAAA,EAAU,CAAA,qBAC1E,CAAA,wBAES,QAAA;;;;;;;KAQH,qBAAA,WACJ,eAAA,GAAkB,cAAA,CAAe,YAAA,SAAqB,QAAA,EAAU,CAAA;;;AATjD;AAQvB;iBAmBgB,yBAAA,CACd,SAAA,EAAW,SAAA,EACX,SAAA,EAAW,WAAA,GACV,qBAAA,OAA4B,qBAAA;;;;;cAuBlB,kBAAA,EAAoB,QAAQ,CAAC,MAAA;;;;;cAO7B,wBAAA,EAA0B,QAAQ,CAAC,MAAA;;iBAIhC,gBAAA,CACd,YAAA,EAAc,MAAA,oBACb,MAAA,CAAO,WAAA"}
+{"version":3,"file":"service_injectors.d.ts","names":[],"sources":["../../src/services/service_injectors.ts"],"mappings":";;;;;KAmBK,qBACF,kBAAkB,WAAW,iBAAiB,qBAAqB,UAAU,sBAC1E,0BAES;;;;;;;YAQH,2BACT,KAAK,kBAAkB,eAAe,qBAAqB,UAAU;;;;;wBAkBxD,0BACd,WAAW,WACX,WAAW,cACV,4BAA4B;;;;;qBAuBlB,oBAAoB,SAAS;;;;;qBAO7B,0BAA0B,SAAS;;wBAIhC,iBACd,cAAc,0BACb,OAAO"}

package/dist/services/service_registry.d.ts

@@ -1,6 +1,5 @@
 import { Services } from "./service_declarations.js";
 import { InferServiceModelHost, InferServiceUiHost, ModelServiceFactoryMap, ServiceName, ServiceTypesLike, UiServiceFactoryMap } from "./service_types.js";
-
 //#region src/services/service_registry.d.ts
 type RegistryName = "ModelServiceRegistry" | "UiServiceRegistry";
 declare class ServiceRegistryBase {
@@ -12,14 +11,13 @@ declare class ServiceRegistryBase {
   dispose(): Promise<void>;
   protected getById(serviceId: ServiceName): Record<string, Function> | null;
 }
-declare class ModelServiceRegistry<SMap extends Record<string, ServiceName> = typeof Services> extends ServiceRegistryBase {
+export declare class ModelServiceRegistry<SMap extends Record<string, ServiceName> = typeof Services> extends ServiceRegistryBase {
   constructor(serviceMap: SMap, factories: ModelServiceFactoryMap<SMap>);
   get<S extends ServiceTypesLike>(id: ServiceName<S>): ([unknown] extends [InferServiceModelHost<S>] ? Record<string, Function> : InferServiceModelHost<S>) | null;
 }
-declare class UiServiceRegistry<SMap extends Record<string, ServiceName> = typeof Services> extends ServiceRegistryBase {
+export declare class UiServiceRegistry<SMap extends Record<string, ServiceName> = typeof Services> extends ServiceRegistryBase {
   constructor(serviceMap: SMap, factories: UiServiceFactoryMap<SMap>);
   get<S extends ServiceTypesLike>(id: ServiceName<S>): ([unknown] extends [InferServiceUiHost<S>] ? Record<string, Function> : InferServiceUiHost<S>) | null;
 }
 //#endregion
-export { ModelServiceRegistry, UiServiceRegistry };
 //# sourceMappingURL=service_registry.d.ts.map

package/dist/services/service_registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service_registry.d.ts","names":[],"sources":["../../src/services/service_registry.ts"],"mappings":";;;;KAWK,YAAA;AAAA,cAGC,mBAAA;EAAA,iBACa,YAAA;EAAA,iBACA,aAAA;EAAA,iBACA,SAAA;EAAA,iBACA,SAAA;EAAA,UAER,WAAA,CACP,YAAA,EAAc,YAAA,EACd,UAAA,EAAY,MAAA,SAAe,WAAA,GAC3B,SAAA,EAAW,MAAA;EAYP,OAAA,IAAW,OAAA;EAAA,UAWP,OAAA,CAAQ,SAAA,EAAW,WAAA,GAAc,MAAA,SAAe,QAAA;AAAA;AAAA,cAiB/C,oBAAA,cACE,MAAA,SAAe,WAAA,WAAsB,QAAA,UAC1C,mBAAA;cACI,UAAA,EAAY,IAAA,EAAM,SAAA,EAAW,sBAAA,CAAuB,IAAA;EAIhE,GAAA,WAAc,gBAAA,EACZ,EAAA,EAAI,WAAA,CAAY,CAAA,wBAEM,qBAAA,CAAsB,CAAA,KACtC,MAAA,SAAe,QAAA,IACf,qBAAA,CAAsB,CAAA;AAAA;AAAA,cAOnB,iBAAA,cACE,MAAA,SAAe,WAAA,WAAsB,QAAA,UAC1C,mBAAA;cACI,UAAA,EAAY,IAAA,EAAM,SAAA,EAAW,mBAAA,CAAoB,IAAA;EAI7D,GAAA,WAAc,gBAAA,EACZ,EAAA,EAAI,WAAA,CAAY,CAAA,wBAEM,kBAAA,CAAmB,CAAA,KAAM,MAAA,SAAe,QAAA,IAAY,kBAAA,CAAmB,CAAA;AAAA"}
+{"version":3,"file":"service_registry.d.ts","names":[],"sources":["../../src/services/service_registry.ts"],"mappings":";;;KAWK;cAGC;mBACa;mBACA;mBACA;mBACA;YAER,YACP,cAAc,cACd,YAAY,eAAe,cAC3B,WAAW;EAYP,WAAW;YAWP,QAAQ,WAAW,cAAc,eAAe;;qBAiB/C,qBACX,aAAa,eAAe,sBAAsB,kBAC1C;EACR,YAAY,YAAY,MAAM,WAAW,uBAAuB;EAIhE,IAAI,UAAU,kBACZ,IAAI,YAAY,yBAEM,sBAAsB,MACtC,eAAe,YACf,sBAAsB;;qBAOnB,kBACX,aAAa,eAAe,sBAAsB,kBAC1C;EACR,YAAY,YAAY,MAAM,WAAW,oBAAoB;EAI7D,IAAI,UAAU,kBACZ,IAAI,YAAY,yBAEM,mBAAmB,MAAM,eAAe,YAAY,mBAAmB"}

package/dist/services/service_types.d.ts

@@ -1,9 +1,8 @@
 import { Branded as Branded$1 } from "../branding.js";
 import { Services } from "./service_declarations.js";
 import { UnionToIntersection } from "@milaboratories/helpers";
-
 //#region src/services/service_types.d.ts
-type ServiceTypesLike<Model = unknown, Ui = unknown, Kind extends ServiceType = ServiceType, ModelHost = Model, UiHost = Ui> = {
+export type ServiceTypesLike<Model = unknown, Ui = unknown, Kind extends ServiceType = ServiceType, ModelHost = Model, UiHost = Ui> = {
   readonly __types?: {
     model: Model;
     ui: Ui;
@@ -12,37 +11,37 @@ type ServiceTypesLike<Model = unknown, Ui = unknown, Kind extends ServiceType =
     uiHost: UiHost;
   };
 };
-type InferServiceModel<S extends ServiceTypesLike> = S extends ServiceTypesLike<infer M, unknown, ServiceType, unknown, unknown> ? M : unknown;
-type InferServiceUi<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, infer U, ServiceType, unknown, unknown> ? U : unknown;
-type InferServiceKind<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, unknown, infer K, unknown, unknown> ? K : ServiceType;
+export type InferServiceModel<S extends ServiceTypesLike> = S extends ServiceTypesLike<infer M, unknown, ServiceType, unknown, unknown> ? M : unknown;
+export type InferServiceUi<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, infer U, ServiceType, unknown, unknown> ? U : unknown;
+export type InferServiceKind<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, unknown, infer K, unknown, unknown> ? K : ServiceType;
 /**
  * Host-side shape stored in the model service registry. Differs from
  * {@link InferServiceModel} only when the registered impl carries extra
  * parameters (e.g. per-call `host` bindings) that the sandbox-view does
  * not expose. Defaults to {@link InferServiceModel}.
  */
-type InferServiceModelHost<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, unknown, ServiceType, infer MH, unknown> ? MH : unknown;
+export type InferServiceModelHost<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, unknown, ServiceType, infer MH, unknown> ? MH : unknown;
 /**
  * Host-side shape stored in the UI service registry. Differs from
  * {@link InferServiceUi} only when the registered impl carries extra
  * parameters that the UI-proxy view does not expose. Defaults to
  * {@link InferServiceUi}.
  */
-type InferServiceUiHost<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, unknown, ServiceType, unknown, infer UH> ? UH : unknown;
-type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded$1<string, S>;
-type ServiceType = "node" | "wasm" | "main";
-declare const service: <Model, Ui, ModelHost = Model, UiHost = Ui>() => <K extends ServiceType, N extends string, MM extends readonly (keyof Model & string)[], UM extends readonly (keyof Ui & string)[]>(options: {
-    readonly type: K;
-    readonly name: N;
-    readonly modelMethods: MM;
-    readonly uiMethods: UM;
-  }) => Branded$1<N, ServiceTypesLike<Model, Ui, K, ModelHost, UiHost>>, isNodeService: (id: ServiceName) => boolean, isWasmService: (id: ServiceName) => boolean, isMainService: (id: ServiceName) => boolean, getServiceKind: (id: ServiceName) => ServiceType | undefined, getServiceModelMethods: (id: ServiceName) => readonly string[], getServiceUiMethods: (id: ServiceName) => readonly string[];
-declare function serviceFnKey(serviceId: string, method?: string): string;
-type ServiceBrand<T> = T extends Branded$1<string, infer S extends ServiceTypesLike> ? S : never;
-type ModelServiceFactoryMap<SMap extends Record<string, ServiceName>> = { [K in keyof SMap]: (() => InferServiceModelHost<ServiceBrand<SMap[K]>>) | null };
-type UiServiceFactoryMap<SMap extends Record<string, ServiceName>> = { [K in keyof SMap]: (() => InferServiceUiHost<ServiceBrand<SMap[K]>>) | null };
+export type InferServiceUiHost<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, unknown, ServiceType, unknown, infer UH> ? UH : unknown;
+export type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded$1<string, S>;
+export type ServiceType = "node" | "wasm" | "main";
+export declare const service: <Model, Ui, ModelHost = Model, UiHost = Ui>() => <K extends ServiceType, N extends string, MM extends readonly (keyof Model & string)[], UM extends readonly (keyof Ui & string)[]>(options: {
+  readonly type: K;
+  readonly name: N;
+  readonly modelMethods: MM;
+  readonly uiMethods: UM;
+}) => Branded$1<N, ServiceTypesLike<Model, Ui, K, ModelHost, UiHost>>, isNodeService: (id: ServiceName) => boolean, isWasmService: (id: ServiceName) => boolean, isMainService: (id: ServiceName) => boolean, getServiceKind: (id: ServiceName) => ServiceType | undefined, getServiceModelMethods: (id: ServiceName) => readonly string[], getServiceUiMethods: (id: ServiceName) => readonly string[];
+export declare function serviceFnKey(serviceId: string, method?: string): string;
+export type ServiceBrand<T> = T extends Branded$1<string, infer S extends ServiceTypesLike> ? S : never;
+export type ModelServiceFactoryMap<SMap extends Record<string, ServiceName>> = { [K in keyof SMap]: (() => InferServiceModelHost<ServiceBrand<SMap[K]>>) | null; };
+export type UiServiceFactoryMap<SMap extends Record<string, ServiceName>> = { [K in keyof SMap]: (() => InferServiceUiHost<ServiceBrand<SMap[K]>>) | null; };
 /** Contract between any service provider and any service consumer. */
-interface ServiceDispatch {
+export interface ServiceDispatch {
   getServiceNames(): ServiceName[];
   getServiceMethods(serviceId: ServiceName): string[];
   callServiceMethod(serviceId: ServiceName, method: string, ...args: unknown[]): unknown;
@@ -50,14 +49,13 @@ interface ServiceDispatch {
 type TServices = typeof Services;
 type ExtractServiceName<T> = T extends Branded$1<infer N extends string, any> ? N : never;
 /** Model-side service interfaces keyed by service name literal. */
-type ModelServices = { [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceModel<ServiceBrand<TServices[K]>> };
+export type ModelServices = { [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceModel<ServiceBrand<TServices[K]>>; };
 /** UI-side service interfaces keyed by service name literal. */
-type UiServices = { [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceUi<ServiceBrand<TServices[K]>> };
+export type UiServices = { [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceUi<ServiceBrand<TServices[K]>>; };
 /** Map from Services keys to their unbranded string name literals. */
-type ServiceNameLiterals = { [K in keyof TServices]: ExtractServiceName<TServices[K]> };
+export type ServiceNameLiterals = { [K in keyof TServices]: ExtractServiceName<TServices[K]>; };
 /** Auto-derived requires* feature flags from Services keys. */
-type ServiceRequireFlags = { [K in keyof TServices as `requires${K & string}`]?: boolean };
-type RequireServices<T extends ServiceName> = UnionToIntersection<T extends Branded$1<infer N extends string, infer S extends ServiceTypesLike> ? Record<N, InferServiceModel<S>> : never>;
+export type ServiceRequireFlags = { [K in keyof TServices as `requires${K & string}`]?: boolean; };
+export type RequireServices<T extends ServiceName> = UnionToIntersection<T extends Branded$1<infer N extends string, infer S extends ServiceTypesLike> ? Record<N, InferServiceModel<S>> : never>;
 //#endregion
-export { InferServiceKind, InferServiceModel, InferServiceModelHost, InferServiceUi, InferServiceUiHost, ModelServiceFactoryMap, ModelServices, RequireServices, ServiceBrand, ServiceDispatch, ServiceName, ServiceNameLiterals, ServiceRequireFlags, ServiceType, ServiceTypesLike, UiServiceFactoryMap, UiServices, getServiceKind, getServiceModelMethods, getServiceUiMethods, isMainService, isNodeService, isWasmService, service, serviceFnKey };
 //# sourceMappingURL=service_types.d.ts.map

package/dist/services/service_types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service_types.d.ts","names":[],"sources":["../../src/services/service_types.ts"],"mappings":";;;;;KAKY,gBAAA,6CAGG,WAAA,GAAc,WAAA,cACf,KAAA,WACH,EAAA;EAAA,SAEA,OAAA;IACP,KAAA,EAAO,KAAA;IACP,EAAA,EAAI,EAAA;IACJ,IAAA,EAAM,IAAA;IACN,SAAA,EAAW,SAAA;IACX,MAAA,EAAQ,MAAA;EAAA;AAAA;AAAA,KAIA,iBAAA,WAA4B,gBAAA,IACtC,CAAA,SAAU,gBAAA,mBAAmC,WAAA,sBAAiC,CAAA;AAAA,KAEpE,cAAA,WAAyB,gBAAA,IACnC,CAAA,SAAU,gBAAA,mBAAmC,WAAA,sBAAiC,CAAA;AAAA,KAEpE,gBAAA,WAA2B,gBAAA,IACrC,CAAA,SAAU,gBAAA,gDAAgE,CAAA,GAAI,WAAA;;;;;;;KAQpE,qBAAA,WAAgC,gBAAA,IAC1C,CAAA,SAAU,gBAAA,mBAAmC,WAAA,uBAAkC,EAAA;;;;;;;KAQrE,kBAAA,WAA6B,gBAAA,IACvC,CAAA,SAAU,gBAAA,mBAAmC,WAAA,uBAAkC,EAAA;AAAA,KAErE,WAAA,WAAsB,gBAAA,GAAmB,gBAAA,IAAoB,SAAA,SAAgB,CAAA;AAAA,KAE7E,WAAA;AAAA,cAKV,OAAA,0BAY8B,KAAA,WAAgB,EAAA,kBAE9B,WAAA,+CAEiB,KAAA,yCACA,EAAA,cAAc,OAAA;IAAA,SAEhC,IAAA,EAAM,CAAA;IAAA,SACN,IAAA,EAAM,CAAA;IAAA,SACN,YAAA,EAAc,EAAA;IAAA,SACd,SAAA,EAAW,EAAA;EAAA,MAClB,SAAA,CAAQ,CAAA,EAAG,gBAAA,CAAiB,KAAA,EAAO,EAAA,EAAI,CAAA,EAAG,SAAA,EAAW,MAAA,oBAtBhD,EAAA,EAsCO,WAAA,8BArCP,EAAA,EAwCO,WAAA,8BAvCP,EAAA,EA0CO,WAAA,+BAzCN,EAAA,EA4CO,WAAA,KAAc,WAAA,uCA3Cb,EAAA,EA8CO,WAAA,8CA7CV,EAAA,EAgDO,WAAA;AAAA,iBAMZ,YAAA,CAAa,SAAA,UAAmB,MAAW;AAAA,KAI/C,YAAA,MACV,CAAA,SAAU,SAAA,yBAAgC,gBAAA,IAAoB,CAAA;AAAA,KAEpD,sBAAA,cAAoC,MAAA,SAAe,WAAA,mBACjD,IAAA,UAAc,qBAAA,CAAsB,YAAA,CAAa,IAAA,CAAK,CAAA;AAAA,KAGxD,mBAAA,cAAiC,MAAA,SAAe,WAAA,mBAC9C,IAAA,UAAc,kBAAA,CAAmB,YAAA,CAAa,IAAA,CAAK,CAAA;;UAIhD,eAAA;EACf,eAAA,IAAmB,WAAA;EACnB,iBAAA,CAAkB,SAAA,EAAW,WAAA;EAC7B,iBAAA,CAAkB,SAAA,EAAW,WAAA,EAAa,MAAA,aAAmB,IAAA;AAAA;AAAA,KAM1D,SAAA,UAAmB,QAAQ;AAAA,KAE3B,kBAAA,MAAwB,CAAA,SAAU,SAAO,gCAAgC,CAAA;;KAGlE,aAAA,iBACE,SAAA,IAAa,kBAAA,CAAmB,SAAA,CAAU,CAAA,KAAM,iBAAA,CAC1D,YAAA,CAAa,SAAA,CAAU,CAAA;;KAKf,UAAA,iBACE,SAAA,IAAa,kBAAA,CAAmB,SAAA,CAAU,CAAA,KAAM,cAAA,CAC1D,YAAA,CAAa,SAAA,CAAU,CAAA;;KAKf,mBAAA,iBACE,SAAA,GAAY,kBAAA,CAAmB,SAAA,CAAU,CAAA;;KAI3C,mBAAA,iBACE,SAAA,eAAwB,CAAC;AAAA,KAG3B,eAAA,WAA0B,WAAA,IAAe,mBAAA,CACnD,CAAA,SAAU,SAAA,yCAAgD,gBAAA,IACtD,MAAA,CAAO,CAAA,EAAG,iBAAA,CAAkB,CAAA"}
+{"version":3,"file":"service_types.d.ts","names":[],"sources":["../../src/services/service_types.ts"],"mappings":";;;;YAKY,iBACV,iBACA,cACA,aAAa,cAAc,aAC3B,YAAY,OACZ,SAAS;WAEA;IACP,OAAO;IACP,IAAI;IACJ,MAAM;IACN,WAAW;IACX,QAAQ;;;YAIA,kBAAkB,UAAU,oBACtC,UAAU,uBAAuB,YAAY,iCAAiC;YAEpE,eAAe,UAAU,oBACnC,UAAU,gCAAgC,GAAG,iCAAiC;YAEpE,iBAAiB,UAAU,oBACrC,UAAU,yCAAyC,uBAAuB,IAAI;;;;;;;YAQpE,sBAAsB,UAAU,oBAC1C,UAAU,mCAAmC,mBAAmB,eAAe;;;;;;;YAQrE,mBAAmB,UAAU,oBACvC,UAAU,mCAAmC,4BAA4B,MAAM;YAErE,YAAY,UAAU,mBAAmB,oBAAoB,kBAAgB;YAE7E;qBAKV,UAYU,OAAO,IAAI,YAAS,OAAU,SAAM,UAExC,UAAU,aACV,kBACA,2BAA2B,mBAC3B,2BAA2B,gBAAc;WAEhC,MAAM;WACN,MAAM;WACN,cAAc;WACd,WAAW;MAClB,UAAQ,GAAG,iBAAiB,OAAO,IAAI,GAAG,WAAW,UAtB7D,gBAAa,IAsCO,yBArCpB,gBAAa,IAwCO,yBAvCpB,gBAAa,IA0CO,yBAzCpB,iBAAc,IA4CO,gBAAc,yBA3CnC,yBAAsB,IA8CO,mCA7C7B,sBAAmB,IAgDO;wBAMZ,aAAa,mBAAmB;YAIpC,aAAa,KACvB,UAAU,wBAAsB,UAAU,oBAAoB;YAEpD,uBAAuB,aAAa,eAAe,mBAC5D,WAAW,cAAc,sBAAsB,aAAa,KAAK;YAGxD,oBAAoB,aAAa,eAAe,mBACzD,WAAW,cAAc,mBAAmB,aAAa,KAAK;;iBAIhD;EACf,mBAAmB;EACnB,kBAAkB,WAAW;EAC7B,kBAAkB,WAAW,aAAa,mBAAmB;;KAM1D,mBAAmB;KAEnB,mBAAmB,KAAK,UAAU,gBAAc,yBAAyB;;YAGlE,mBACT,WAAW,aAAa,mBAAmB,UAAU,MAAM,kBAC1D,aAAa,UAAU;;YAKf,gBACT,WAAW,aAAa,mBAAmB,UAAU,MAAM,eAC1D,aAAa,UAAU;;YAKf,yBACT,WAAW,YAAY,mBAAmB,UAAU;;YAI3C,yBACT,WAAW,wBAAwB;YAG1B,gBAAgB,UAAU,eAAe,oBACnD,UAAU,gBAAc,wBAAwB,UAAU,oBACtD,OAAO,GAAG,kBAAkB"}

package/dist/template/index.cjs

@@ -0,0 +1,20 @@
+const require_kind_selector = require("./kind_selector.cjs");
+const require_project_template_v1 = require("./project_template_v1.cjs");
+const require_template_ref_form = require("./template_ref_form.cjs");
+const require_template_relocate = require("./template_relocate.cjs");
+exports.PROJECT_TEMPLATE_SCHEMA_V1 = require_project_template_v1.PROJECT_TEMPLATE_SCHEMA_V1;
+exports.ProjectTemplateV1ParseError = require_project_template_v1.ProjectTemplateV1ParseError;
+exports.expandTemplateRefs = require_template_ref_form.expandTemplateRefs;
+exports.formatKindSelector = require_kind_selector.formatKindSelector;
+exports.formatKindSelectorReference = require_kind_selector.formatKindSelectorReference;
+exports.formatTemplateParseIssue = require_project_template_v1.formatTemplateParseIssue;
+exports.isBlockKindSelectorReference = require_kind_selector.isBlockKindSelectorReference;
+exports.isTemplatePlRef = require_template_ref_form.isTemplatePlRef;
+exports.kindReferenceToSelectorReference = require_kind_selector.kindReferenceToSelectorReference;
+exports.parseBlockPackLocation = require_project_template_v1.parseBlockPackLocation;
+exports.parseBlockPackReference = require_project_template_v1.parseBlockPackReference;
+exports.parseKindSelector = require_kind_selector.parseKindSelector;
+exports.parseKindSelectorReference = require_kind_selector.parseKindSelectorReference;
+exports.parseProjectTemplateV1 = require_project_template_v1.parseProjectTemplateV1;
+exports.readProjectTemplateV1 = require_project_template_v1.readProjectTemplateV1;
+exports.relocateBlockIds = require_template_relocate.relocateBlockIds;

package/dist/template/index.d.ts

@@ -0,0 +1,5 @@
+import { BlockKindSelectorReference, KindSelector, KindSelectorOp, formatKindSelector, formatKindSelectorReference, isBlockKindSelectorReference, kindReferenceToSelectorReference, parseKindSelector, parseKindSelectorReference } from "./kind_selector.js";
+import { BlockPackLocationReference, BlockPackLocatorOverride, BlockPackReference, PROJECT_TEMPLATE_SCHEMA_V1, ProjectTemplateSchemaV1, ProjectTemplateV1, ProjectTemplateV1Entry, ProjectTemplateV1ParseError, ProjectTemplateV1ReadResult, TemplateParseIssue, formatTemplateParseIssue, parseBlockPackLocation, parseBlockPackReference, parseProjectTemplateV1, readProjectTemplateV1 } from "./project_template_v1.js";
+import { TemplatePlRef, expandTemplateRefs, isTemplatePlRef } from "./template_ref_form.js";
+import { relocateBlockIds } from "./template_relocate.js";
+export { BlockKindSelectorReference, BlockPackLocationReference, BlockPackLocatorOverride, BlockPackReference, KindSelector, KindSelectorOp, PROJECT_TEMPLATE_SCHEMA_V1, ProjectTemplateSchemaV1, ProjectTemplateV1, ProjectTemplateV1Entry, ProjectTemplateV1ParseError, ProjectTemplateV1ReadResult, TemplateParseIssue, TemplatePlRef, expandTemplateRefs, formatKindSelector, formatKindSelectorReference, formatTemplateParseIssue, isBlockKindSelectorReference, isTemplatePlRef, kindReferenceToSelectorReference, parseBlockPackLocation, parseBlockPackReference, parseKindSelector, parseKindSelectorReference, parseProjectTemplateV1, readProjectTemplateV1, relocateBlockIds };

package/dist/template/index.js

@@ -0,0 +1,5 @@
+import { formatKindSelector, formatKindSelectorReference, isBlockKindSelectorReference, kindReferenceToSelectorReference, parseKindSelector, parseKindSelectorReference } from "./kind_selector.js";
+import { PROJECT_TEMPLATE_SCHEMA_V1, ProjectTemplateV1ParseError, formatTemplateParseIssue, parseBlockPackLocation, parseBlockPackReference, parseProjectTemplateV1, readProjectTemplateV1 } from "./project_template_v1.js";
+import { expandTemplateRefs, isTemplatePlRef } from "./template_ref_form.js";
+import { relocateBlockIds } from "./template_relocate.js";
+export { PROJECT_TEMPLATE_SCHEMA_V1, ProjectTemplateV1ParseError, expandTemplateRefs, formatKindSelector, formatKindSelectorReference, formatTemplateParseIssue, isBlockKindSelectorReference, isTemplatePlRef, kindReferenceToSelectorReference, parseBlockPackLocation, parseBlockPackReference, parseKindSelector, parseKindSelectorReference, parseProjectTemplateV1, readProjectTemplateV1, relocateBlockIds };

package/dist/template/kind_selector.cjs

@@ -0,0 +1,92 @@
+const require_block_kind_ref = require("../bmodel/block_kind_ref.cjs");
+//#region src/template/kind_selector.ts
+/** `X.Y.Z` with optional semver prerelease and build metadata. */
+const semVerRegex = /^\d+\.\d+\.\d+(?:-[\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*)?(?:\+[\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*)?$/;
+/**
+* Split a raw selector string (`1.2.0`, `~1.2.0`, `^1.2.0`) into its parts.
+*
+* The version is validated as `X.Y.Z`, so a range that is legal npm but not part
+* of the kind grammar (`>=1.0.0`, `1.x`, `latest`) is rejected here rather than
+* reaching resolution. Note the deliberate divergence from
+* `tools/block-tools`'s `parseSelector`, which additionally tolerates a leading
+* `@` as `exact`: after the `{name}@{selector}` split a leading `@` can only
+* come from a doubled separator, which is malformed.
+*
+* Mapping a selector onto a concrete version is resolution, not parsing, and
+* lives with the resolver (`kind_resolver.selectorToRange`).
+*
+* @throws if the version part is not `X.Y.Z`
+*/
+function parseKindSelector(raw) {
+	const s = raw.trim();
+	const op = s.startsWith("~") ? "patch" : s.startsWith("^") ? "minor" : "exact";
+	const version = op === "exact" ? s : s.slice(1);
+	if (!semVerRegex.test(version)) throw new Error(`Malformed kind version selector (expected 'X.Y.Z', '~X.Y.Z' or '^X.Y.Z'): ${raw}`);
+	return {
+		op,
+		version
+	};
+}
+/** Render a {@link KindSelector} back to its on-wire string. */
+function formatKindSelector(sel) {
+	switch (sel.op) {
+		case "exact": return sel.version;
+		case "patch": return `~${sel.version}`;
+		case "minor": return `^${sel.version}`;
+	}
+}
+/**
+* Split a {@link BlockKindSelectorReference} into `{ name, selector }`.
+*
+* @throws if the reference carries no version segment, or the selector is
+*   outside the `X.Y.Z` / `~X.Y.Z` / `^X.Y.Z` grammar
+*/
+function parseKindSelectorReference(ref) {
+	const { name, version } = require_block_kind_ref.splitVersionedName(ref, "kind selector reference", "{name}@{selector}");
+	return {
+		name,
+		selector: parseKindSelector(version)
+	};
+}
+/**
+* Compose a {@link BlockKindSelectorReference} from a name and selector.
+*
+* A formatter, not a validator — pass a selector that came from
+* {@link parseKindSelector} or that you constructed from a known-good version.
+*/
+function formatKindSelectorReference(k) {
+	return `${k.name}@${formatKindSelector(k.selector)}`;
+}
+/**
+* Widen a resolved {@link BlockKindReference} to its `exact`-tier selector form.
+*
+* The export direction: a block implements exactly one kind version, so export
+* always emits `{name}@X.Y.Z`. Validates on the way through, so a
+* malformed stored reference fails at the boundary rather than in the file.
+*/
+function kindReferenceToSelectorReference(ref) {
+	const { name, version } = require_block_kind_ref.parseKindRef(ref);
+	return formatKindSelectorReference({
+		name,
+		selector: parseKindSelector(version)
+	});
+}
+/** Whether `value` is a well-formed `{name}@{selector}` string. */
+function isBlockKindSelectorReference(value) {
+	if (typeof value !== "string") return false;
+	try {
+		parseKindSelectorReference(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+exports.formatKindSelector = formatKindSelector;
+exports.formatKindSelectorReference = formatKindSelectorReference;
+exports.isBlockKindSelectorReference = isBlockKindSelectorReference;
+exports.kindReferenceToSelectorReference = kindReferenceToSelectorReference;
+exports.parseKindSelector = parseKindSelector;
+exports.parseKindSelectorReference = parseKindSelectorReference;
+
+//# sourceMappingURL=kind_selector.cjs.map

package/dist/template/kind_selector.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind_selector.cjs","names":["splitVersionedName","parseKindRef"],"sources":["../../src/template/kind_selector.ts"],"sourcesContent":["import type { Branded } from \"@milaboratories/helpers\";\nimport type { BlockKindReference } from \"../bmodel/block_kind_ref\";\nimport { parseKindRef, splitVersionedName } from \"../bmodel/block_kind_ref\";\n\n/**\n * Version-selection tier of a template entry's `kind` field.\n *\n * - `exact` — `X.Y.Z`: this version and no other.\n * - `patch` — `~X.Y.Z`: patch floor, behavior frozen.\n * - `minor` — `^X.Y.Z`: minor floor, behavior floats.\n */\nexport type KindSelectorOp = \"exact\" | \"patch\" | \"minor\";\n\n/** The version half of a `{name}@{selector}` kind reference, split into parts. */\nexport type KindSelector = {\n  readonly op: KindSelectorOp;\n  readonly version: string;\n};\n\n/**\n * On-wire reference to a *set* of block kind versions: `{name}@{selector}`, e.g.\n * `@platforma-open/milaboratories.mixcr-clonotyping.kind@~1.2.0`.\n *\n * The template-file form of a kind reference, and the only form the\n * `template-v1` schema accepts in an entry's `kind` field. It is the same string\n * shape as {@link BlockKindReference} widened by the `~`/`^` tiers, but branded\n * separately so a *resolved* kind reference is never silently passed where a\n * selector is expected, or vice versa. Widen an exact reference explicitly with\n * {@link kindReferenceToSelectorReference}.\n */\nexport type BlockKindSelectorReference = Branded<string, \"BlockKindSelectorReference\">;\n\n/** `X.Y.Z` with optional semver prerelease and build metadata. */\nconst semVerRegex =\n  /^\\d+\\.\\d+\\.\\d+(?:-[\\dA-Za-z-]+(?:\\.[\\dA-Za-z-]+)*)?(?:\\+[\\dA-Za-z-]+(?:\\.[\\dA-Za-z-]+)*)?$/;\n\n/**\n * Split a raw selector string (`1.2.0`, `~1.2.0`, `^1.2.0`) into its parts.\n *\n * The version is validated as `X.Y.Z`, so a range that is legal npm but not part\n * of the kind grammar (`>=1.0.0`, `1.x`, `latest`) is rejected here rather than\n * reaching resolution. Note the deliberate divergence from\n * `tools/block-tools`'s `parseSelector`, which additionally tolerates a leading\n * `@` as `exact`: after the `{name}@{selector}` split a leading `@` can only\n * come from a doubled separator, which is malformed.\n *\n * Mapping a selector onto a concrete version is resolution, not parsing, and\n * lives with the resolver (`kind_resolver.selectorToRange`).\n *\n * @throws if the version part is not `X.Y.Z`\n */\nexport function parseKindSelector(raw: string): KindSelector {\n  const s = raw.trim();\n  const op: KindSelectorOp = s.startsWith(\"~\") ? \"patch\" : s.startsWith(\"^\") ? \"minor\" : \"exact\";\n  const version = op === \"exact\" ? s : s.slice(1);\n  if (!semVerRegex.test(version)) {\n    throw new Error(\n      `Malformed kind version selector (expected 'X.Y.Z', '~X.Y.Z' or '^X.Y.Z'): ${raw}`,\n    );\n  }\n  return { op, version };\n}\n\n/** Render a {@link KindSelector} back to its on-wire string. */\nexport function formatKindSelector(sel: KindSelector): string {\n  switch (sel.op) {\n    case \"exact\":\n      return sel.version;\n    case \"patch\":\n      return `~${sel.version}`;\n    case \"minor\":\n      return `^${sel.version}`;\n  }\n}\n\n/**\n * Split a {@link BlockKindSelectorReference} into `{ name, selector }`.\n *\n * @throws if the reference carries no version segment, or the selector is\n *   outside the `X.Y.Z` / `~X.Y.Z` / `^X.Y.Z` grammar\n */\nexport function parseKindSelectorReference(ref: BlockKindSelectorReference): {\n  name: string;\n  selector: KindSelector;\n} {\n  const { name, version } = splitVersionedName(ref, \"kind selector reference\", \"{name}@{selector}\");\n  return { name, selector: parseKindSelector(version) };\n}\n\n/**\n * Compose a {@link BlockKindSelectorReference} from a name and selector.\n *\n * A formatter, not a validator — pass a selector that came from\n * {@link parseKindSelector} or that you constructed from a known-good version.\n */\nexport function formatKindSelectorReference(k: {\n  name: string;\n  selector: KindSelector;\n}): BlockKindSelectorReference {\n  return `${k.name}@${formatKindSelector(k.selector)}` as BlockKindSelectorReference;\n}\n\n/**\n * Widen a resolved {@link BlockKindReference} to its `exact`-tier selector form.\n *\n * The export direction: a block implements exactly one kind version, so export\n * always emits `{name}@X.Y.Z`. Validates on the way through, so a\n * malformed stored reference fails at the boundary rather than in the file.\n */\nexport function kindReferenceToSelectorReference(\n  ref: BlockKindReference,\n): BlockKindSelectorReference {\n  const { name, version } = parseKindRef(ref);\n  return formatKindSelectorReference({ name, selector: parseKindSelector(version) });\n}\n\n/** Whether `value` is a well-formed `{name}@{selector}` string. */\nexport function isBlockKindSelectorReference(value: unknown): value is BlockKindSelectorReference {\n  if (typeof value !== \"string\") return false;\n  try {\n    parseKindSelectorReference(value as BlockKindSelectorReference);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;AAiCA,MAAM,cACJ;;;;;;;;;;;;;;;;AAiBF,SAAgB,kBAAkB,KAA2B;CAC3D,MAAM,IAAI,IAAI,KAAK;CACnB,MAAM,KAAqB,EAAE,WAAW,GAAG,IAAI,UAAU,EAAE,WAAW,GAAG,IAAI,UAAU;CACvF,MAAM,UAAU,OAAO,UAAU,IAAI,EAAE,MAAM,CAAC;CAC9C,IAAI,CAAC,YAAY,KAAK,OAAO,GAC3B,MAAM,IAAI,MACR,6EAA6E,KAC/E;CAEF,OAAO;EAAE;EAAI;CAAQ;AACvB;;AAGA,SAAgB,mBAAmB,KAA2B;CAC5D,QAAQ,IAAI,IAAZ;EACE,KAAK,SACH,OAAO,IAAI;EACb,KAAK,SACH,OAAO,IAAI,IAAI;EACjB,KAAK,SACH,OAAO,IAAI,IAAI;CACnB;AACF;;;;;;;AAQA,SAAgB,2BAA2B,KAGzC;CACA,MAAM,EAAE,MAAM,YAAYA,uBAAAA,mBAAmB,KAAK,2BAA2B,mBAAmB;CAChG,OAAO;EAAE;EAAM,UAAU,kBAAkB,OAAO;CAAE;AACtD;;;;;;;AAQA,SAAgB,4BAA4B,GAGb;CAC7B,OAAO,GAAG,EAAE,KAAK,GAAG,mBAAmB,EAAE,QAAQ;AACnD;;;;;;;;AASA,SAAgB,iCACd,KAC4B;CAC5B,MAAM,EAAE,MAAM,YAAYC,uBAAAA,aAAa,GAAG;CAC1C,OAAO,4BAA4B;EAAE;EAAM,UAAU,kBAAkB,OAAO;CAAE,CAAC;AACnF;;AAGA,SAAgB,6BAA6B,OAAqD;CAChG,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI;EACF,2BAA2B,KAAmC;EAC9D,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/template/kind_selector.d.ts

@@ -0,0 +1,78 @@
+import { BlockKindReference } from "../bmodel/block_kind_ref.js";
+import { Branded } from "@milaboratories/helpers";
+//#region src/template/kind_selector.d.ts
+/**
+ * Version-selection tier of a template entry's `kind` field.
+ *
+ * - `exact` — `X.Y.Z`: this version and no other.
+ * - `patch` — `~X.Y.Z`: patch floor, behavior frozen.
+ * - `minor` — `^X.Y.Z`: minor floor, behavior floats.
+ */
+export type KindSelectorOp = "exact" | "patch" | "minor";
+/** The version half of a `{name}@{selector}` kind reference, split into parts. */
+export type KindSelector = {
+  readonly op: KindSelectorOp;
+  readonly version: string;
+};
+/**
+ * On-wire reference to a *set* of block kind versions: `{name}@{selector}`, e.g.
+ * `@platforma-open/milaboratories.mixcr-clonotyping.kind@~1.2.0`.
+ *
+ * The template-file form of a kind reference, and the only form the
+ * `template-v1` schema accepts in an entry's `kind` field. It is the same string
+ * shape as {@link BlockKindReference} widened by the `~`/`^` tiers, but branded
+ * separately so a *resolved* kind reference is never silently passed where a
+ * selector is expected, or vice versa. Widen an exact reference explicitly with
+ * {@link kindReferenceToSelectorReference}.
+ */
+export type BlockKindSelectorReference = Branded<string, "BlockKindSelectorReference">;
+/**
+ * Split a raw selector string (`1.2.0`, `~1.2.0`, `^1.2.0`) into its parts.
+ *
+ * The version is validated as `X.Y.Z`, so a range that is legal npm but not part
+ * of the kind grammar (`>=1.0.0`, `1.x`, `latest`) is rejected here rather than
+ * reaching resolution. Note the deliberate divergence from
+ * `tools/block-tools`'s `parseSelector`, which additionally tolerates a leading
+ * `@` as `exact`: after the `{name}@{selector}` split a leading `@` can only
+ * come from a doubled separator, which is malformed.
+ *
+ * Mapping a selector onto a concrete version is resolution, not parsing, and
+ * lives with the resolver (`kind_resolver.selectorToRange`).
+ *
+ * @throws if the version part is not `X.Y.Z`
+ */
+export declare function parseKindSelector(raw: string): KindSelector;
+/** Render a {@link KindSelector} back to its on-wire string. */
+export declare function formatKindSelector(sel: KindSelector): string;
+/**
+ * Split a {@link BlockKindSelectorReference} into `{ name, selector }`.
+ *
+ * @throws if the reference carries no version segment, or the selector is
+ *   outside the `X.Y.Z` / `~X.Y.Z` / `^X.Y.Z` grammar
+ */
+export declare function parseKindSelectorReference(ref: BlockKindSelectorReference): {
+  name: string;
+  selector: KindSelector;
+};
+/**
+ * Compose a {@link BlockKindSelectorReference} from a name and selector.
+ *
+ * A formatter, not a validator — pass a selector that came from
+ * {@link parseKindSelector} or that you constructed from a known-good version.
+ */
+export declare function formatKindSelectorReference(k: {
+  name: string;
+  selector: KindSelector;
+}): BlockKindSelectorReference;
+/**
+ * Widen a resolved {@link BlockKindReference} to its `exact`-tier selector form.
+ *
+ * The export direction: a block implements exactly one kind version, so export
+ * always emits `{name}@X.Y.Z`. Validates on the way through, so a
+ * malformed stored reference fails at the boundary rather than in the file.
+ */
+export declare function kindReferenceToSelectorReference(ref: BlockKindReference): BlockKindSelectorReference;
+/** Whether `value` is a well-formed `{name}@{selector}` string. */
+export declare function isBlockKindSelectorReference(value: unknown): value is BlockKindSelectorReference;
+//#endregion
+//# sourceMappingURL=kind_selector.d.ts.map

package/dist/template/kind_selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind_selector.d.ts","names":[],"sources":["../../src/template/kind_selector.ts"],"mappings":";;;;;;;;;;YAWY;;YAGA;WACD,IAAI;WACJ;;;;;;;;;;;;;YAcC,6BAA6B;;;;;;;;;;;;;;;;wBAqBzB,kBAAkB,cAAc;;wBAahC,mBAAmB,KAAK;;;;;;;wBAiBxB,2BAA2B,KAAK;EAC9C;EACA,UAAU;;;;;;;;wBAYI,4BAA4B;EAC1C;EACA,UAAU;IACR;;;;;;;;wBAWY,iCACd,KAAK,qBACJ;;wBAMa,6BAA6B,iBAAiB,SAAS"}

package/dist/template/kind_selector.js

@@ -0,0 +1,87 @@
+import { parseKindRef, splitVersionedName } from "../bmodel/block_kind_ref.js";
+//#region src/template/kind_selector.ts
+/** `X.Y.Z` with optional semver prerelease and build metadata. */
+const semVerRegex = /^\d+\.\d+\.\d+(?:-[\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*)?(?:\+[\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*)?$/;
+/**
+* Split a raw selector string (`1.2.0`, `~1.2.0`, `^1.2.0`) into its parts.
+*
+* The version is validated as `X.Y.Z`, so a range that is legal npm but not part
+* of the kind grammar (`>=1.0.0`, `1.x`, `latest`) is rejected here rather than
+* reaching resolution. Note the deliberate divergence from
+* `tools/block-tools`'s `parseSelector`, which additionally tolerates a leading
+* `@` as `exact`: after the `{name}@{selector}` split a leading `@` can only
+* come from a doubled separator, which is malformed.
+*
+* Mapping a selector onto a concrete version is resolution, not parsing, and
+* lives with the resolver (`kind_resolver.selectorToRange`).
+*
+* @throws if the version part is not `X.Y.Z`
+*/
+function parseKindSelector(raw) {
+	const s = raw.trim();
+	const op = s.startsWith("~") ? "patch" : s.startsWith("^") ? "minor" : "exact";
+	const version = op === "exact" ? s : s.slice(1);
+	if (!semVerRegex.test(version)) throw new Error(`Malformed kind version selector (expected 'X.Y.Z', '~X.Y.Z' or '^X.Y.Z'): ${raw}`);
+	return {
+		op,
+		version
+	};
+}
+/** Render a {@link KindSelector} back to its on-wire string. */
+function formatKindSelector(sel) {
+	switch (sel.op) {
+		case "exact": return sel.version;
+		case "patch": return `~${sel.version}`;
+		case "minor": return `^${sel.version}`;
+	}
+}
+/**
+* Split a {@link BlockKindSelectorReference} into `{ name, selector }`.
+*
+* @throws if the reference carries no version segment, or the selector is
+*   outside the `X.Y.Z` / `~X.Y.Z` / `^X.Y.Z` grammar
+*/
+function parseKindSelectorReference(ref) {
+	const { name, version } = splitVersionedName(ref, "kind selector reference", "{name}@{selector}");
+	return {
+		name,
+		selector: parseKindSelector(version)
+	};
+}
+/**
+* Compose a {@link BlockKindSelectorReference} from a name and selector.
+*
+* A formatter, not a validator — pass a selector that came from
+* {@link parseKindSelector} or that you constructed from a known-good version.
+*/
+function formatKindSelectorReference(k) {
+	return `${k.name}@${formatKindSelector(k.selector)}`;
+}
+/**
+* Widen a resolved {@link BlockKindReference} to its `exact`-tier selector form.
+*
+* The export direction: a block implements exactly one kind version, so export
+* always emits `{name}@X.Y.Z`. Validates on the way through, so a
+* malformed stored reference fails at the boundary rather than in the file.
+*/
+function kindReferenceToSelectorReference(ref) {
+	const { name, version } = parseKindRef(ref);
+	return formatKindSelectorReference({
+		name,
+		selector: parseKindSelector(version)
+	});
+}
+/** Whether `value` is a well-formed `{name}@{selector}` string. */
+function isBlockKindSelectorReference(value) {
+	if (typeof value !== "string") return false;
+	try {
+		parseKindSelectorReference(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { formatKindSelector, formatKindSelectorReference, isBlockKindSelectorReference, kindReferenceToSelectorReference, parseKindSelector, parseKindSelectorReference };
+
+//# sourceMappingURL=kind_selector.js.map

package/dist/template/kind_selector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind_selector.js","names":[],"sources":["../../src/template/kind_selector.ts"],"sourcesContent":["import type { Branded } from \"@milaboratories/helpers\";\nimport type { BlockKindReference } from \"../bmodel/block_kind_ref\";\nimport { parseKindRef, splitVersionedName } from \"../bmodel/block_kind_ref\";\n\n/**\n * Version-selection tier of a template entry's `kind` field.\n *\n * - `exact` — `X.Y.Z`: this version and no other.\n * - `patch` — `~X.Y.Z`: patch floor, behavior frozen.\n * - `minor` — `^X.Y.Z`: minor floor, behavior floats.\n */\nexport type KindSelectorOp = \"exact\" | \"patch\" | \"minor\";\n\n/** The version half of a `{name}@{selector}` kind reference, split into parts. */\nexport type KindSelector = {\n  readonly op: KindSelectorOp;\n  readonly version: string;\n};\n\n/**\n * On-wire reference to a *set* of block kind versions: `{name}@{selector}`, e.g.\n * `@platforma-open/milaboratories.mixcr-clonotyping.kind@~1.2.0`.\n *\n * The template-file form of a kind reference, and the only form the\n * `template-v1` schema accepts in an entry's `kind` field. It is the same string\n * shape as {@link BlockKindReference} widened by the `~`/`^` tiers, but branded\n * separately so a *resolved* kind reference is never silently passed where a\n * selector is expected, or vice versa. Widen an exact reference explicitly with\n * {@link kindReferenceToSelectorReference}.\n */\nexport type BlockKindSelectorReference = Branded<string, \"BlockKindSelectorReference\">;\n\n/** `X.Y.Z` with optional semver prerelease and build metadata. */\nconst semVerRegex =\n  /^\\d+\\.\\d+\\.\\d+(?:-[\\dA-Za-z-]+(?:\\.[\\dA-Za-z-]+)*)?(?:\\+[\\dA-Za-z-]+(?:\\.[\\dA-Za-z-]+)*)?$/;\n\n/**\n * Split a raw selector string (`1.2.0`, `~1.2.0`, `^1.2.0`) into its parts.\n *\n * The version is validated as `X.Y.Z`, so a range that is legal npm but not part\n * of the kind grammar (`>=1.0.0`, `1.x`, `latest`) is rejected here rather than\n * reaching resolution. Note the deliberate divergence from\n * `tools/block-tools`'s `parseSelector`, which additionally tolerates a leading\n * `@` as `exact`: after the `{name}@{selector}` split a leading `@` can only\n * come from a doubled separator, which is malformed.\n *\n * Mapping a selector onto a concrete version is resolution, not parsing, and\n * lives with the resolver (`kind_resolver.selectorToRange`).\n *\n * @throws if the version part is not `X.Y.Z`\n */\nexport function parseKindSelector(raw: string): KindSelector {\n  const s = raw.trim();\n  const op: KindSelectorOp = s.startsWith(\"~\") ? \"patch\" : s.startsWith(\"^\") ? \"minor\" : \"exact\";\n  const version = op === \"exact\" ? s : s.slice(1);\n  if (!semVerRegex.test(version)) {\n    throw new Error(\n      `Malformed kind version selector (expected 'X.Y.Z', '~X.Y.Z' or '^X.Y.Z'): ${raw}`,\n    );\n  }\n  return { op, version };\n}\n\n/** Render a {@link KindSelector} back to its on-wire string. */\nexport function formatKindSelector(sel: KindSelector): string {\n  switch (sel.op) {\n    case \"exact\":\n      return sel.version;\n    case \"patch\":\n      return `~${sel.version}`;\n    case \"minor\":\n      return `^${sel.version}`;\n  }\n}\n\n/**\n * Split a {@link BlockKindSelectorReference} into `{ name, selector }`.\n *\n * @throws if the reference carries no version segment, or the selector is\n *   outside the `X.Y.Z` / `~X.Y.Z` / `^X.Y.Z` grammar\n */\nexport function parseKindSelectorReference(ref: BlockKindSelectorReference): {\n  name: string;\n  selector: KindSelector;\n} {\n  const { name, version } = splitVersionedName(ref, \"kind selector reference\", \"{name}@{selector}\");\n  return { name, selector: parseKindSelector(version) };\n}\n\n/**\n * Compose a {@link BlockKindSelectorReference} from a name and selector.\n *\n * A formatter, not a validator — pass a selector that came from\n * {@link parseKindSelector} or that you constructed from a known-good version.\n */\nexport function formatKindSelectorReference(k: {\n  name: string;\n  selector: KindSelector;\n}): BlockKindSelectorReference {\n  return `${k.name}@${formatKindSelector(k.selector)}` as BlockKindSelectorReference;\n}\n\n/**\n * Widen a resolved {@link BlockKindReference} to its `exact`-tier selector form.\n *\n * The export direction: a block implements exactly one kind version, so export\n * always emits `{name}@X.Y.Z`. Validates on the way through, so a\n * malformed stored reference fails at the boundary rather than in the file.\n */\nexport function kindReferenceToSelectorReference(\n  ref: BlockKindReference,\n): BlockKindSelectorReference {\n  const { name, version } = parseKindRef(ref);\n  return formatKindSelectorReference({ name, selector: parseKindSelector(version) });\n}\n\n/** Whether `value` is a well-formed `{name}@{selector}` string. */\nexport function isBlockKindSelectorReference(value: unknown): value is BlockKindSelectorReference {\n  if (typeof value !== \"string\") return false;\n  try {\n    parseKindSelectorReference(value as BlockKindSelectorReference);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;AAiCA,MAAM,cACJ;;;;;;;;;;;;;;;;AAiBF,SAAgB,kBAAkB,KAA2B;CAC3D,MAAM,IAAI,IAAI,KAAK;CACnB,MAAM,KAAqB,EAAE,WAAW,GAAG,IAAI,UAAU,EAAE,WAAW,GAAG,IAAI,UAAU;CACvF,MAAM,UAAU,OAAO,UAAU,IAAI,EAAE,MAAM,CAAC;CAC9C,IAAI,CAAC,YAAY,KAAK,OAAO,GAC3B,MAAM,IAAI,MACR,6EAA6E,KAC/E;CAEF,OAAO;EAAE;EAAI;CAAQ;AACvB;;AAGA,SAAgB,mBAAmB,KAA2B;CAC5D,QAAQ,IAAI,IAAZ;EACE,KAAK,SACH,OAAO,IAAI;EACb,KAAK,SACH,OAAO,IAAI,IAAI;EACjB,KAAK,SACH,OAAO,IAAI,IAAI;CACnB;AACF;;;;;;;AAQA,SAAgB,2BAA2B,KAGzC;CACA,MAAM,EAAE,MAAM,YAAY,mBAAmB,KAAK,2BAA2B,mBAAmB;CAChG,OAAO;EAAE;EAAM,UAAU,kBAAkB,OAAO;CAAE;AACtD;;;;;;;AAQA,SAAgB,4BAA4B,GAGb;CAC7B,OAAO,GAAG,EAAE,KAAK,GAAG,mBAAmB,EAAE,QAAQ;AACnD;;;;;;;;AASA,SAAgB,iCACd,KAC4B;CAC5B,MAAM,EAAE,MAAM,YAAY,aAAa,GAAG;CAC1C,OAAO,4BAA4B;EAAE;EAAM,UAAU,kBAAkB,OAAO;CAAE,CAAC;AACnF;;AAGA,SAAgB,6BAA6B,OAAqD;CAChG,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI;EACF,2BAA2B,KAAmC;EAC9D,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF"}