@salsita-ai/sdk 0.50.0-develop.b5468d6828 → 0.50.0-develop.b5d443db78

package/dist/domain/spec/runtime/application-spec-slice.d.ts

@@ -0,0 +1,73 @@
+import type { AnyActionImplementations, AnyDomainComponentOptic } from '../../core/index.js';
+import { type ApplicationConfiguratorSpec, type ApplicationSpec as RuntimeApplicationSpec } from '../../domain-runtime/index.js';
+import type { ElementRegistration, HandlerRegistration } from '../modules/index.js';
+import type { RuntimeSpec } from '../runtime-spec/index.js';
+import type { ApplicationRuntime } from './application-runtime.js';
+type Theme = ApplicationConfiguratorSpec['theme'];
+/**
+ * The theme presets of the SDK by name, as `getPhoenixThemes()` returns them. The caller passes
+ * them, because `application-spec` does not depend on the UI package that defines them.
+ */
+export type ThemePresets = Readonly<Record<string, Theme>>;
+/**
+ * The project modules of an application's spec slice, checked and flattened: `handlers` and
+ * `elements` with the content hash of each registration (the remount key of a registration whose
+ * file changed), the component optics of `src/components/` and the action implementations of
+ * `src/actions/`.
+ *
+ * A `null` keeps the previous spec's value: the editor passes it for a kind of file that did not
+ * change since the last update.
+ */
+export interface ApplicationSpecSliceModules {
+    readonly handlers: {
+        readonly handlers: ReadonlyArray<HandlerRegistration<any, any>>;
+        readonly nameHashes?: Readonly<Record<string, string>>;
+    } | null;
+    readonly elements: {
+        readonly elements: readonly ElementRegistration[];
+        readonly nameHashes?: Readonly<Record<string, string>>;
+    } | null;
+    readonly customComponentOptics: readonly AnyDomainComponentOptic[] | null;
+    readonly actionImplementations: AnyActionImplementations | null;
+}
+interface SliceInput {
+    readonly runtime: ApplicationRuntime;
+    readonly modules: ApplicationSpecSliceModules;
+    readonly themePresets: ThemePresets;
+}
+/**
+ * The first spec slice of an application: every section is built from `runtime`, `spec` and the
+ * modules. `initialPublishedData` is empty; the caller computes it with a domain runtime of this
+ * slice and puts it in.
+ */
+export interface ApplicationSpecStart extends SliceInput {
+    readonly previous?: undefined;
+    readonly spec: RuntimeSpec;
+    /** The component optics of `src/admin/components/`. */
+    readonly customAdminComponentOptics: readonly AnyDomainComponentOptic[];
+    /** The SDK's default elements of the application kind; a project element with the same name replaces one. */
+    readonly defaultElements: readonly ElementRegistration[];
+    /** The resources URL of the environment, used when the spec sets no `baseResourcesUrl`. */
+    readonly environmentResourcesUrl: string | undefined;
+}
+/**
+ * A rebuild of a running application's spec slice, as the editor makes it when the project
+ * changes. Only the configurator sections are rebuilt; a section whose runtime did not change, and
+ * a kind of module given as `null`, keeps its object from `previous`, so selectors over it stay
+ * memoized. With `model: 'keep'` the domain factory and the model-owned fields stay too (the
+ * schema of the model is unchanged); with `model: 'rebuild'` they are built from `runtime`.
+ */
+export interface ApplicationSpecUpdate extends SliceInput {
+    readonly previous: RuntimeApplicationSpec;
+    readonly model: 'keep' | 'rebuild';
+}
+/** The component optics a project file contributes, as opposed to those the spec generates. */
+export declare const customComponentOpticsOf: (componentOptics: readonly AnyDomainComponentOptic[]) => AnyDomainComponentOptic[];
+/**
+ * Maps an application's runtime (`ApplicationRuntime`, built with the project's modules) and its
+ * checked modules onto the spec slice of the domain runtime, the one input of every mounted
+ * application: an application's first slice, which `createApplication` builds with it, or the
+ * editor's rebuild after a change of the project.
+ */
+export declare const applicationSpecSlice: (input: ApplicationSpecStart | ApplicationSpecUpdate) => RuntimeApplicationSpec;
+export {};

package/dist/domain/spec/runtime/application-spec-slice.js

@@ -0,0 +1 @@
+import{resolveImportedTransformers as e}from"../../domain-runtime/index.js";export const customComponentOpticsOf=e=>e.filter(e=>!0!==e.generated);let t=(t,n)=>{let{runtime:s,modules:a,themePresets:i}=t,{configurator:o}=s,r=(e,t,s)=>e||void 0===n?t():s(n),l=a.handlers?.handlers??n?.handlers??[],m=a.handlers||void 0===n?((e,t,n)=>{let s={};for(let a of e)s[a.name]=t?.[a.name]??n?.[a.name]??a.name;return s})(l,a.handlers?.nameHashes,n?.handlerHashes):n.handlerHashes,c=a.elements?.elements??n?.elements??[],p=a.elements||void 0===n?((e,t,n)=>{let s={},a=0;for(let i of e)if("assistantFormElement"!==i.type)if("entity"===i.type||"layout"===i.type)s[i.name]=t?.[i.name]??n?.[i.name]??i.name;else{let e=`icon:${a}`;s[e]=t?.[e]??n?.[e]??`${e}:${i.elements.length}`,a+=1}return s})(c,a.elements?.nameHashes,n?.elementHashes):n.elementHashes,d=a.customComponentOptics??customComponentOpticsOf(n?.componentOptics??[]),u=r(o.componentOptics.changed||null!==a.customComponentOptics,()=>[...o.componentOptics.optics.map(e=>e.optic),...d],e=>e.componentOptics),{importedTransformers:h,specTransformers:g}=o.transformersRuntime;return{presets:r(o.presetRuntime.changed,()=>o.presetRuntime.presets,e=>e.presets),theme:r(o.themeRuntime.changed,()=>{var e;let t;return t=(Object.hasOwn(i,(e=o.themeRuntime).preset)?i[e.preset]:{})??{},Object.keys(e.options).length>0?{...t,...e.options}:t},e=>e.theme),assistant:r(o.assistantRuntime.changed,()=>o.assistantRuntime.assistant,e=>e.assistant),navigationStates:r(o.statesRuntime.changed,()=>o.statesRuntime.navigationStates,e=>e.navigationStates),viewStates:r(o.statesRuntime.changed,()=>o.statesRuntime.viewStates,e=>e.viewStates),toolStates:r(o.statesRuntime.changed,()=>o.statesRuntime.toolStates,e=>e.toolStates),exportStates:r(o.statesRuntime.changed,()=>o.statesRuntime.exportStates,e=>e.exportStates),componentOptics:u,createTransformers:r(o.transformersRuntime.changed,()=>t=>e(h,g,t),e=>e.createTransformers),handlers:l,handlerHashes:m,elements:c,elementHashes:p}},n=(e,t,n)=>{let{modelRuntime:s,expressionRuntime:a,actionsRuntime:i,migrationRuntime:o}=e.configurator,r=s.domainBuilder.withExpressions(a.merged).withActions(Object.values(i.definitions)).withActionImplementations(t),l=(n?r.withMigrate(o.migrate):r).build();return{modelVersion:l.context.modelVersion,factory:l,aliasMap:l.context.aliasMap,entityReflections:l.context.entityReflections,$entityReflections:l.context.$entityReflections,allowedRootEntityTypes:l.context.allowedRootEntityTypes,migrate:l.context.migrate}};export const applicationSpecSlice=e=>void 0===e.previous?(e=>{let{runtime:s,spec:a}=e,i=(e=>{let{runtime:s,modules:a,spec:i,defaultElements:o}=e,{expressionRuntime:r,actionsRuntime:l}=s.configurator,{ui:m}=i.configurator,c=i.infra.resourcesConfig,p=a.actionImplementations??{};return{...t(e,void 0),...n(s,p,!0),expressions:r.merged,actions:l.definitions,actionImplementations:p,defaultElements:o,appLoader:m.appLoader??"universal",preview:m.preview??"auto",alwaysExpand:m.alwaysExpand??!1,deploymentQueryDisabled:c?.deploymentQueryDisabled??!1,prefetchTextureUrls:c?.prefetchTextureUrls??[]}})(e),o=a.configurator.ui.textLanguages;return{version:a.appMetadata.applicationVersion,dataConfig:s.data.dataSpec,chunks:s.data.chunks,publishedDataHash:s.data.publishedDataHash,initialPublishedData:{},canCreate:[...a.infra.acl.canCreate],enableAdminRelease:a.appMetadata.enableAdminRelease,textLanguages:o&&o.length>0?o:["en"],baseResourcesUrl:a.infra.resourcesConfig?.baseResourcesUrl??e.environmentResourcesUrl??"",configurator:i,admin:((e,t)=>{let{modelRuntime:n,expressionRuntime:s,migrationRuntime:a,presetRuntime:i,componentOptics:o,statesRuntime:r}=e.runtime.admin,[l]=i.presets;if(void 0===l)throw Error("Cannot register application spec because admin preset is required.");let m=n.domainBuilder.withExpressions(s.merged).withMigrate(a.migrate).build();return{factory:m,modelVersion:m.modelVersion,aliasMap:m.context.aliasMap,entityReflections:m.context.entityReflections,$entityReflections:m.context.$entityReflections,expressions:m.context.expressions,actions:m.context.actions,actionImplementations:m.context.actionImplementations,allowedRootEntityTypes:m.context.allowedRootEntityTypes,migrate:m.context.migrate,preset:l,componentOptics:[...o.optics.map(e=>e.optic),...e.customAdminComponentOptics],navigationStates:r.navigationStates,viewStates:[],handlers:t.handlers,handlerHashes:t.handlerHashes,elements:t.elements,elementHashes:t.elementHashes}})(e,i)}})(e):{...e.previous,configurator:(e=>{let{runtime:s,modules:a,previous:i,model:o}=e,r=i.configurator,{expressionRuntime:l,actionsRuntime:m}=s.configurator,c=t(e,r),p=a.actionImplementations??r.actionImplementations;return"keep"===o?{...r,...c,expressions:l.changed?l.merged:r.expressions,actions:m.changed?m.definitions:r.actions,actionImplementations:p}:{...r,...c,...n(s,p,!1),expressions:l.merged,actions:m.definitions,actionImplementations:p}})(e)};

