@milaboratories/pl-model-common 1.48.0 → 1.49.0

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/kind_selector.d.ts

@@ -1,6 +1,5 @@
 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.
@@ -9,9 +8,9 @@ import { Branded } from "@milaboratories/helpers";
  * - `patch` — `~X.Y.Z`: patch floor, behavior frozen.
  * - `minor` — `^X.Y.Z`: minor floor, behavior floats.
  */
-type KindSelectorOp = "exact" | "patch" | "minor";
+export type KindSelectorOp = "exact" | "patch" | "minor";
 /** The version half of a `{name}@{selector}` kind reference, split into parts. */
-type KindSelector = {
+export type KindSelector = {
   readonly op: KindSelectorOp;
   readonly version: string;
 };
@@ -26,7 +25,7 @@ type KindSelector = {
  * selector is expected, or vice versa. Widen an exact reference explicitly with
  * {@link kindReferenceToSelectorReference}.
  */
-type BlockKindSelectorReference = Branded<string, "BlockKindSelectorReference">;
+export type BlockKindSelectorReference = Branded<string, "BlockKindSelectorReference">;
 /**
  * Split a raw selector string (`1.2.0`, `~1.2.0`, `^1.2.0`) into its parts.
  *
@@ -42,16 +41,16 @@ type BlockKindSelectorReference = Branded<string, "BlockKindSelectorReference">;
  *
  * @throws if the version part is not `X.Y.Z`
  */
-declare function parseKindSelector(raw: string): KindSelector;
+export declare function parseKindSelector(raw: string): KindSelector;
 /** Render a {@link KindSelector} back to its on-wire string. */
-declare function formatKindSelector(sel: KindSelector): 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
  */
-declare function parseKindSelectorReference(ref: BlockKindSelectorReference): {
+export declare function parseKindSelectorReference(ref: BlockKindSelectorReference): {
   name: string;
   selector: KindSelector;
 };
@@ -61,7 +60,7 @@ declare function parseKindSelectorReference(ref: BlockKindSelectorReference): {
  * A formatter, not a validator — pass a selector that came from
  * {@link parseKindSelector} or that you constructed from a known-good version.
  */
-declare function formatKindSelectorReference(k: {
+export declare function formatKindSelectorReference(k: {
   name: string;
   selector: KindSelector;
 }): BlockKindSelectorReference;
@@ -72,9 +71,8 @@ declare function formatKindSelectorReference(k: {
  * 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.
  */
-declare function kindReferenceToSelectorReference(ref: BlockKindReference): BlockKindSelectorReference;
+export declare function kindReferenceToSelectorReference(ref: BlockKindReference): BlockKindSelectorReference;
 /** Whether `value` is a well-formed `{name}@{selector}` string. */
-declare function isBlockKindSelectorReference(value: unknown): value is BlockKindSelectorReference;
+export declare function isBlockKindSelectorReference(value: unknown): value is BlockKindSelectorReference;
 //#endregion
-export { BlockKindSelectorReference, KindSelector, KindSelectorOp, formatKindSelector, formatKindSelectorReference, isBlockKindSelectorReference, kindReferenceToSelectorReference, parseKindSelector, parseKindSelectorReference };
 //# sourceMappingURL=kind_selector.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"kind_selector.d.ts","names":[],"sources":["../../src/template/kind_selector.ts"],"mappings":";;;;;;AAWA;;;;AAA0B;KAAd,cAAA;;KAGA,YAAA;EAAA,SACD,EAAA,EAAI,cAAc;EAAA,SAClB,OAAA;AAAA;;;AAAO;AAclB;;;;AAAgD;AAqBhD;;;KArBY,0BAAA,GAA6B,OAAO;AAqBY;AAa5D;;;;AAAoD;AAiBpD;;;;;;;;;AA9B4D,iBAA5C,iBAAA,CAAkB,GAAA,WAAc,YAAY;AAgCpC;AAAA,iBAnBR,kBAAA,CAAmB,GAAiB,EAAZ,YAAY;;;;;;;iBAiBpC,0BAAA,CAA2B,GAAA,EAAK,0BAAA;EAC9C,IAAA;EACA,QAAA,EAAU,YAAY;AAAA;AA0BxB;;;;;;AAAA,iBAdgB,2BAAA,CAA4B,CAAA;EAC1C,IAAA;EACA,QAAA,EAAU,YAAA;AAAA,IACR,0BAA0B;;;;;;;;iBAWd,gCAAA,CACd,GAAA,EAAK,kBAAA,GACJ,0BAA0B;;iBAMb,4BAAA,CAA6B,KAAA,YAAiB,KAAA,IAAS,0BAA0B"}
+{"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/project_template_v1.d.ts

@@ -1,13 +1,12 @@
 import { BlockKindSelectorReference } from "./kind_selector.js";
 import { Branded } from "@milaboratories/helpers";
-
 //#region src/template/project_template_v1.d.ts
 /**
  * Value of a template file's `schema` field — the format marker every
  * `template-v1` document opens with.
  */
-declare const PROJECT_TEMPLATE_SCHEMA_V1 = "template-v1";
-type ProjectTemplateSchemaV1 = typeof PROJECT_TEMPLATE_SCHEMA_V1;
+export declare const PROJECT_TEMPLATE_SCHEMA_V1 = "template-v1";
+export type ProjectTemplateSchemaV1 = typeof PROJECT_TEMPLATE_SCHEMA_V1;
 /**
  * On-wire reference to one exact block package version, `{name}@X.Y.Z`.
  *
@@ -16,14 +15,14 @@ type ProjectTemplateSchemaV1 = typeof PROJECT_TEMPLATE_SCHEMA_V1;
  * `BlockPackId` (`{ organization, name, version }`) is import-side work; the
  * organization lives inside the npm scope here, as it does for kind names.
  */
-type BlockPackReference = Branded<string, "BlockPackReference">;
+export type BlockPackReference = Branded<string, "BlockPackReference">;
 /**
  * Split a {@link BlockPackReference} into `{ name, version }`.
  *
  * @throws if the reference carries no version segment or the version is not
  *   exactly `X.Y.Z`
  */
-declare function parseBlockPackReference(ref: BlockPackReference): {
+export declare function parseBlockPackReference(ref: BlockPackReference): {
   name: string;
   version: string;
 };
@@ -42,7 +41,7 @@ declare function parseBlockPackReference(ref: BlockPackReference): {
  * business: this type fixes only the grammar, so a document remains readable by a
  * consumer that cannot fetch every scheme.
  */
-type BlockPackLocationReference = Branded<string, "BlockPackLocationReference">;
+export type BlockPackLocationReference = Branded<string, "BlockPackLocationReference">;
 /**
  * Read the scheme off a {@link BlockPackLocationReference}, which is all the
  * document layer knows about it — resolving the rest belongs to whoever can reach
@@ -54,7 +53,7 @@ type BlockPackLocationReference = Branded<string, "BlockPackLocationReference">;
  *
  * @throws if the value carries no scheme
  */
-declare function parseBlockPackLocation(ref: BlockPackLocationReference): {
+export declare function parseBlockPackLocation(ref: BlockPackLocationReference): {
   scheme: string;
 };
 /**
@@ -75,7 +74,7 @@ declare function parseBlockPackLocation(ref: BlockPackLocationReference): {
  * entirely; carrying both would state two different things with no way to reconcile them, so
  * the type admits at most one.
  */
-type ProjectTemplateV1Entry = {
+export type ProjectTemplateV1Entry = {
   /**
    * Template-local identifier, unique within the file. Names the entry for
    * inter-block references; on export it is the block's project-local UUID,
@@ -110,7 +109,7 @@ type ProjectTemplateV1Entry = {
  * Readers are unaffected: every arm declares both keys, so `entry.block` and `entry.location`
  * stay directly readable without narrowing.
  */
-type BlockPackLocatorOverride = {
+export type BlockPackLocatorOverride = {
   /**
    * WHICH VERSION to install, leaving it to the environment to decide which registry
    * serves it — so an entry pinned this way stays portable.
@@ -120,10 +119,12 @@ type BlockPackLocatorOverride = {
    * it already records the exact version the block implements, leaving a pin nothing to
    * add — so this is a hand-written field.
    */
-  readonly block?: BlockPackReference; /** Excluded: this arm is the version pin. */
+  readonly block?: BlockPackReference;
+  /** Excluded: this arm is the version pin. */
   readonly location?: never;
 } | {
-  /** Excluded: this arm is the place. */readonly block?: never;
+  /** Excluded: this arm is the place. */
+  readonly block?: never;
   /**
    * WHICH PLACE to install from, as an absolute URI (see
    * {@link BlockPackLocationReference}).
@@ -151,13 +152,15 @@ type BlockPackLocatorOverride = {
  * dependency; serializing to YAML bytes belongs with the caller that already
  * has one (pl-middle-layer).
  */
-type ProjectTemplateV1 = {
+export type ProjectTemplateV1 = {
   readonly schema: ProjectTemplateSchemaV1;
   readonly blocks: readonly ProjectTemplateV1Entry[];
 };
 /** One thing wrong with a document, and where in it. */
-type TemplateParseIssue = {
-  /** Location in the decoded value: `["blocks", 2, "kind"]`. */readonly path: readonly (string | number)[]; /** What is wrong, worded for whoever is editing the file. */
+export type TemplateParseIssue = {
+  /** Location in the decoded value: `["blocks", 2, "kind"]`. */
+  readonly path: readonly (string | number)[];
+  /** What is wrong, worded for whoever is editing the file. */
   readonly message: string;
 };
 /**
@@ -166,19 +169,19 @@ type TemplateParseIssue = {
  * Indexes read as they are written in the file — `blocks[2]`, not `blocks.2` — so the place
  * can be found by reading rather than by counting.
  */
-declare function formatTemplateParseIssue(issue: TemplateParseIssue): string;
+export declare function formatTemplateParseIssue(issue: TemplateParseIssue): string;
 /**
  * Every problem a document has, thrown once so a caller fixes the file in one pass.
  *
  * The issues are in `message` as well as on `issues`, because a throw that escapes to a log is
  * read as its message and nothing else.
  */
-declare class ProjectTemplateV1ParseError extends Error {
+export declare class ProjectTemplateV1ParseError extends Error {
   readonly issues: readonly TemplateParseIssue[];
   constructor(issues: readonly TemplateParseIssue[]);
 }
 /** A document, or everything wrong with the value that was supposed to be one. */
-type ProjectTemplateV1ReadResult = {
+export type ProjectTemplateV1ReadResult = {
   readonly ok: true;
   readonly document: ProjectTemplateV1;
 } | {
@@ -202,14 +205,13 @@ type ProjectTemplateV1ReadResult = {
  *
  * Collects rather than stops: a file with three mistakes should take one pass to fix.
  */
-declare function readProjectTemplateV1(value: unknown): ProjectTemplateV1ReadResult;
+export declare function readProjectTemplateV1(value: unknown): ProjectTemplateV1ReadResult;
 /**
  * {@link readProjectTemplateV1} for a caller that treats an unreadable document as
  * exceptional — export, which asserts on every run that what it wrote can be read back.
  *
  * @throws {ProjectTemplateV1ParseError} carrying every problem found
  */
-declare function parseProjectTemplateV1(value: unknown): ProjectTemplateV1;
+export declare function parseProjectTemplateV1(value: unknown): ProjectTemplateV1;
 //#endregion
-export { BlockPackLocationReference, BlockPackLocatorOverride, BlockPackReference, PROJECT_TEMPLATE_SCHEMA_V1, ProjectTemplateSchemaV1, ProjectTemplateV1, ProjectTemplateV1Entry, ProjectTemplateV1ParseError, ProjectTemplateV1ReadResult, TemplateParseIssue, formatTemplateParseIssue, parseBlockPackLocation, parseBlockPackReference, parseProjectTemplateV1, readProjectTemplateV1 };
 //# sourceMappingURL=project_template_v1.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"project_template_v1.d.ts","names":[],"sources":["../../src/template/project_template_v1.ts"],"mappings":";;;;;;AASA;;cAAa,0BAAA;AAAA,KACD,uBAAA,UAAiC,0BAA0B;AADhC;AACvC;;;;AAAuE;AAUvE;;AAXuC,KAW3B,kBAAA,GAAqB,OAAO;;AAAA;AAQxC;;;;iBAAgB,uBAAA,CAAwB,GAAA,EAAK,kBAAkB;EAC7D,IAAA;EACA,OAAA;AAAA;;AAAO;AA2BT;;;;AAAgD;AAahD;;;;;;;;KAbY,0BAAA,GAA6B,OAAO;AAqDhD;;;;;;;;;;;AAAA,iBAxCgB,sBAAA,CAAuB,GAAA,EAAK,0BAA0B;EAAK,MAAA;AAAA;;AA+D/C;AAa5B;;;;;;;;;;;AA6BoD;AAiBpD;;;;KAlFY,sBAAA;EAmFO;;;;AAC+B;EAD/B,SA7ER,EAAA;EAAA,SACA,IAAA,EAAM,0BAAA;;;AAiGC;AASlB;;;;AAAkE;AAmBlE;;;;;;WA9GW,MAAA,EAAQ,MAAA;AAAA,IACf,wBAAA;;;;;;;;AA8GwD;AAY5D;;;KA7GY,wBAAA;EA8GG;;;;;;;AACuD;AAyBtE;EA1Be,SAnGA,KAAA,GAAQ,kBAAA;WAER,QAAA;AAAA;EAwRC,gDApRD,KAAA;;;AAoR0D;;;;;;;;;WAxQ1D,QAAA,GAAW,0BAA0B;AAAA;;;;;;;;;;;;;;;KAiBxC,iBAAA;EAAA,SACD,MAAA,EAAQ,uBAAA;EAAA,SACR,MAAA,WAAiB,sBAAsB;AAAA;;KAgBtC,kBAAA;yEAED,IAAA;WAEA,OAAO;AAAA;;;;;;;iBASF,wBAAA,CAAyB,KAAyB,EAAlB,kBAAkB;;;;;;;cAmBrD,2BAAA,SAAoC,KAAA;EAAA,SAC1B,MAAA,WAAiB,kBAAA;cAAjB,MAAA,WAAiB,kBAAA;AAAA;;KAY5B,2BAAA;EAAA,SACG,EAAA;EAAA,SAAmB,QAAA,EAAU,iBAAA;AAAA;EAAA,SAC7B,EAAA;EAAA,SAAoB,MAAA,WAAiB,kBAAkB;AAAA;;;;;;;;;;;;;;;;;;iBAyBtD,qBAAA,CAAsB,KAAA,YAAiB,2BAA2B;;;;;;;iBA6JlE,sBAAA,CAAuB,KAAA,YAAiB,iBAAiB"}
+{"version":3,"file":"project_template_v1.d.ts","names":[],"sources":["../../src/template/project_template_v1.ts"],"mappings":";;;;;;;qBASa;YACD,iCAAiC;;;;;;;;;YAUjC,qBAAqB;;;;;;;wBAQjB,wBAAwB,KAAK;EAC3C;EACA;;;;;;;;;;;;;;;;;YA2BU,6BAA6B;;;;;;;;;;;;wBAazB,uBAAuB,KAAK;EAA+B;;;;;;;;;;;;;;;;;;;;YAwC/D;;;;;;WAMD;WACA,MAAM;;;;;;;;;;;;;;;WAeN,QAAQ;IACf;;;;;;;;;;;;YAaQ;;;;;;;;;;WAWG,QAAQ;;WAER;;;WAIA;;;;;;;;;;;;WAYA,WAAW;;;;;;;;;;;;;;;;YAiBd;WACD,QAAQ;WACR,iBAAiB;;;YAgBhB;;WAED;;WAEA;;;;;;;;wBASK,yBAAyB,OAAO;;;;;;;qBAmBnC,oCAAoC;WAC1B,iBAAiB;EAAtC,YAAqB,iBAAiB;;;YAY5B;WACG;WAAmB,UAAU;;WAC7B;WAAoB,iBAAiB;;;;;;;;;;;;;;;;;;;wBAyBpC,sBAAsB,iBAAiB;;;;;;;wBA6JvC,uBAAuB,iBAAiB"}

package/dist/template/template_ref_form.d.ts

@@ -26,8 +26,10 @@
  * parser runs, so a kind's params contract is written against `PlRef` alone and never learns
  * this type exists.
  */
-type TemplatePlRef = {
-  /** The template-local id of the entry this points at. */readonly block: string; /** The upstream output's name, exactly as a `PlRef` spells it. */
+export type TemplatePlRef = {
+  /** The template-local id of the entry this points at. */
+  readonly block: string;
+  /** The upstream output's name, exactly as a `PlRef` spells it. */
   readonly name: string;
 };
 /**
@@ -37,7 +39,7 @@ type TemplatePlRef = {
  * and nothing else. A value carrying `__isRef` is a `PlRef` already and is not this — the two
  * are told apart by shape and never overlap.
  */
-declare function isTemplatePlRef(value: unknown): value is TemplatePlRef;
+export declare function isTemplatePlRef(value: unknown): value is TemplatePlRef;
 /**
  * Expand every readable reference form in `params` into the form the system stores.
  *
@@ -68,7 +70,6 @@ declare function isTemplatePlRef(value: unknown): value is TemplatePlRef;
  * would have to be resolved somewhere that knows the document, and would drag that knowledge
  * into every caller of this. Keep them information-preserving.
  */
-declare function expandTemplateRefs<T>(params: T): T;
+export declare function expandTemplateRefs<T>(params: T): T;
 //#endregion
-export { TemplatePlRef, expandTemplateRefs, isTemplatePlRef };
 //# sourceMappingURL=template_ref_form.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"template_ref_form.d.ts","names":[],"sources":["../../src/template/template_ref_form.ts"],"mappings":";;AA6BA;;;;AAIe;AAUf;;;;;;;;AAAuE;AAsCvE;;;;;;;;;AAAmD;;;KApDvC,aAAA;oEAED,KAAA;WAEA,IAAI;AAAA;;;;;;;;iBAUC,eAAA,CAAgB,KAAA,YAAiB,KAAA,IAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCvD,kBAAA,IAAsB,MAAA,EAAQ,CAAA,GAAI,CAAC"}
+{"version":3,"file":"template_ref_form.d.ts","names":[],"sources":["../../src/template/template_ref_form.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;YA6BY;;WAED;;WAEA;;;;;;;;;wBAUK,gBAAgB,iBAAiB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsC1C,mBAAmB,GAAG,QAAQ,IAAI"}

package/dist/template/template_relocate.cjs

@@ -1,5 +1,7 @@
+const require_spec = require("../drivers/pframe/spec/spec.cjs");
 const require_ids = require("../drivers/pframe/spec/ids.cjs");
 require("../drivers/index.cjs");
+let es_toolkit = require("es-toolkit");
 //#region src/template/template_relocate.ts
 /**
 * Point every column identifier in a block's params at the blocks of the project being built.
@@ -16,8 +18,13 @@ require("../drivers/index.cjs");
 *
 * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields
 * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*
-* like an id — a `domain` entry, an axis filter — from being rewritten along with it, and
-* what re-sorts a qualifications map whose keys are identifiers.
+* like an id — an axis filter, a domain this package can see belongs to an identifier it
+* knows — from being rewritten along with it, and what re-sorts a qualifications map whose
+* keys are identifiers.
+*
+* A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is
+* qualified by the block that produced it. Only the domain keys known to name a block are
+* repointed — matching an entry id is not on its own evidence of a reference.
 *
 * An id the map does not mention is left as it is. That is the ordering rule doing its work:
 * a caller building the map as it creates blocks passes only the entries already created, so
@@ -35,9 +42,23 @@ function relocateBlockIds(params, blockIds) {
 		if (typeof node === "string") return require_ids.remapColumnIdBlockIds(node, remapBlockId);
 		if (require_ids.isColumnUniversalKey(node)) return require_ids.remapColumnIdBlockIds(node, remapBlockId);
 		if (Array.isArray(node)) return node.map(walk);
-		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [require_ids.remapColumnIdBlockIds(key, remapBlockId), walk(value)]));
+		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [require_ids.remapColumnIdBlockIds(key, remapBlockId), key === "domain" && (0, es_toolkit.isPlainObject)(value) ? relocateDomain(value) : walk(value)]));
 		return node;
 	};
+	/**
+	* The block-naming entries of a domain, repointed at the project being built: an axis a block
+	* produced names that block in its domain, so those are references like any other.
+	*
+	* Only the keys {@link BlockScopedDomain} lists, because a template's entry ids are arbitrary
+	* non-empty strings — a hand-written template may name an entry `closest`, and a qualifier
+	* reading `closest` is not a reference to it. Matching the map is not on its own enough to
+	* tell one from the other; the key is.
+	*
+	* Reached only from the generic object case — inside an identifier this package recognizes a
+	* domain is spec data and stays as it is, which is what keeps an overridden column's
+	* `specOverrides.domain` untouched.
+	*/
+	const relocateDomain = (domain) => Object.fromEntries(Object.entries(domain).map(([key, value]) => [key, typeof value === "string" && require_spec.BlockScopedDomain.has(key) ? remapBlockId(value) : walk(value)]));
 	return walk(params);
 }
 //#endregion

package/dist/template/template_relocate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"template_relocate.cjs","names":["remapColumnIdBlockIds","isColumnUniversalKey"],"sources":["../../src/template/template_relocate.ts"],"sourcesContent":["import { isColumnUniversalKey, remapColumnIdBlockIds } from \"../drivers\";\n\n/**\n * Point every column identifier in a block's params at the blocks of the project being built.\n *\n * The whole of what a template does about references, and it lives here — in the package the\n * block's own bundle imports — because knowing which values carry block ids is knowing the\n * reference system. The engine carrying the params neither marks them, reads them, nor\n * rewrites them: it hands the block its params and this map, and takes back what comes out.\n *\n * Params travel verbatim precisely so that this is possible. A file holds a `PlRef` as the\n * object the block stored and a column id as the canonical string the block stored, with no\n * marker of any kind, and the identifiers are found here by recognizing them — the same way\n * the project's own dependency detector finds them in live args.\n *\n * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields\n * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*\n * like an id — a `domain` entry, an axis filter — from being rewritten along with it, and\n * what re-sorts a qualifications map whose keys are identifiers.\n *\n * An id the map does not mention is left as it is. That is the ordering rule doing its work:\n * a caller building the map as it creates blocks passes only the entries already created, so\n * a reference to an entry further down the file stays pointing at a block that does not\n * exist, and the applied block reports itself as missing references rather than being wired\n * to something below it.\n *\n * @param params Whatever the block projected, as the document stored it\n * @param blockIds template-local entry id → the block id that entry was given\n */\nexport function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T {\n  if (blockIds.size === 0) return params;\n  const remapBlockId = (blockId: string) => blockIds.get(blockId) ?? blockId;\n\n  const walk = (node: unknown): unknown => {\n    // Any string may be an identifier under any amount of escaping; one that is not comes\n    // back as the very same string, so this needs no test of its own here.\n    if (typeof node === \"string\") return remapColumnIdBlockIds(node, remapBlockId);\n\n    // Before the generic object case: an identifier IS an object, and descending into one\n    // would rewrite the strings nested in it piecemeal instead of rebuilding the whole id —\n    // losing the bottom-up canonicalization that keeps the result a valid identifier.\n    if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);\n\n    if (Array.isArray(node)) return node.map(walk);\n\n    if (typeof node === \"object\" && node !== null) {\n      // Keys as well as values: params may be keyed by column id — per-column settings, say\n      // — and a key is exactly as much of a reference as a value is.\n      return Object.fromEntries(\n        Object.entries(node).map(([key, value]) => [\n          remapColumnIdBlockIds(key, remapBlockId),\n          walk(value),\n        ]),\n      );\n    }\n\n    return node;\n  };\n\n  return walk(params) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,iBAAoB,QAAW,UAA0C;CACvF,IAAI,SAAS,SAAS,GAAG,OAAO;CAChC,MAAM,gBAAgB,YAAoB,SAAS,IAAI,OAAO,KAAK;CAEnE,MAAM,QAAQ,SAA2B;EAGvC,IAAI,OAAO,SAAS,UAAU,OAAOA,YAAAA,sBAAsB,MAAM,YAAY;EAK7E,IAAIC,YAAAA,qBAAqB,IAAI,GAAG,OAAOD,YAAAA,sBAAsB,MAAM,YAAY;EAE/E,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,IAAI;EAE7C,IAAI,OAAO,SAAS,YAAY,SAAS,MAGvC,OAAO,OAAO,YACZ,OAAO,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACzCA,YAAAA,sBAAsB,KAAK,YAAY,GACvC,KAAK,KAAK,CACZ,CAAC,CACH;EAGF,OAAO;CACT;CAEA,OAAO,KAAK,MAAM;AACpB"}
+{"version":3,"file":"template_relocate.cjs","names":["remapColumnIdBlockIds","isColumnUniversalKey","BlockScopedDomain"],"sources":["../../src/template/template_relocate.ts"],"sourcesContent":["import { isPlainObject } from \"es-toolkit\";\n\nimport { BlockScopedDomain, isColumnUniversalKey, remapColumnIdBlockIds } from \"../drivers\";\n\n/**\n * Point every column identifier in a block's params at the blocks of the project being built.\n *\n * The whole of what a template does about references, and it lives here — in the package the\n * block's own bundle imports — because knowing which values carry block ids is knowing the\n * reference system. The engine carrying the params neither marks them, reads them, nor\n * rewrites them: it hands the block its params and this map, and takes back what comes out.\n *\n * Params travel verbatim precisely so that this is possible. A file holds a `PlRef` as the\n * object the block stored and a column id as the canonical string the block stored, with no\n * marker of any kind, and the identifiers are found here by recognizing them — the same way\n * the project's own dependency detector finds them in live args.\n *\n * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields\n * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*\n * like an id — an axis filter, a domain this package can see belongs to an identifier it\n * knows — from being rewritten along with it, and what re-sorts a qualifications map whose\n * keys are identifiers.\n *\n * A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is\n * qualified by the block that produced it. Only the domain keys known to name a block are\n * repointed — matching an entry id is not on its own evidence of a reference.\n *\n * An id the map does not mention is left as it is. That is the ordering rule doing its work:\n * a caller building the map as it creates blocks passes only the entries already created, so\n * a reference to an entry further down the file stays pointing at a block that does not\n * exist, and the applied block reports itself as missing references rather than being wired\n * to something below it.\n *\n * @param params Whatever the block projected, as the document stored it\n * @param blockIds template-local entry id → the block id that entry was given\n */\nexport function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T {\n  if (blockIds.size === 0) return params;\n  const remapBlockId = (blockId: string) => blockIds.get(blockId) ?? blockId;\n\n  const walk = (node: unknown): unknown => {\n    // Any string may be an identifier under any amount of escaping; one that is not comes\n    // back as the very same string, so this needs no test of its own here.\n    if (typeof node === \"string\") return remapColumnIdBlockIds(node, remapBlockId);\n\n    // Before the generic object case: an identifier IS an object, and descending into one\n    // would rewrite the strings nested in it piecemeal instead of rebuilding the whole id —\n    // losing the bottom-up canonicalization that keeps the result a valid identifier.\n    if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);\n\n    if (Array.isArray(node)) return node.map(walk);\n\n    if (typeof node === \"object\" && node !== null) {\n      // Keys as well as values: params may be keyed by column id — per-column settings, say\n      // — and a key is exactly as much of a reference as a value is.\n      return Object.fromEntries(\n        Object.entries(node).map(([key, value]) => [\n          remapColumnIdBlockIds(key, remapBlockId),\n          key === \"domain\" && isPlainObject(value) ? relocateDomain(value) : walk(value),\n        ]),\n      );\n    }\n\n    return node;\n  };\n\n  /**\n   * The block-naming entries of a domain, repointed at the project being built: an axis a block\n   * produced names that block in its domain, so those are references like any other.\n   *\n   * Only the keys {@link BlockScopedDomain} lists, because a template's entry ids are arbitrary\n   * non-empty strings — a hand-written template may name an entry `closest`, and a qualifier\n   * reading `closest` is not a reference to it. Matching the map is not on its own enough to\n   * tell one from the other; the key is.\n   *\n   * Reached only from the generic object case — inside an identifier this package recognizes a\n   * domain is spec data and stays as it is, which is what keeps an overridden column's\n   * `specOverrides.domain` untouched.\n   */\n  const relocateDomain = (domain: Record<string, unknown>): Record<string, unknown> =>\n    Object.fromEntries(\n      Object.entries(domain).map(([key, value]) => [\n        key,\n        typeof value === \"string\" && BlockScopedDomain.has(key) ? remapBlockId(value) : walk(value),\n      ]),\n    );\n\n  return walk(params) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,iBAAoB,QAAW,UAA0C;CACvF,IAAI,SAAS,SAAS,GAAG,OAAO;CAChC,MAAM,gBAAgB,YAAoB,SAAS,IAAI,OAAO,KAAK;CAEnE,MAAM,QAAQ,SAA2B;EAGvC,IAAI,OAAO,SAAS,UAAU,OAAOA,YAAAA,sBAAsB,MAAM,YAAY;EAK7E,IAAIC,YAAAA,qBAAqB,IAAI,GAAG,OAAOD,YAAAA,sBAAsB,MAAM,YAAY;EAE/E,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,IAAI;EAE7C,IAAI,OAAO,SAAS,YAAY,SAAS,MAGvC,OAAO,OAAO,YACZ,OAAO,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACzCA,YAAAA,sBAAsB,KAAK,YAAY,GACvC,QAAQ,aAAA,GAAA,WAAA,cAAA,CAA0B,KAAK,IAAI,eAAe,KAAK,IAAI,KAAK,KAAK,CAC/E,CAAC,CACH;EAGF,OAAO;CACT;;;;;;;;;;;;;;CAeA,MAAM,kBAAkB,WACtB,OAAO,YACL,OAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CAC3C,KACA,OAAO,UAAU,YAAYE,aAAAA,kBAAkB,IAAI,GAAG,IAAI,aAAa,KAAK,IAAI,KAAK,KAAK,CAC5F,CAAC,CACH;CAEF,OAAO,KAAK,MAAM;AACpB"}

package/dist/template/template_relocate.d.ts

@@ -14,8 +14,13 @@
  *
  * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields
  * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*
- * like an id — a `domain` entry, an axis filter — from being rewritten along with it, and
- * what re-sorts a qualifications map whose keys are identifiers.
+ * like an id — an axis filter, a domain this package can see belongs to an identifier it
+ * knows — from being rewritten along with it, and what re-sorts a qualifications map whose
+ * keys are identifiers.
+ *
+ * A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is
+ * qualified by the block that produced it. Only the domain keys known to name a block are
+ * repointed — matching an entry id is not on its own evidence of a reference.
  *
  * An id the map does not mention is left as it is. That is the ordering rule doing its work:
  * a caller building the map as it creates blocks passes only the entries already created, so
@@ -26,7 +31,6 @@
  * @param params Whatever the block projected, as the document stored it
  * @param blockIds template-local entry id → the block id that entry was given
  */
-declare function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T;
+export declare function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T;
 //#endregion
-export { relocateBlockIds };
 //# sourceMappingURL=template_relocate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"template_relocate.d.ts","names":[],"sources":["../../src/template/template_relocate.ts"],"mappings":";;AA6BA;;;;;;;;;;;;;;;AAAwF;;;;;;;;;;;iBAAxE,gBAAA,IAAoB,MAAA,EAAQ,CAAA,EAAG,QAAA,EAAU,WAAA,mBAA8B,CAAA"}
+{"version":3,"file":"template_relocate.d.ts","names":[],"sources":["../../src/template/template_relocate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoCgB,iBAAiB,GAAG,QAAQ,GAAG,UAAU,8BAA8B"}

package/dist/template/template_relocate.js

@@ -1,5 +1,7 @@
+import { BlockScopedDomain } from "../drivers/pframe/spec/spec.js";
 import { isColumnUniversalKey, remapColumnIdBlockIds } from "../drivers/pframe/spec/ids.js";
 import "../drivers/index.js";
+import { isPlainObject } from "es-toolkit";
 //#region src/template/template_relocate.ts
 /**
 * Point every column identifier in a block's params at the blocks of the project being built.
@@ -16,8 +18,13 @@ import "../drivers/index.js";
 *
 * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields
 * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*
-* like an id — a `domain` entry, an axis filter — from being rewritten along with it, and
-* what re-sorts a qualifications map whose keys are identifiers.
+* like an id — an axis filter, a domain this package can see belongs to an identifier it
+* knows — from being rewritten along with it, and what re-sorts a qualifications map whose
+* keys are identifiers.
+*
+* A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is
+* qualified by the block that produced it. Only the domain keys known to name a block are
+* repointed — matching an entry id is not on its own evidence of a reference.
 *
 * An id the map does not mention is left as it is. That is the ordering rule doing its work:
 * a caller building the map as it creates blocks passes only the entries already created, so
@@ -35,9 +42,23 @@ function relocateBlockIds(params, blockIds) {
 		if (typeof node === "string") return remapColumnIdBlockIds(node, remapBlockId);
 		if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);
 		if (Array.isArray(node)) return node.map(walk);
-		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [remapColumnIdBlockIds(key, remapBlockId), walk(value)]));
+		if (typeof node === "object" && node !== null) return Object.fromEntries(Object.entries(node).map(([key, value]) => [remapColumnIdBlockIds(key, remapBlockId), key === "domain" && isPlainObject(value) ? relocateDomain(value) : walk(value)]));
 		return node;
 	};
+	/**
+	* The block-naming entries of a domain, repointed at the project being built: an axis a block
+	* produced names that block in its domain, so those are references like any other.
+	*
+	* Only the keys {@link BlockScopedDomain} lists, because a template's entry ids are arbitrary
+	* non-empty strings — a hand-written template may name an entry `closest`, and a qualifier
+	* reading `closest` is not a reference to it. Matching the map is not on its own enough to
+	* tell one from the other; the key is.
+	*
+	* Reached only from the generic object case — inside an identifier this package recognizes a
+	* domain is spec data and stays as it is, which is what keeps an overridden column's
+	* `specOverrides.domain` untouched.
+	*/
+	const relocateDomain = (domain) => Object.fromEntries(Object.entries(domain).map(([key, value]) => [key, typeof value === "string" && BlockScopedDomain.has(key) ? remapBlockId(value) : walk(value)]));
 	return walk(params);
 }
 //#endregion

package/dist/template/template_relocate.js.map

@@ -1 +1 @@
-{"version":3,"file":"template_relocate.js","names":[],"sources":["../../src/template/template_relocate.ts"],"sourcesContent":["import { isColumnUniversalKey, remapColumnIdBlockIds } from \"../drivers\";\n\n/**\n * Point every column identifier in a block's params at the blocks of the project being built.\n *\n * The whole of what a template does about references, and it lives here — in the package the\n * block's own bundle imports — because knowing which values carry block ids is knowing the\n * reference system. The engine carrying the params neither marks them, reads them, nor\n * rewrites them: it hands the block its params and this map, and takes back what comes out.\n *\n * Params travel verbatim precisely so that this is possible. A file holds a `PlRef` as the\n * object the block stored and a column id as the canonical string the block stored, with no\n * marker of any kind, and the identifiers are found here by recognizing them — the same way\n * the project's own dependency detector finds them in live args.\n *\n * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields\n * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*\n * like an id — a `domain` entry, an axis filter — from being rewritten along with it, and\n * what re-sorts a qualifications map whose keys are identifiers.\n *\n * An id the map does not mention is left as it is. That is the ordering rule doing its work:\n * a caller building the map as it creates blocks passes only the entries already created, so\n * a reference to an entry further down the file stays pointing at a block that does not\n * exist, and the applied block reports itself as missing references rather than being wired\n * to something below it.\n *\n * @param params Whatever the block projected, as the document stored it\n * @param blockIds template-local entry id → the block id that entry was given\n */\nexport function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T {\n  if (blockIds.size === 0) return params;\n  const remapBlockId = (blockId: string) => blockIds.get(blockId) ?? blockId;\n\n  const walk = (node: unknown): unknown => {\n    // Any string may be an identifier under any amount of escaping; one that is not comes\n    // back as the very same string, so this needs no test of its own here.\n    if (typeof node === \"string\") return remapColumnIdBlockIds(node, remapBlockId);\n\n    // Before the generic object case: an identifier IS an object, and descending into one\n    // would rewrite the strings nested in it piecemeal instead of rebuilding the whole id —\n    // losing the bottom-up canonicalization that keeps the result a valid identifier.\n    if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);\n\n    if (Array.isArray(node)) return node.map(walk);\n\n    if (typeof node === \"object\" && node !== null) {\n      // Keys as well as values: params may be keyed by column id — per-column settings, say\n      // — and a key is exactly as much of a reference as a value is.\n      return Object.fromEntries(\n        Object.entries(node).map(([key, value]) => [\n          remapColumnIdBlockIds(key, remapBlockId),\n          walk(value),\n        ]),\n      );\n    }\n\n    return node;\n  };\n\n  return walk(params) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,iBAAoB,QAAW,UAA0C;CACvF,IAAI,SAAS,SAAS,GAAG,OAAO;CAChC,MAAM,gBAAgB,YAAoB,SAAS,IAAI,OAAO,KAAK;CAEnE,MAAM,QAAQ,SAA2B;EAGvC,IAAI,OAAO,SAAS,UAAU,OAAO,sBAAsB,MAAM,YAAY;EAK7E,IAAI,qBAAqB,IAAI,GAAG,OAAO,sBAAsB,MAAM,YAAY;EAE/E,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,IAAI;EAE7C,IAAI,OAAO,SAAS,YAAY,SAAS,MAGvC,OAAO,OAAO,YACZ,OAAO,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACzC,sBAAsB,KAAK,YAAY,GACvC,KAAK,KAAK,CACZ,CAAC,CACH;EAGF,OAAO;CACT;CAEA,OAAO,KAAK,MAAM;AACpB"}
+{"version":3,"file":"template_relocate.js","names":[],"sources":["../../src/template/template_relocate.ts"],"sourcesContent":["import { isPlainObject } from \"es-toolkit\";\n\nimport { BlockScopedDomain, isColumnUniversalKey, remapColumnIdBlockIds } from \"../drivers\";\n\n/**\n * Point every column identifier in a block's params at the blocks of the project being built.\n *\n * The whole of what a template does about references, and it lives here — in the package the\n * block's own bundle imports — because knowing which values carry block ids is knowing the\n * reference system. The engine carrying the params neither marks them, reads them, nor\n * rewrites them: it hands the block its params and this map, and takes back what comes out.\n *\n * Params travel verbatim precisely so that this is possible. A file holds a `PlRef` as the\n * object the block stored and a column id as the canonical string the block stored, with no\n * marker of any kind, and the identifiers are found here by recognizing them — the same way\n * the project's own dependency detector finds them in live args.\n *\n * Rewriting is structural, never textual: an identifier is taken apart, its `blockId` fields\n * are replaced, and it is rebuilt canonically. That is what keeps a value that merely *looks*\n * like an id — an axis filter, a domain this package can see belongs to an identifier it\n * knows — from being rewritten along with it, and what re-sorts a qualifications map whose\n * keys are identifiers.\n *\n * A domain reached on its own is the exception, and `relocateDomain` below says why: an axis is\n * qualified by the block that produced it. Only the domain keys known to name a block are\n * repointed — matching an entry id is not on its own evidence of a reference.\n *\n * An id the map does not mention is left as it is. That is the ordering rule doing its work:\n * a caller building the map as it creates blocks passes only the entries already created, so\n * a reference to an entry further down the file stays pointing at a block that does not\n * exist, and the applied block reports itself as missing references rather than being wired\n * to something below it.\n *\n * @param params Whatever the block projected, as the document stored it\n * @param blockIds template-local entry id → the block id that entry was given\n */\nexport function relocateBlockIds<T>(params: T, blockIds: ReadonlyMap<string, string>): T {\n  if (blockIds.size === 0) return params;\n  const remapBlockId = (blockId: string) => blockIds.get(blockId) ?? blockId;\n\n  const walk = (node: unknown): unknown => {\n    // Any string may be an identifier under any amount of escaping; one that is not comes\n    // back as the very same string, so this needs no test of its own here.\n    if (typeof node === \"string\") return remapColumnIdBlockIds(node, remapBlockId);\n\n    // Before the generic object case: an identifier IS an object, and descending into one\n    // would rewrite the strings nested in it piecemeal instead of rebuilding the whole id —\n    // losing the bottom-up canonicalization that keeps the result a valid identifier.\n    if (isColumnUniversalKey(node)) return remapColumnIdBlockIds(node, remapBlockId);\n\n    if (Array.isArray(node)) return node.map(walk);\n\n    if (typeof node === \"object\" && node !== null) {\n      // Keys as well as values: params may be keyed by column id — per-column settings, say\n      // — and a key is exactly as much of a reference as a value is.\n      return Object.fromEntries(\n        Object.entries(node).map(([key, value]) => [\n          remapColumnIdBlockIds(key, remapBlockId),\n          key === \"domain\" && isPlainObject(value) ? relocateDomain(value) : walk(value),\n        ]),\n      );\n    }\n\n    return node;\n  };\n\n  /**\n   * The block-naming entries of a domain, repointed at the project being built: an axis a block\n   * produced names that block in its domain, so those are references like any other.\n   *\n   * Only the keys {@link BlockScopedDomain} lists, because a template's entry ids are arbitrary\n   * non-empty strings — a hand-written template may name an entry `closest`, and a qualifier\n   * reading `closest` is not a reference to it. Matching the map is not on its own enough to\n   * tell one from the other; the key is.\n   *\n   * Reached only from the generic object case — inside an identifier this package recognizes a\n   * domain is spec data and stays as it is, which is what keeps an overridden column's\n   * `specOverrides.domain` untouched.\n   */\n  const relocateDomain = (domain: Record<string, unknown>): Record<string, unknown> =>\n    Object.fromEntries(\n      Object.entries(domain).map(([key, value]) => [\n        key,\n        typeof value === \"string\" && BlockScopedDomain.has(key) ? remapBlockId(value) : walk(value),\n      ]),\n    );\n\n  return walk(params) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,iBAAoB,QAAW,UAA0C;CACvF,IAAI,SAAS,SAAS,GAAG,OAAO;CAChC,MAAM,gBAAgB,YAAoB,SAAS,IAAI,OAAO,KAAK;CAEnE,MAAM,QAAQ,SAA2B;EAGvC,IAAI,OAAO,SAAS,UAAU,OAAO,sBAAsB,MAAM,YAAY;EAK7E,IAAI,qBAAqB,IAAI,GAAG,OAAO,sBAAsB,MAAM,YAAY;EAE/E,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAK,IAAI,IAAI;EAE7C,IAAI,OAAO,SAAS,YAAY,SAAS,MAGvC,OAAO,OAAO,YACZ,OAAO,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACzC,sBAAsB,KAAK,YAAY,GACvC,QAAQ,YAAY,cAAc,KAAK,IAAI,eAAe,KAAK,IAAI,KAAK,KAAK,CAC/E,CAAC,CACH;EAGF,OAAO;CACT;;;;;;;;;;;;;;CAeA,MAAM,kBAAkB,WACtB,OAAO,YACL,OAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CAC3C,KACA,OAAO,UAAU,YAAY,kBAAkB,IAAI,GAAG,IAAI,aAAa,KAAK,IAAI,KAAK,KAAK,CAC5F,CAAC,CACH;CAEF,OAAO,KAAK,MAAM;AACpB"}

package/dist/utag.d.ts

@@ -1,8 +1,7 @@
 import { AuthorMarker } from "./author_marker.js";
-
 //#region src/utag.d.ts
 /** Value returned for changing states supporting reactive listening for changes */
-interface ValueWithUTag<V> {
+export interface ValueWithUTag<V> {
   /** Value snapshot. */
   readonly value: V;
   /**
@@ -14,9 +13,8 @@ interface ValueWithUTag<V> {
    * */
   readonly uTag: string;
 }
-interface ValueWithUTagAndAuthor<V> extends ValueWithUTag<V> {
+export interface ValueWithUTagAndAuthor<V> extends ValueWithUTag<V> {
   readonly author?: AuthorMarker;
 }
 //#endregion
-export { ValueWithUTag, ValueWithUTagAndAuthor };
 //# sourceMappingURL=utag.d.ts.map

package/dist/utag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utag.d.ts","names":[],"sources":["../src/utag.ts"],"mappings":";;;;UAGiB,aAAA;EAAA;EAAA,SAEN,KAAA,EAAO,CAAC;EAFW;;;;;;;EAAA,SAWnB,IAAA;AAAA;AAAA,UAGM,sBAAA,YAAkC,aAAA,CAAc,CAAA;EAAA,SACtD,MAAA,GAAS,YAAA;AAAA"}
+{"version":3,"file":"utag.d.ts","names":[],"sources":["../src/utag.ts"],"mappings":";;;iBAGiB,cAAc;;WAEpB,OAAO;;;;;;;;WASP;;iBAGM,uBAAuB,WAAW,cAAc;WACtD,SAAS"}