package/dist/domain/spec/runtime/configurator-runtime/configurator-runtime.d.ts

@@ -0,0 +1,37 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ImportedTransformer } from '../../../application/index.js';
+import type { ImplementationErrorCollector } from '../../errors/index.js';
+import type { ProjectModule } from '../../modules/index.js';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
+import { ExpressionRuntime, type InvariantImplementations, type MissingExpression } from '../expressions/index.js';
+import type { FactoryDataRuntime } from '../factory-data/index.js';
+import { type MigrationModules, MigrationRuntime } from '../migrations/index.js';
+import type { ConfiguratorModelRuntime } from '../model/index.js';
+import { ComponentOptics } from '../optics/index.js';
+import type { RuntimeReferenceStore } from '../runtime-reference-store.js';
+import { ActionsRuntime, AssistantRuntime, PresetRuntime, ThemeRuntime, TransformersRuntime } from '../sections/index.js';
+import type { SpecCodeMap } from '../spec-code/index.js';
+import { ConfiguratorStatesRuntime } from './states-runtime.js';
+export type ConfiguratorRuntime = Branded<'ConfiguratorRuntime', {
+    readonly modelRuntime: ConfiguratorModelRuntime;
+    readonly componentOptics: ComponentOptics;
+    readonly presetRuntime: PresetRuntime;
+    readonly statesRuntime: ConfiguratorStatesRuntime;
+    readonly expressionRuntime: ExpressionRuntime;
+    readonly themeRuntime: ThemeRuntime;
+    readonly transformersRuntime: TransformersRuntime;
+    readonly assistantRuntime: AssistantRuntime;
+    readonly actionsRuntime: ActionsRuntime;
+    readonly migrationRuntime: MigrationRuntime;
+    readonly factoryDataRuntime: FactoryDataRuntime;
+}>;
+export type ConfiguratorRuntimeResult = {
+    readonly ok: true;
+    readonly runtime: ConfiguratorRuntime;
+} | {
+    readonly ok: false;
+    readonly missingExpressions: readonly MissingExpression[];
+    /** The migrations the migration modules do not export, as `migrationRuntime.missingMigrations` lists them. */
+    readonly missingMigrations: readonly string[];
+};
+export declare const ConfiguratorRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, expressionModules: readonly ProjectModule[], importedTransformers: readonly ImportedTransformer[], invariantImplementations: InvariantImplementations | undefined, migrationModules: MigrationModules, code: SpecCodeMap | undefined, errors: ImplementationErrorCollector) => ConfiguratorRuntimeResult;

package/dist/domain/spec/runtime/configurator-runtime/configurator-runtime.js

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{ExpressionRuntime as i}from"../expressions/index.js";import{MigrationRuntime as t}from"../migrations/index.js";import{ComponentOptics as o}from"../optics/index.js";import{ActionsRuntime as r,AssistantRuntime as n,PresetRuntime as s,ThemeRuntime as m,TransformersRuntime as u}from"../sections/index.js";import{ConfiguratorSpecRuntime as c}from"./configurator-spec-runtime.js";import{ConfiguratorStatesRuntime as p}from"./states-runtime.js";export const ConfiguratorRuntime=(a,f,g,R,x,d,j,l)=>{let{modelRuntime:k,factoryDataRuntime:E}=c(a,f,j),S=i(a.configurator,f,g,"configuratorExpressionRuntime",x,j,l),v=t(f,{referenceScope:"configuratorRuntime/migrationRuntime",resolvedVersions:a.configurator.resolvedVersions,latestEntities:k.entities,migrationModules:d});return S.ok?{ok:!0,runtime:e({modelRuntime:k,componentOptics:o(f,{components:a.configurator.components,referenceScope:"configuratorRuntime/componentOptics",modelRuntime:k,code:j}),presetRuntime:s(f,{referenceScope:"configuratorRuntime/presetRuntime",presets:a.configurator.presets.presets}),statesRuntime:p(a,f),expressionRuntime:S.runtime,themeRuntime:m(a,f),transformersRuntime:u(a,f,R),assistantRuntime:n(a,f),actionsRuntime:r(a.configurator.actions,f),migrationRuntime:v,factoryDataRuntime:E})}:{ok:!1,missingExpressions:S.missing,missingMigrations:v.missingMigrations}};

package/dist/domain/spec/runtime/configurator-runtime/configurator-spec-runtime.d.ts

@@ -0,0 +1,16 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
+import { FactoryDataRuntime } from '../factory-data/index.js';
+import { ConfiguratorModelRuntime } from '../model/index.js';
+import type { RuntimeReferenceStore } from '../runtime-reference-store.js';
+import type { SpecCodeMap } from '../spec-code/index.js';
+/**
+ * The sections of the configurator domain that the spec alone determines: its model and the data
+ * of its `phx.domain` factories. `ConfiguratorRuntime` builds its own from this function, so a
+ * build of either in the same reference store returns the same objects.
+ */
+export type ConfiguratorSpecRuntime = Branded<'ConfiguratorSpecRuntime', {
+    readonly modelRuntime: ConfiguratorModelRuntime;
+    readonly factoryDataRuntime: FactoryDataRuntime;
+}>;
+export declare const ConfiguratorSpecRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, code: SpecCodeMap | undefined) => ConfiguratorSpecRuntime;

package/dist/domain/spec/runtime/configurator-runtime/configurator-spec-runtime.js

@@ -0,0 +1 @@
+import{Branded as t}from"@salsita-ai/common/utils";import{FactoryDataRuntime as a}from"../factory-data/index.js";import{ConfiguratorModelRuntime as i}from"../model/index.js";export const ConfiguratorSpecRuntime=(r,o,e)=>{let n=i(r.configurator,o,e);return t({modelRuntime:n,factoryDataRuntime:a(o,{referenceScope:"configuratorRuntime/factoryDataRuntime",invariants:r.configurator.invariants,defaults:r.configurator.defaults,aliases:n.aliases,entities:n.entities})})};

package/dist/domain/spec/runtime/configurator-runtime/index.d.ts

@@ -0,0 +1,2 @@
+export { ConfiguratorRuntime } from './configurator-runtime.js';
+export { ConfiguratorSpecRuntime } from './configurator-spec-runtime.js';

package/dist/domain/spec/runtime/configurator-runtime/index.js

@@ -0,0 +1 @@
+export{ConfiguratorRuntime}from"./configurator-runtime.js";export{ConfiguratorSpecRuntime}from"./configurator-spec-runtime.js";

package/dist/domain/spec/runtime/configurator-runtime/states-runtime.d.ts

@@ -0,0 +1,11 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { RuntimeSpec } from '../../runtime-spec/index.js';
+import type { RuntimeReferenceStore } from '../runtime-reference-store.js';
+export type ConfiguratorStatesRuntime = Branded<'ConfiguratorStatesRuntime', {
+    readonly navigationStates: readonly string[];
+    readonly viewStates: readonly string[];
+    readonly toolStates: readonly string[];
+    readonly exportStates: readonly string[];
+    readonly changed: boolean;
+}>;
+export declare const ConfiguratorStatesRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore) => ConfiguratorStatesRuntime;

package/dist/domain/spec/runtime/create-application.d.ts

@@ -0,0 +1,58 @@
+import { type Messages } from '@lingui/core';
+import { type Application } from '../../domain-runtime/index.js';
+import { type ElementRegistration, type ProjectModule } from '../modules/index.js';
+import type { RuntimeSpec } from '../runtime-spec/index.js';
+import { type ThemePresets } from './application-spec-slice.js';
+import type { MigrationModules } from './migrations/index.js';
+import type { RuntimeReferenceStore } from './runtime-reference-store.js';
+import type { SpecCodeModule } from './spec-code/index.js';
+/**
+ * The project modules of an application, as the generated barrels list them: each file of a
+ * convention folder as `{ origin, exports }`, unchecked; the migration modules of both domains keyed
+ * by project path (`src/migrations/v2.ts`); and the message catalogs of `src/locales/<locale>/`,
+ * keyed by locale. `components` holds the files of `src/components/` and the frontend component
+ * files, in that order, and `elements` every element file the application mounts.
+ */
+export interface ApplicationModules {
+    readonly expressions: readonly ProjectModule[];
+    readonly invariants: readonly ProjectModule[];
+    readonly actions: readonly ProjectModule[];
+    readonly components: readonly ProjectModule[];
+    readonly handlers: readonly ProjectModule[];
+    readonly elements: readonly ProjectModule[];
+    readonly transformers: readonly ProjectModule[];
+    readonly adminExpressions: readonly ProjectModule[];
+    readonly adminInvariants: readonly ProjectModule[];
+    readonly adminComponents: readonly ProjectModule[];
+    readonly migrations: MigrationModules;
+    readonly catalogs: Readonly<Record<string, Messages>>;
+}
+export interface CreateApplicationInput {
+    /** The runtime spec, `.phoenix/application-spec.json` decoded with `decodeRuntimeSpec`. */
+    readonly spec: RuntimeSpec;
+    /** The store `createPhx` built the `phx` values in. */
+    readonly referenceStore: RuntimeReferenceStore;
+    /** The generated `.phoenix/spec-code.ts` module of the same generation as `spec`. */
+    readonly specCode?: SpecCodeModule | undefined;
+    readonly modules: ApplicationModules;
+    /** The SDK's default elements of the application kind; a project element with the same name replaces one. */
+    readonly defaultElements: readonly ElementRegistration[];
+    /** The SDK's theme presets by name, `getPhoenixThemes()`. */
+    readonly themePresets: ThemePresets;
+    readonly environment?: Application['environment'] | undefined;
+    /** The services a host provides; i18n is built from the catalogs. */
+    readonly services?: Omit<Application['services'], 'i18n'> | undefined;
+    /** The tag the web component mounts as; by default the spec's `webComponentTag`, else `salsita-configurator`. */
+    readonly tag?: string | undefined;
+}
+/**
+ * Builds an application from its runtime spec and its project modules, ready to mount, with no
+ * `ConfiguratorBuilder` and no `ApplicationConfig`: the full `ApplicationRuntime` in the store
+ * `createPhx` built the `phx` values in, the spec slice of the domain runtime, the initial published
+ * data and i18n.
+ *
+ * Every mistake of the project's files is reported at once, as one `ImplementationErrors`: a file
+ * that breaks its folder's contract, an expression defined twice or one the spec already gives a
+ * value, a declared expression no file implements and a migration no file exports.
+ */
+export declare const createApplication: <TYPES = unknown>(input: CreateApplicationInput) => Application<TYPES>;

package/dist/domain/spec/runtime/create-application.js

@@ -0,0 +1 @@
+import{setupI18n as e}from"@lingui/core";import{initConsoleLogger as i}from"@salsita-ai/common/utils";import{defaultI18n as t,mergeCatalogs as o,sdkCatalog as n}from"#package/i18n";import{checkSingleInstanceHandlers as r,createInitialPublishedData as a}from"../../application/index.js";import{NoopAnalyticsSystem as s}from"../../domain-context/index.js";import{createDomainRuntime as m,resolveTransformerModule as l}from"../../domain-runtime/index.js";import{ImplementationError as c,createImplementationErrorCollector as p}from"../errors/index.js";import{resolveActionModules as u,resolveComponentOpticModules as d,resolveElementModule as f,resolveHandlerModule as g,resolveInvariantModules as h}from"../modules/index.js";import{ApplicationRuntime as v}from"./application-runtime.js";import{applicationSpecSlice as x}from"./application-spec-slice.js";let E=(e,i,t)=>e.filter(e=>t.attempt(()=>(i(e),!0),!1)),M=(e,i,t)=>e.flatMap(e=>t.attempt(()=>i(e),[]));export const createApplication=b=>{let{spec:j,referenceStore:w,specCode:I,modules:T,environment:k={}}=b,A=p(),C=M(T.handlers,g,A),R=M(T.elements,f,A),y=M(T.transformers,e=>[l(e)],A),N=M(T.components,e=>d([e]),A),P=M(T.adminComponents,e=>d([e]),A),S=E(T.invariants,e=>h([e]),A),L=E(T.adminInvariants,e=>h([e]),A),O=E(T.actions,e=>u([e]),A),U=v(j,w,T.expressions,y,h(S),T.adminExpressions,h(L),T.migrations,I,A);if((U.ok?[...U.runtime.configurator.migrationRuntime.missingMigrations,...U.runtime.admin.migrationRuntime.missingMigrations]:U.missingMigrations).forEach(e=>A.add((e=>{let[i=e,t="migrateToVN"]=e.split("#");return new c({code:"MISSING_IMPLEMENTATION",origin:i,problem:`The migration ${t} is missing`,fix:`The spec declares the model version this file migrates to, so the file must export ${t}, the function that turns a state of the previous version into one of this version; without it a saved configuration of an earlier version cannot load. Add or rename the export.`})})(e))),A.throwIfAny(),!U.ok)throw Error("The application runtime could not be built, but no implementation error was recorded.");r(C);let $=x({runtime:U.runtime,spec:j,modules:{handlers:{handlers:C},elements:{elements:R},customComponentOptics:N,actionImplementations:u(O)},customAdminComponentOptics:P,defaultElements:b.defaultElements,themePresets:b.themePresets,environmentResourcesUrl:k.defaultEnvs?.resourcesUrl}),D=i(),F=a({adminDomainFactory:$.admin.factory,domainRuntime:m({application:{spec:$,environment:k},services:{analyticsService:new s,i18n:t,logger:D}}),adminPresets:U.runtime.admin.presetRuntime.presets,handlers:$.configurator.handlers,dataSpec:$.dataConfig??void 0,chunks:$.chunks,logger:D});return{spec:{...$,initialPublishedData:F},environment:k,services:{...b.services,i18n:e({messages:o([n,T.catalogs],j.configurator.ui.availableLocales),locale:j.configurator.ui.availableLocales[0]})},tag:b.tag??j.appMetadata.webComponentTag??"salsita-configurator"}};

package/dist/domain/spec/runtime/expressions/expression-runtime.d.ts

@@ -0,0 +1,57 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type DomainEntity, type Expression as DomainExpression, type Invariant as DomainInvariant } from '../../../core/index.js';
+import { type ImplementationErrorCollector } from '../../errors/index.js';
+import { type Expressions } from '../../expressions/index.js';
+import { type ProjectModule } from '../../modules/index.js';
+import { type RuntimeModelVersion } from '../../runtime-spec/index.js';
+import type { RuntimeReferenceStore } from '../runtime-reference-store.js';
+import type { SpecCodeMap } from '../spec-code/index.js';
+type RuntimeData = Record<string, unknown>;
+type RuntimeEntity = DomainEntity<string>;
+type AnyExpression = DomainExpression<RuntimeEntity, RuntimeEntity, RuntimeData, RuntimeData, RuntimeData, RuntimeEntity, unknown>;
+type SdkInvariant = DomainInvariant<RuntimeEntity, RuntimeEntity, RuntimeData, RuntimeData, RuntimeData, RuntimeEntity, string>;
+/**
+ * Flat, entity-keyed expression map stored in the runtime spec slice and derived into the
+ * memoized table returned by `DomainContextSelectors.getDomainExpressions()`.
+ */
+export type ExpressionImplementations = Record<DomainEntity<string>['type'], Record<string, AnyExpression>>;
+/** Invariant implementations keyed by their concrete entity type or alias declaration. */
+export type InvariantImplementations = Readonly<Record<string, readonly SdkInvariant[]>>;
+export type MissingExpression = {
+    readonly entityType: string;
+    readonly exprName: string;
+};
+export type ExpressionRuntime = Branded<'ExpressionRuntime', {
+    readonly merged: ExpressionImplementations;
+    readonly changed: boolean;
+}>;
+export type ExpressionRuntimeResult = {
+    readonly ok: true;
+    readonly runtime: ExpressionRuntime;
+} | {
+    readonly ok: false;
+    readonly missing: readonly MissingExpression[];
+};
+interface ExpressionRuntimeSpec {
+    readonly expressions: Expressions;
+    readonly latestModel: RuntimeModelVersion;
+}
+/**
+ * Runtime section that produces the single merged expression map for the registry.
+ *
+ * Dispatches on `expression.implementation.kind`:
+ * - `relation` / `violations` — calls the matching SDK factory with params + runtime context
+ * - `user` — uses the implementation of the project files `expressionModules` (`src/expressions/`,
+ *   or `src/admin/expressions/`), merged with the spec's aliases by `mergeExpressionModules`, or the
+ *   one `builtIn` holds
+ * - `value` — evaluates the parsed {@link MemoEvalPlan}; stabilized per
+ *   {@link canonicalEnhancedJsonValueKey} so identical values reuse the same
+ *   evaluator across rebuilds. Its `$eval` code comes from `code`, the domain's map of the generated
+ *   code module, when that holds it.
+ *
+ * A file that is wrong, or that defines an expression another file, the spec or `builtIn` already
+ * defines, is recorded in `errors` as an `ImplementationError` and left out. So is every declared
+ * expression without an implementation, which also makes the result an error.
+ */
+export declare const ExpressionRuntime: (spec: ExpressionRuntimeSpec, referenceStore: RuntimeReferenceStore, expressionModules: readonly ProjectModule[], referenceScopePrefix: string, invariantImplementations: InvariantImplementations | undefined, code: SpecCodeMap | undefined, errors: ImplementationErrorCollector, builtIn?: ExpressionImplementations) => ExpressionRuntimeResult;
+export {};

package/dist/domain/spec/runtime/expressions/expression-runtime.js

@@ -0,0 +1 @@
+import e from"lodash-es/isEqual.js";import{Branded as t}from"@salsita-ai/common/utils";import{createRelationFactory as i}from"../../../core/index.js";import{canonicalEnhancedJsonValueKey as n}from"../../enhanced-json/index.js";import{ImplementationError as a}from"../../errors/index.js";import{isSdkExpressionImplementation as r}from"../../expressions/index.js";import{mergeExpressionModules as o}from"../../modules/index.js";import{specCodeExpressionKey as s}from"../../runtime-spec/index.js";import{generateMemoEvalPlanRuntime as l}from"./generate-memo-eval-plan-runtime.js";let p={},m=["0-1","1-1","0-N","1-N"],d={relation:(e,t)=>{let n=t[0];if(!("object"==typeof n&&null!==n&&"kind"in n&&"target"in n&&"string"==typeof n.target&&"cardinality"in n&&m.includes(n.cardinality)&&("allOfType"===n.kind||("direct"===n.kind||"indirect"===n.kind)&&"field"in n&&"string"==typeof n.field)))throw Error("Cannot create the relation expression because its parameter is not a relation declaration. The application spec is inconsistent; rebuild it from a valid relations declaration.");return i(e.aliasMap)(n)},violations:(e,t)=>{let i=t[0];if("object"!=typeof i||null===i||!("entityType"in i)||"string"!=typeof i.entityType)throw Error("Cannot create the violations expression because its entityType parameter is missing. The application spec is inconsistent; rebuild it from a valid invariants declaration.");let n=i.entityType,a=Object.entries(e.invariantImplementations).flatMap(([t,i])=>{let a=e.aliasMap[t];return t===n||a?.includes(n)?i:[]});return{origin:{name:"$violations",typeOrAlias:n},evaluate:(e,t,i)=>a.flatMap(n=>n.evaluate(e,t,i)),meta:{}}}},f=e=>{let t=l(e.plan,s(e.entityOrAlias,e.name),e.code);return{origin:{name:e.name,typeOrAlias:e.entityOrAlias},evaluate:(e,i,n)=>t(n.domain.get$Entity(e,i),i,n),meta:{}}},u=e=>({...(0,d[e.kind])({aliasMap:e.aliasMap,invariantImplementations:e.invariantImplementations},e.params),origin:{name:e.name,typeOrAlias:e.entityOrAlias}});export const ExpressionRuntime=(i,s,l,m,d=p,c,y,g={})=>{let x={};for(let[e,t]of i.latestModel.aliases)x[String(e)]=t.map(String);let v={...g};for(let[e,t]of Object.entries(o(l,x,y,((e,t,i)=>{let n=new Map,a=(e,t)=>{n.set(e,(n.get(e)??new Set).add(t))};for(let[i,n]of e.expressions.expressions)for(let[e,r]of n)if("user"!==r.implementation.kind)for(let n of t[String(i)]??[String(i)])a(n,String(e));for(let[e,t]of Object.entries(i))for(let i of Object.keys(t))a(e,i);return n})(i,x,g))))v[e]={...v[e],...t};let S=s.createBuilder(`${m}/sdk`,{build:u,getKey:e=>`sdk::${e.entityOrAlias}::${e.name}`,compare:(t,i)=>t.kind===i.kind&&e(t.params,i.params)&&e(t.aliasMap,i.aliasMap)&&("violations"!==i.kind||t.invariantImplementations===i.invariantImplementations)}),h=s.createBuilder(`${m}/user`,{build:e=>e.impl,getKey:e=>`user::${e.entityType}::${e.name}`,compare:(e,t)=>{let i,n;return(i=e.impl)===(n=t.impl)||i.evaluate===n.evaluate&&i.meta===n.meta&&i.origin.name===n.origin.name&&i.origin.typeOrAlias===n.origin.typeOrAlias}}),O=s.createBuilder(`${m}/value`,{build:f,getKey:e=>`value::${e.entityOrAlias}::${e.name}`,compare:(e,t)=>e.valueKey===t.valueKey&&e.code===t.code}),b={},j=!1,k=new Set,$=new Set,M=new Set;for(let[e,t]of i.expressions.expressions)for(let[,i]of t){let t=x[String(e)]??[String(e)];if(r(i.implementation)){let n={entityOrAlias:String(e),name:String(i.name),kind:i.implementation.kind,params:i.implementation.params,aliasMap:x,invariantImplementations:d},a=S.build(n);for(let e of(a.changed&&(j=!0),k.add(S.getKey(n)),t))b[e]||(b[e]={}),b[e][String(i.name)]=a.output;continue}if("value"===i.implementation.kind){let a=i.implementation.value,r={entityOrAlias:String(e),name:String(i.name),valueKey:n(a),plan:i.implementation.plan,code:c},o=O.build(r);for(let e of(o.changed&&(j=!0),M.add(O.getKey(r)),t))b[e]||(b[e]={}),b[e][String(i.name)]=o.output;continue}}for(let[e,t]of Object.entries(v))for(let[i,n]of Object.entries(t)){let t={entityType:e,name:i,impl:n},a=h.build(t);a.changed&&(j=!0),$.add(h.getKey(t)),b[e]||(b[e]={}),b[e][i]=a.output}S.cleanup(k)&&(j=!0),h.cleanup($)&&(j=!0),O.cleanup(M)&&(j=!0);let A=[];for(let[e,t]of i.expressions.entityExpressions)for(let n of t.shapeGroups){let t=i.expressions.expressions.get(n);if(t)for(let[i]of t)b[String(e)]?.[String(i)]||A.push({entityType:String(e),exprName:String(i)})}return A.length>0?(A.forEach(e=>y.add(new a({code:"MISSING_IMPLEMENTATION",origin:null,problem:`Missing implementation of expression ${e.entityType}.${e.exprName}`,fix:"The spec declares it without a value of its own ($eval, $msg or a read), so a project file implements it: a default export of phx.domain.implementCustomExpressions({ ... }) in src/expressions/, or of phx.domain.admin.implementCustomExpressions({ ... }) in src/admin/expressions/ for an admin entity type. Implement it, or remove the declaration from the spec."}))),{ok:!1,missing:A}):{ok:!0,runtime:t({merged:b,changed:j})}};

package/dist/domain/spec/runtime/expressions/generate-memo-eval-plan-runtime.d.ts

@@ -0,0 +1,33 @@
+import type { SelfAccessor } from '../../enhanced-json/index.js';
+import type { MemoEvalPlan } from '../../expressions/index.js';
+import { type SpecCodeMap } from '../spec-code/index.js';
+/**
+ * Runtime counterpart to
+ * {@link ../../code/templates/domain-spec/generate-memo-eval-plan-code#generateMemoEvalPlanCode | generateMemoEvalPlanCode}.
+ * Produces a `(self) => value` reader function that evaluates each dep against
+ * `self` and splices the resulting values into the plan's template tree:
+ *
+ * - Static (no deps): evaluates the template once and returns a `() => cached`
+ *   thunk — no allocation per call. (Codegen emits a zero-dep `memoEval` for the
+ *   same case so contextual typing reaches the body; the stability contract is
+ *   identical.)
+ * - With deps: wraps the per-dep resolution in `memoEval` so equal dep arrays
+ *   short-circuit to the cached body, matching codegen semantics exactly.
+ *
+ * Each `$eval` dep is the closure the generated code module holds under its spec code id
+ * (`<key>#<n>`, `key` naming the expression or component the plan belongs to), or its text
+ * compiled with `new Function` when there is no such closure; each `$target` dep reads
+ * `self[target]` verbatim. `$msg` markers inside the
+ * template lower to `{ id?, message }` descriptors for i18n consumers.
+ */
+type MemoEvalPlanRuntimeReader = (self: SelfAccessor, state?: unknown, ctx?: unknown) => unknown;
+export declare const generateMemoEvalPlanRuntime: (plan: MemoEvalPlan, key: string, code: SpecCodeMap | undefined) => MemoEvalPlanRuntimeReader;
+/**
+ * Runtime counterpart to
+ * {@link ../../code/templates/domain-spec/generate-static-value-code#generateStaticValueCode | generateStaticValueCode}:
+ * evaluates a self-free plan once to the plain value a module-level constant holds. Plans that read
+ * `self` need an entity instance and are rejected. `key` and `code` resolve its `$eval` code as in
+ * {@link generateMemoEvalPlanRuntime}.
+ */
+export declare const evaluateStaticMemoEvalPlan: (plan: MemoEvalPlan, key: string, code: SpecCodeMap | undefined) => unknown;
+export {};

package/dist/domain/spec/runtime/expressions/generate-memo-eval-plan-runtime.js

@@ -0,0 +1 @@
+import{memoEval as e}from"../../../utils/index.js";import{createMessageDescriptor as t}from"../../markers/index.js";import{specCodeEvalIds as r}from"../../runtime-spec/index.js";import{resolveSpecCode as a}from"../spec-code/index.js";let n=(e,r)=>{if("literal"===e.kind)return e.value;if("slot"===e.kind)return r[e.depIndex];if("msg"===e.kind)return t(e.marker);if("array"===e.kind)return e.items.map(e=>n(e,r));let a={};for(let[t,l]of e.entries)a[t]=n(l,r);return a};export const generateMemoEvalPlanRuntime=(t,l,i)=>{if(0===t.deps.length){let e=n(t.template,[]);return()=>e}let s=r(t,l),o=t.deps.map((e,t)=>{let r=s[t];return"eval"===e.kind&&void 0!==r?a(i,r,e.code):void 0});return e(e=>t.deps.map((t,r)=>"eval"===t.kind?o[r](e):Reflect.get(e,t.target)),(...e)=>n(t.template,e))};export const evaluateStaticMemoEvalPlan=(e,t,l)=>{if(e.usesSelf)throw Error("Cannot evaluate a plan that uses self as a static value. Filter self-dependent plans before evaluating constants.");let i=r(e,t),s=e.deps.map((e,t)=>{if("read"===e.kind)throw Error(`Cannot evaluate the self-dependent read "${e.target}" as a static value. Filter self-dependent plans before evaluating constants.`);return a(l,i[t],e.code)()});return n(e.template,s)};

package/dist/domain/spec/runtime/expressions/index.d.ts

@@ -0,0 +1,3 @@
+export { ExpressionRuntime, type ExpressionImplementations, type InvariantImplementations, type MissingExpression, } from './expression-runtime.js';
+export { evaluateStaticMemoEvalPlan, generateMemoEvalPlanRuntime } from './generate-memo-eval-plan-runtime.js';
+export { evaluateReflectionConstants, findReflectionConstants } from './reflection-constants-runtime.js';

package/dist/domain/spec/runtime/expressions/index.js

@@ -0,0 +1 @@
+export{ExpressionRuntime}from"./expression-runtime.js";export{evaluateStaticMemoEvalPlan,generateMemoEvalPlanRuntime}from"./generate-memo-eval-plan-runtime.js";export{evaluateReflectionConstants,findReflectionConstants}from"./reflection-constants-runtime.js";

package/dist/domain/spec/runtime/expressions/reflection-constants-runtime.d.ts

@@ -0,0 +1,11 @@
+import type { Expressions, MemoEvalPlan } from '../../expressions/index.js';
+import type { ExpressionName } from '../../model/index.js';
+import type { SpecCodeMap } from '../spec-code/index.js';
+/** The self-free `constants:` plans declared on one entity or alias, or `undefined` when it has none. */
+export declare const findReflectionConstants: (expressions: Expressions, entityOrAlias: string) => ReadonlyMap<ExpressionName, MemoEvalPlan> | undefined;
+/**
+ * Runtime counterpart of the constants literal codegen passes to an enhanced reflection: the
+ * entity's or alias's self-free `constants:` values evaluated once to plain values, keyed by name.
+ * Their `$eval` code comes from `code` when the generated code module holds it.
+ */
+export declare const evaluateReflectionConstants: (expressions: Expressions, entityOrAlias: string, code: SpecCodeMap | undefined) => Readonly<Record<string, unknown>>;

package/dist/domain/spec/runtime/expressions/reflection-constants-runtime.js

@@ -0,0 +1 @@
+import{specCodeExpressionKey as t}from"../../runtime-spec/index.js";import{evaluateStaticMemoEvalPlan as n}from"./generate-memo-eval-plan-runtime.js";export const findReflectionConstants=(t,n)=>{for(let[e,o]of t.constants)if(String(e)===n)return o};export const evaluateReflectionConstants=(e,o,r)=>{let i=findReflectionConstants(e,o);return i?Object.fromEntries([...i].map(([e,i])=>[String(e),n(i,t(o,String(e)),r)])):{}};

package/dist/domain/spec/runtime/factory-data/factory-data-runtime.d.ts

@@ -0,0 +1,44 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { AnyEntityReflections, DomainEntity, DomainEntityReflection } from '../../../core/index.js';
+import type { Invariants } from '../../invariants/index.js';
+import type { Defaults } from '../../model/index.js';
+import type { RuntimeReferenceStore } from '../runtime-reference-store.js';
+import { type RecipeDefaults } from './recipe-defaults.js';
+import { type StaticViolations } from './static-violations.js';
+interface FactoryDataRuntimeFields {
+    /**
+     * The member types of each alias: what `phx.domain.attachComponent` expands an alias with, and
+     * what `phx.domain.createRecipe` expands alias defaults with.
+     */
+    readonly aliases: Readonly<Record<string, readonly string[]>>;
+    /** The entity reflections `phx.domain.createRecipe` validates the defaults with. */
+    readonly entityReflections: ReadonlyArray<DomainEntityReflection<DomainEntity<string>>>;
+    /** The violations `phx.domain.implementCustomInvariants` reports for a static invariant that fails. */
+    readonly staticViolations: StaticViolations;
+    /** The defaults `phx.domain.createRecipe` puts into a new recipe. */
+    readonly defaults: RecipeDefaults;
+    readonly changed: boolean;
+}
+/**
+ * The data the `phx.domain` factories of one domain carry, built from the parsed spec: the static
+ * violations of `implementCustomInvariants`, the aliases of `attachComponent`, and the aliases,
+ * entity reflections and defaults of `createRecipe`. Generated `domain-spec.ts` passes the same
+ * values to those factories as literals; with this section the factories can be built from the
+ * spec instead. The configurator and the admin domain each have one.
+ */
+export type FactoryDataRuntime = Branded<'FactoryDataRuntime', FactoryDataRuntimeFields>;
+interface FactoryDataRuntimeInput {
+    readonly invariants: Invariants;
+    readonly defaults: Defaults;
+    readonly aliases: Readonly<Record<string, readonly string[]>>;
+    readonly entities: AnyEntityReflections;
+}
+interface FactoryDataRuntimeProps extends FactoryDataRuntimeInput {
+    readonly referenceScope: string;
+}
+/**
+ * Builds the factory data of one domain. The result keeps its reference while the invariants and
+ * defaults are equal and the model runtime's aliases and entity reflections are the same objects.
+ */
+export declare const FactoryDataRuntime: (referenceStore: RuntimeReferenceStore, props: FactoryDataRuntimeProps) => FactoryDataRuntime;
+export {};

package/dist/domain/spec/runtime/factory-data/recipe-defaults.d.ts

@@ -0,0 +1,13 @@
+import type { Defaults } from '../../model/index.js';
+/**
+ * The default property values of each entity type, keyed by entity type: what
+ * `phx.domain.createRecipe` puts into a new recipe before the caller's overrides. Alias entries are
+ * already expanded to their member types by the parser.
+ */
+export type RecipeDefaults = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+/**
+ * The runtime counterpart of the `defaults` literal the generated `domain-spec.ts` passes to
+ * `createRecipeFactory`: the parsed per-entity defaults with every `$msg` lowered to the descriptor
+ * the `msg` macro produces.
+ */
+export declare const createRecipeDefaults: (defaults: Defaults) => RecipeDefaults;

package/dist/domain/spec/runtime/factory-data/recipe-defaults.js

@@ -0,0 +1 @@
+import{createMessageDescriptor as e,isEvalMarker as t,isMsgMarker as r}from"../../markers/index.js";let s=(a,i)=>{if(null===a||"object"!=typeof a)return a;if(r(a))return e(a);if(t(a))throw Error(`The default at ${i} is an $eval expression. Defaults are static values; the parser rejects $eval in them, so the spec given to the runtime was not produced by it. Parse the spec again and pass the result.`);return Array.isArray(a)?a.map((e,t)=>s(e,`${i}[${t}]`)):Object.fromEntries(Object.entries(a).map(([e,t])=>[e,s(t,`${i}.${e}`)]))};export const createRecipeDefaults=e=>Object.fromEntries(Object.entries(e.entries).map(([e,t])=>[e,Object.fromEntries(Object.entries(t).map(([t,r])=>[t,s(r,`${e}.${t}`)]))]));

package/dist/domain/spec/runtime/factory-data/static-violations.d.ts

@@ -0,0 +1,16 @@
+import type { Violation } from '../../../core/index.js';
+import type { Invariants } from '../../invariants/index.js';
+/**
+ * The violation each static invariant of a domain reports when its implementation returns `false`,
+ * by entity type or alias and by invariant name. `phx.domain.implementCustomInvariants` closes over
+ * it: a project implements a static invariant as a boolean and the factory turns `false` into this
+ * violation.
+ */
+export type StaticViolations = Readonly<Record<string, Readonly<Record<string, Violation<string>>>>>;
+/**
+ * The runtime counterpart of the `staticViolations` literal the generated `domain-spec.ts` passes
+ * to `createCustomInvariantFactory`: one entry per static invariant, keyed as the spec declares it,
+ * with a `$msg` message lowered to the descriptor the `msg` macro produces. Types and aliases
+ * without a static invariant have no entry.
+ */
+export declare const createStaticViolations: (invariants: Invariants) => StaticViolations;

package/dist/domain/spec/runtime/factory-data/static-violations.js

@@ -0,0 +1 @@
+import{createMessageDescriptor as t}from"../../markers/index.js";export const createStaticViolations=e=>{let i={};for(let[o,r]of Object.entries(e.entries))for(let e of Object.values(r)){if("static"!==e.kind)continue;let r={type:String(e.violationType),severity:e.severity,message:"string"==typeof e.message?e.message:t(e.message),...void 0===e.controlViolationPriority?{}:{controlViolationPriority:e.controlViolationPriority}};i[o]={...i[o],[String(e.name)]:r}}return i};

package/dist/domain/spec/runtime/generate-runtime-instance.d.ts

@@ -0,0 +1,2 @@
+import { ApplicationInstance } from '../application/index.js';
+export declare const generateRuntimeInstance: (applicationInstance: ApplicationInstance) => ApplicationInstance;

package/dist/domain/spec/runtime/generate-runtime-instance.js

@@ -0,0 +1 @@
+import{ApplicationInstance as n}from"../application/index.js";export const generateRuntimeInstance=e=>n(e.applicationVersion);

package/dist/domain/spec/runtime/index.d.ts

@@ -0,0 +1,13 @@
+export { ApplicationRuntime, type ApplicationRuntimeResult } from './application-runtime.js';
+export { applicationSpecSlice, type ApplicationSpecSliceModules } from './application-spec-slice.js';
+export { type ApplicationModules, createApplication } from './create-application.js';
+export { generateRuntimeInstance } from './generate-runtime-instance.js';
+export { SpecRuntime } from './spec-runtime.js';
+export * from './expressions/index.js';
+export * from './factory-data/index.js';
+export * from './migrations/index.js';
+export * from './model/index.js';
+export * from './optics/index.js';
+export * from './runtime-reference-store.js';
+export * from './sections/index.js';
+export * from './spec-code/index.js';

package/dist/domain/spec/runtime/index.js

@@ -0,0 +1 @@
+export{ApplicationRuntime}from"./application-runtime.js";export{applicationSpecSlice}from"./application-spec-slice.js";export{createApplication}from"./create-application.js";export{generateRuntimeInstance}from"./generate-runtime-instance.js";export{SpecRuntime}from"./spec-runtime.js";export*from"./expressions/index.js";export*from"./factory-data/index.js";export*from"./migrations/index.js";export*from"./model/index.js";export*from"./optics/index.js";export*from"./runtime-reference-store.js";export*from"./sections/index.js";export*from"./spec-code/index.js";

package/dist/domain/spec/runtime/migrations/migration-runtime.d.ts

@@ -0,0 +1,53 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type AnyEntityReflections, type DomainEntity, type MigrateFunction, type Migration } from '../../../core/index.js';
+import type { RuntimeResolvedVersions } from '../../runtime-spec/index.js';
+import type { RuntimeReferenceStore } from '../runtime-reference-store.js';
+type AnyEntity = DomainEntity<string>;
+type AnyMigration = Migration<AnyEntity, AnyEntity>;
+/**
+ * The project's migration modules, keyed by the project path the parser records for each model
+ * version (`src/migrations/v2.ts`, `src/admin/migrations/v2.ts`), each holding the module's exports.
+ * The module of version `N` exports the migration to that version as `migrateToV<N>`, the name the
+ * generated `domain.ts` imports.
+ */
+export type MigrationModules = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+interface MigrationRuntimeFields {
+    /** The entity reflections of each model version, keyed by version; the latest is the domain's own. */
+    readonly modelVersions: Readonly<Record<number, AnyEntityReflections>>;
+    /** The migration to each version, keyed by the version it yields. */
+    readonly migrations: Readonly<Record<number, AnyMigration>>;
+    readonly migrate: MigrateFunction<AnyEntity>;
+    /**
+     * The migrations the spec declares but the migration modules do not provide, as
+     * `<migration file>#migrateToV<N>`. A state that needs one fails to load with a
+     * `StateMigrationError` naming the missing step.
+     */
+    readonly missingMigrations: readonly string[];
+    readonly changed: boolean;
+}
+/**
+ * How a domain migrates a stored state of any of its model versions to the latest one: the entity
+ * reflections of every version, the project's migration to each version above the first, and the
+ * migrate function built from both, which `DomainBuilder.withMigrate` takes.
+ *
+ * The configurator and the admin domain each have one. The admin domain's factory first applies the
+ * SDK's own migration of the common admin entities (`migrateCommonAdminDomain`) and then this one.
+ */
+export type MigrationRuntime = Branded<'MigrationRuntime', MigrationRuntimeFields>;
+interface MigrationRuntimeInput {
+    readonly resolvedVersions: RuntimeResolvedVersions;
+    readonly latestEntities: AnyEntityReflections;
+    readonly migrationModules: MigrationModules;
+}
+interface MigrationRuntimeProps extends MigrationRuntimeInput {
+    readonly referenceScope: string;
+}
+/**
+ * Builds a domain's migrations from its resolved model versions and the project's migration
+ * modules: the runtime counterpart of the `modelVersions` literal of the generated `domain-spec.ts`
+ * and the `createMigrateFunction(...)` call of the generated `domain.ts`. The latest version uses the
+ * domain's own entity reflections, as generated code does. The result keeps its reference while
+ * the versions, the latest reflections and the migration modules stay the same.
+ */
+export declare const MigrationRuntime: (referenceStore: RuntimeReferenceStore, props: MigrationRuntimeProps) => MigrationRuntime;
+export {};

package/dist/domain/spec/runtime/migrations/migration-runtime.js

@@ -0,0 +1 @@
+import e from"lodash-es/isEqual.js";import{Branded as i}from"@salsita-ai/common/utils";import{DomainEntityReflection as t,createMigrateFunction as s}from"../../../core/index.js";let o=e=>"function"==typeof e,r=e=>`migrateToV${e}`,n=e=>{let{resolvedVersions:i,latestEntities:n,migrationModules:l}=e,a={},m={},d=[];for(let e of i.versionedModels){if(e.isLatest)a[e.version]=n;else{let i={};for(let s of e.modelVersion.entitySchemas)i[String(s.entityType)]=new t(String(s.entityType),[s.shapeSchema]);a[e.version]=i}if(void 0===e.migrationFile)continue;let i=r(e.version),s=l[e.migrationFile]?.[i];o(s)?m[e.version]=s:d.push(`${e.migrationFile}#${i}`)}return{modelVersions:a,migrations:m,migrate:s(a,i.latestVersion,m),missingMigrations:d}},l=e=>e.versionedModels.map(e=>({version:e.version,isLatest:e.isLatest,migrationFile:e.migrationFile,schemas:e.isLatest?[]:e.modelVersion.entitySchemas.map(e=>e.shapeSchema)})),a=(i,t)=>i.latestEntities===t.latestEntities&&i.resolvedVersions.latestVersion===t.resolvedVersions.latestVersion&&e(l(i.resolvedVersions),l(t.resolvedVersions))&&i.resolvedVersions.versionedModels.every(e=>void 0===e.migrationFile||i.migrationModules[e.migrationFile]===t.migrationModules[e.migrationFile]);export const MigrationRuntime=(e,t)=>{let s=e.createBuilder(t.referenceScope,{build:n,getKey:()=>"singleton",compare:a}).build({resolvedVersions:t.resolvedVersions,latestEntities:t.latestEntities,migrationModules:t.migrationModules});return i({...s.output,changed:s.changed})};

package/dist/domain/spec/runtime/model/admin-model-runtime.d.ts

@@ -0,0 +1,31 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type $DomainEntity, $DomainEntityReflection, type DomainEntity, DomainEntityReflection, RawAliasReflection, SchemaReflection } from '../../../core/index.js';
+import { DomainBuilder } from '../../../domain-builder/index.js';
+import type { Expressions } from '../../expressions/index.js';
+import type { RuntimeDataSchemas, RuntimeModelVersion, RuntimeResolvedVersions } from '../../runtime-spec/index.js';
+import type { RuntimeReferenceStore } from '../runtime-reference-store.js';
+import type { SpecCodeMap } from '../spec-code/index.js';
+type AnyEntity = DomainEntity<string>;
+type AnyAliases = Record<string, AnyEntity>;
+type AnyData = Record<string, unknown>;
+type Any$Map = Record<AnyEntity['type'], $DomainEntity<AnyEntity>>;
+type AnyDomainBuilder = DomainBuilder<AnyEntity, AnyEntity, AnyAliases, Any$Map, AnyData, AnyData, AnyData>;
+interface AdminModelRuntimeSpec {
+    readonly expressions: Expressions;
+    readonly latestModel: RuntimeModelVersion;
+    readonly resolvedVersions: RuntimeResolvedVersions;
+}
+interface AdminModelRuntimeFields {
+    readonly entities: Record<string, DomainEntityReflection<AnyEntity>>;
+    readonly aliasReflections: Record<string, RawAliasReflection<AnyEntity>>;
+    readonly commonTypeReflections: Record<string, SchemaReflection<unknown>>;
+    readonly aliases: Record<string, readonly string[]>;
+    readonly $entityReflections: Record<string, $DomainEntityReflection<$DomainEntity<AnyEntity>>>;
+    readonly rootEntityTypes: readonly string[];
+    readonly modelVersion: number;
+    readonly domainBuilder: AnyDomainBuilder;
+    readonly schemaChanged: boolean;
+}
+export type AdminModelRuntime = Branded<'AdminModelRuntime', AdminModelRuntimeFields>;
+export declare const AdminModelRuntime: (domainSpec: AdminModelRuntimeSpec, dataSchemas: RuntimeDataSchemas, referenceStore: RuntimeReferenceStore, code: SpecCodeMap | undefined) => AdminModelRuntime;
+export {};

package/dist/domain/spec/runtime/model/admin-model-runtime.js

@@ -0,0 +1 @@
+import e from"lodash-es/isEqual.js";import{Branded as t}from"@salsita-ai/common/utils";import{$DomainEntityReflection as s,DomainEntityReflection as a,RawAliasReflection as i,SchemaReflection as n}from"../../../core/index.js";import{DomainBuilder as o}from"../../../domain-builder/index.js";import{evaluateReflectionConstants as r,findReflectionConstants as m}from"../expressions/index.js";let l=e=>({latestVersion:e.resolvedVersions.latestVersion,versionedModels:e.resolvedVersions.versionedModels.map(e=>({version:e.version,key:e.key,isLatest:e.isLatest,migrationFile:e.migrationFile}))}),p=e=>{let t=[];for(let[s,a]of e.expressions.entityExpressions)t.push({entityType:String(s),shapeGroups:a.shapeGroups.map(String),expressionNamesByGroup:a.shapeGroups.map(t=>{let s=e.expressions.expressions.get(t);return{group:String(t),names:s?[...s.keys()].map(String):[]}}),constants:[...m(e.expressions,String(s))??[]].map(([e,t])=>[String(e),t])});return t},d=(t,s)=>{let a,i;return t.code===s.code&&(a=t.domainSpec,i=s.domainSpec,e(a.latestModel.entitySchemas.map(e=>e.shapeSchema),i.latestModel.entitySchemas.map(e=>e.shapeSchema))&&e([...a.latestModel.aliases],[...i.latestModel.aliases])&&e([...a.latestModel.commonTypes],[...i.latestModel.commonTypes])&&e(l(a),l(i))&&e(p(a),p(i)))&&e(t.dataSchemas.publishedData.runtimeSchema,s.dataSchemas.publishedData.runtimeSchema)&&e(t.dataSchemas.sessionData.runtimeSchema,s.dataSchemas.sessionData.runtimeSchema)&&e(t.dataSchemas.frontendData.runtimeSchema,s.dataSchemas.frontendData.runtimeSchema)},S=e=>{let{latestModel:t,resolvedVersions:m,expressions:l}=e.domainSpec,p={};for(let e of t.entitySchemas)p[String(e.entityType)]=new a(String(e.entityType),[e.shapeSchema]);let d={};for(let[e,s]of t.commonTypes){let t=s.runtimeSchema;d[String(e)]=new n(String(e),t)}let S=[...t.aliases],c={},h={};for(let[e,t]of S){let s=t.map(e=>p[String(e)]),a=new i(String(e),s);c[String(e)]=a,h[String(e)]=a.types}let u={};for(let a of t.entityTypes){let t=String(a),i=l.entityExpressions.get(a),n=[];if(i)for(let e of i.shapeGroups){let t=l.expressions.get(e);t&&n.push(...t.keys())}u[t]=new s(t,n,r(l,t,e.code))}let y=S.map(([e])=>String(e)).includes("RootEntity")?"RootEntity":"AnyDomainEntity",g=c[y]?.types??[],f=m.latestVersion,x=e.dataSchemas.publishedData.runtimeSchema,D=e.dataSchemas.sessionData.runtimeSchema,M=e.dataSchemas.frontendData.runtimeSchema,v=o.from(p,h,u,g,f,x,D,M,void 0,!0);return{entities:p,aliasReflections:c,commonTypeReflections:d,aliases:h,$entityReflections:u,rootEntityTypes:g,modelVersion:f,domainBuilder:v}};export const AdminModelRuntime=(e,s,a,i)=>{let n=a.createBuilder("modelRuntime:admin",{build:S,getKey:()=>"singleton",compare:d}).build({domainSpec:e,dataSchemas:s,code:i});return t({...n.output,schemaChanged:n.changed})};