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

package/dist/domain/spec/modules/resolve-expression-modules.d.ts

@@ -0,0 +1,14 @@
+import type { AnonymousExpression } from '../../core/index.js';
+import type { ProjectModule } from './project-modules.js';
+/** The expressions of one validated expression file, keyed by entity type or alias, then by expression name. */
+export interface ExpressionModule {
+    readonly origin: string;
+    readonly expressions: Readonly<Record<string, Readonly<Record<string, AnyAnonymousExpression>>>>;
+}
+type AnyAnonymousExpression = AnonymousExpression<any, any, any, any, any, any, unknown>;
+/**
+ * Validates the `src/expressions/` files with the checks of {@link mergeExpressionModules}, throws
+ * everything they find as one `ImplementationErrors`, and returns each file on its own, unmerged.
+ */
+export declare const resolveExpressionModules: (modules: readonly ProjectModule[], aliasMap: Readonly<Record<string, readonly string[]>>) => readonly ExpressionModule[];
+export {};

package/dist/domain/spec/modules/resolve-expression-modules.js

@@ -0,0 +1 @@
+import{isExpressionExport as e,mergeExpressionModules as o}from"./merge-expression-modules.js";export const resolveExpressionModules=(s,r)=>(o(s,r),s.flatMap(o=>e(o.exports)?[{origin:o.origin,expressions:o.exports}]:[]));

package/dist/domain/spec/modules/resolve-invariant-modules.d.ts

@@ -0,0 +1,6 @@
+import type { Invariant } from '../../core/index.js';
+import { type ProjectModule } from './project-modules.js';
+/** An invariant of any project: a file's default export does not carry the project's entity and data types. */
+export type AnyInvariant = Invariant<any, any, any, any, any, any, string>;
+/** Validates the `src/invariants/` files and concatenates their invariants per entity type or alias. */
+export declare const resolveInvariantModules: (modules: readonly ProjectModule[]) => Readonly<Record<string, readonly AnyInvariant[]>>;

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

@@ -0,0 +1 @@
+export { type Phx, createPhx } from './phx.js';

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

@@ -0,0 +1 @@
+export{createPhx}from"./phx.js";

package/dist/domain/spec/phx/phx-application-types.d.ts

@@ -0,0 +1,25 @@
+import { type EnumLike } from '../../core/index.js';
+import type { RuntimeSpec } from '../runtime-spec/index.js';
+/**
+ * The value of `phx.applicationTypes`: the application's version and published data hash, the JSON
+ * schemas of its data (`undefined` for data the spec leaves out), and its state enums.
+ */
+export interface PhxApplicationTypes {
+    readonly ApplicationVersion: string;
+    readonly PublishedDataHash: string;
+    readonly PublishedData: unknown;
+    readonly SessionData: unknown;
+    readonly FrontendData: unknown;
+    readonly BackendData: unknown;
+    readonly FinalizeData: unknown;
+    readonly PrefetchedFinalizeData: unknown;
+    readonly FinalizeResult: unknown;
+    readonly CallbackData: unknown;
+    readonly NavigationState: EnumLike<string>;
+    readonly ViewState: EnumLike<string>;
+    readonly ToolState: EnumLike<string>;
+    readonly ExportState: EnumLike<string>;
+    readonly AdminNavigationState: EnumLike<string>;
+}
+/** Builds `phx.applicationTypes` from the spec, with the values generated `domain-spec.ts` writes. */
+export declare const createPhxApplicationTypes: (spec: RuntimeSpec) => PhxApplicationTypes;

package/dist/domain/spec/phx/phx-application-types.js

@@ -0,0 +1 @@
+import{EnumReflection as a}from"../../core/index.js";let t=(t,e)=>new a(t,{enum:[...e]});export const createPhxApplicationTypes=a=>{let{dataSchemas:e,states:i}=a.configurator;return{ApplicationVersion:a.appMetadata.applicationVersion,PublishedDataHash:e.publishedDataHash,PublishedData:e.publishedData.runtimeSchema,SessionData:e.sessionData.runtimeSchema,FrontendData:e.frontendData.runtimeSchema,BackendData:e.backendData?.runtimeSchema,FinalizeData:e.finalizeData.runtimeSchema,PrefetchedFinalizeData:e.prefetchedFinalizeData.runtimeSchema,FinalizeResult:e.finalizeResult.runtimeSchema,CallbackData:e.callbackData.runtimeSchema,NavigationState:t("NavigationState",i.navigationStates),ViewState:t("ViewState",i.viewStates),ToolState:t("ToolState",i.toolStates),ExportState:t("ExportState",i.exportStates),AdminNavigationState:t("AdminNavigationState",a.admin.states.navigationStates)}};

package/dist/domain/spec/phx/phx-domain.d.ts

@@ -0,0 +1,36 @@
+import type { FactoryDataRuntime } from '../runtime/index.js';
+import type { PhxModel } from './phx-model.js';
+/**
+ * The value of `phx.domain`: the reflections and the factories project code writes its expressions,
+ * invariants, actions, components and recipes with, and the same for the admin domain under `admin`.
+ * The factories carry only the data the spec gives them (aliases, static violations, defaults); their
+ * types come from the project's `globals.d.ts`, which declares every member.
+ */
+export interface PhxDomain extends PhxModel {
+    readonly implementCustomExpressions: unknown;
+    readonly implementCustomInvariants: unknown;
+    readonly implementActions: unknown;
+    readonly createAssistantSetupHandler: unknown;
+    readonly attachComponent: unknown;
+    readonly createRecipe: unknown;
+    readonly admin: PhxModel & {
+        readonly implementCustomExpressions: unknown;
+        readonly implementCustomInvariants: unknown;
+        readonly attachComponent: unknown;
+        readonly createMapPublishedRevisionDataHandler: unknown;
+        readonly createMapPublishedChunkedDataHandler: unknown;
+        readonly createDataRowValidatorHandler: unknown;
+        readonly createSheetValidatorHandler: unknown;
+        readonly createRecipe: unknown;
+    };
+}
+interface PhxDomainInput {
+    readonly model: PhxModel;
+    readonly factoryData: FactoryDataRuntime;
+}
+/**
+ * Builds `phx.domain` from the reflections and the factory data of both domains, with the same
+ * factories and the same data generated `domain-spec.ts` passes them.
+ */
+export declare const createPhxDomain: (configurator: PhxDomainInput, admin: PhxDomainInput) => PhxDomain;
+export {};

package/dist/domain/spec/phx/phx-domain.js

@@ -0,0 +1 @@
+import{createAssistantSetupHandlerFactory as a,createDataRowValidatorHandler as t,createMapPublishedChunkedDataHandlerFactory as e,createMapPublishedRevisionDataHandlerFactory as i,createSheetValidatorHandler as o}from"../../application/index.js";import{DomainComponentOpticBuilder as s,createActionFactory as n,createCustomExpressionFactory as r,createCustomInvariantFactory as m,createRecipeFactory as c}from"../../core/index.js";let l=a=>c(a.aliases,a.entityReflections,a.defaults);export const createPhxDomain=(c,p)=>({...c.model,implementCustomExpressions:r(),implementCustomInvariants:m()(c.factoryData.staticViolations),implementActions:n(),createAssistantSetupHandler:a(),attachComponent:s.from(c.factoryData.aliases),createRecipe:l(c.factoryData),admin:{...p.model,implementCustomExpressions:r(),implementCustomInvariants:m()(p.factoryData.staticViolations),attachComponent:s.from(p.factoryData.aliases),createMapPublishedRevisionDataHandler:i(),createMapPublishedChunkedDataHandler:e(),createDataRowValidatorHandler:t,createSheetValidatorHandler:o,createRecipe:l(p.factoryData)}});

package/dist/domain/spec/phx/phx-model.d.ts

@@ -0,0 +1,24 @@
+import type { Expressions } from '../expressions/index.js';
+import type { RuntimeLatestModelVersion } from '../runtime-spec/index.js';
+import { type AdminModelRuntime, type ConfiguratorModelRuntime, type SpecCodeMap } from '../runtime/index.js';
+/**
+ * The reflections of one domain that project code reads from `phx.domain` (or `phx.domain.admin`):
+ * `model` holds the entity, alias, common type and shape reflections, `enhancedModel` the enhanced
+ * reflection of every entity and alias, named `$<Name>`.
+ */
+export interface PhxModel {
+    readonly model: Readonly<Record<string, unknown>>;
+    readonly enhancedModel: Readonly<Record<string, unknown>>;
+}
+interface PhxModelSpec {
+    readonly latestModel: RuntimeLatestModelVersion;
+    readonly expressions: Expressions;
+}
+/**
+ * Builds the reflections of one domain from its runtime spec and its model runtime. The entity and
+ * alias reflections and the enhanced entity reflections are the model runtime's own, so the domain
+ * built from the same model runtime validates with the same objects; common types, shapes and
+ * enhanced aliases are built here, in the order generated code lists them.
+ */
+export declare const createPhxModel: (domainSpec: PhxModelSpec, modelRuntime: ConfiguratorModelRuntime | AdminModelRuntime, code: SpecCodeMap | undefined) => PhxModel;
+export {};

package/dist/domain/spec/phx/phx-model.js

@@ -0,0 +1 @@
+import{EnhancedAliasReflection as e,EnumReflection as t,SchemaReflection as n}from"../../core/index.js";import{evaluateReflectionConstants as r}from"../runtime/index.js";let o=e=>e,i=(e,r,i)=>{let l,s=o(i);return void 0!==(l=r.enum)&&l.length>0&&l.every(e=>"string"==typeof e)?new t(e,{...s,enum:[...r.enum]}):new n(e,s)};export const createPhxModel=(t,l,s)=>{let m={...l.entities,...l.aliasReflections};for(let[e,n]of t.latestModel.commonTypes)m[String(e)]=i(String(e),n.schema,n.runtimeSchema);for(let e of t.latestModel.shapes.values()){let t=`${String(e.name)}Shape`;m[t]=new n(t,o(e.runtimeSchema))}let a={};for(let[e,t]of Object.entries(l.$entityReflections))a[`$${e}`]=t;for(let[n,o]of t.latestModel.aliases){let i=String(n);a[`$${i}`]=new e(`$${i}`,o.map(String),r(t.expressions,i,s))}return{model:m,enhancedModel:a}};

package/dist/domain/spec/phx/phx.d.ts

@@ -0,0 +1,21 @@
+import type { RuntimeSpec } from '../runtime-spec/index.js';
+import { type RuntimeReferenceStore, type SpecCodeModule } from '../runtime/index.js';
+import { type PhxApplicationTypes } from './phx-application-types.js';
+import { type PhxDomain } from './phx-domain.js';
+/** The `phx` values an application's project modules read while they load. */
+export interface Phx {
+    readonly domain: PhxDomain;
+    readonly applicationTypes: PhxApplicationTypes;
+}
+/**
+ * Builds the values of `phx.domain` and `phx.applicationTypes` from an application's runtime spec
+ * (`.phoenix/application-spec.json`, decoded with `decodeRuntimeSpec`) and its generated code module
+ * (`.phoenix/spec-code.ts`): the model reflections of both domains, and the factories with the
+ * static violations, aliases and defaults of the spec.
+ *
+ * It builds the spec's sections in `referenceStore`. The application's `ApplicationRuntime` is
+ * built later in the same store, so `phx.domain.model` holds the reflections the application's
+ * domain validates with. It assigns nothing: the generated entry assigns `phx` before it imports
+ * the project's modules, because a development server renames the global in project files only.
+ */
+export declare const createPhx: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, specCode?: SpecCodeModule) => Phx;

package/dist/domain/spec/phx/phx.js

@@ -0,0 +1 @@
+import{SpecRuntime as o}from"../runtime/index.js";import{createPhxApplicationTypes as t}from"./phx-application-types.js";import{createPhxDomain as a}from"./phx-domain.js";import{createPhxModel as m}from"./phx-model.js";export const createPhx=(r,i,e)=>{let{configurator:n,admin:p}=o(r,i,e);return{domain:a({model:m(r.configurator,n.modelRuntime,e?.configurator),factoryData:n.factoryDataRuntime},{model:m(r.admin,p.modelRuntime,e?.admin),factoryData:p.factoryDataRuntime}),applicationTypes:t(r)}};

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

@@ -0,0 +1,32 @@
+import { Branded } from '@salsita-ai/common/utils';
+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 { AdminModelRuntime } from '../model/index.js';
+import { ComponentOptics } from '../optics/index.js';
+import type { RuntimeReferenceStore } from '../runtime-reference-store.js';
+import { PresetRuntime } from '../sections/index.js';
+import type { SpecCodeMap } from '../spec-code/index.js';
+import { AdminStatesRuntime } from './states-runtime.js';
+export type AdminRuntime = Branded<'AdminRuntime', {
+    readonly modelRuntime: AdminModelRuntime;
+    readonly componentOptics: ComponentOptics;
+    readonly expressionRuntime: ExpressionRuntime;
+    readonly presetRuntime: PresetRuntime;
+    readonly statesRuntime: AdminStatesRuntime;
+    readonly migrationRuntime: MigrationRuntime;
+    readonly factoryDataRuntime: FactoryDataRuntime;
+}>;
+export type AdminRuntimeResult = {
+    readonly ok: true;
+    readonly runtime: AdminRuntime;
+} | {
+    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 AdminRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, expressionModules: readonly ProjectModule[], invariantImplementations: InvariantImplementations, migrationModules: MigrationModules, code: SpecCodeMap | undefined, errors: ImplementationErrorCollector) => AdminRuntimeResult;

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

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{Preset as t,PresetCategory as i,commonAdminCustomExpressions as s,commonAdminViolationExpressions as n}from"../../../admin-domain/index.js";import{ExpressionRuntime as r}from"../expressions/index.js";import{MigrationRuntime as o}from"../migrations/index.js";import{ComponentOptics as m}from"../optics/index.js";import{PresetRuntime as a}from"../sections/index.js";import{AdminSpecRuntime as p}from"./admin-spec-runtime.js";import{AdminStatesRuntime as u}from"./states-runtime.js";let f={Preset:[{evaluate:(e,i,s)=>{let r=s.domain.get$Entity(e,i);return t.assert(r),n.Preset.nameNotEmpty(r)}}]},d={PresetCategory:{$isDraft:{origin:{name:"$isDraft",typeOrAlias:"PresetCategory"},evaluate:(e,t,n)=>{let r=n.domain.get$Entity(e,t);return i.assert(r),s.PresetCategory.$isDraft(r)},meta:{}}}},l=new WeakMap;export const AdminRuntime=(t,i,s,n,c,g,x)=>{let{modelRuntime:R,factoryDataRuntime:j}=p(t,i,g),y=r(t.admin,i,s,"adminExpressionRuntime",((e,t)=>{if(0===Object.keys(e).length)return f;let i=l.get(t)??new WeakMap;l.set(t,i);let s=i.get(e);if(s)return s;let n={};for(let i of[f,e])for(let[e,s]of Object.entries(i))for(let i of t[e]??[e])n[i]=[...n[i]??[],...s];return i.set(e,n),n})(n,R.aliases),g,x,d),k=o(i,{referenceScope:"adminRuntime/migrationRuntime",resolvedVersions:t.admin.resolvedVersions,latestEntities:R.entities,migrationModules:c});return y.ok?{ok:!0,runtime:e({modelRuntime:R,componentOptics:m(i,{components:t.admin.components,referenceScope:"adminRuntime/componentOptics",modelRuntime:R,code:g}),expressionRuntime:y.runtime,presetRuntime:a(i,{referenceScope:"adminRuntime/presetRuntime",presets:t.admin.presets.presets}),statesRuntime:u(t,i),migrationRuntime:k,factoryDataRuntime:j})}:{ok:!1,missingExpressions:y.missing,missingMigrations:k.missingMigrations}};

package/dist/domain/spec/runtime/admin-runtime/admin-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 { AdminModelRuntime } from '../model/index.js';
+import type { RuntimeReferenceStore } from '../runtime-reference-store.js';
+import type { SpecCodeMap } from '../spec-code/index.js';
+/**
+ * The sections of the admin domain that the spec alone determines: its model and the data of its
+ * `phx.domain.admin` factories. `AdminRuntime` builds its own from this function, so a build of
+ * either in the same reference store returns the same objects.
+ */
+export type AdminSpecRuntime = Branded<'AdminSpecRuntime', {
+    readonly modelRuntime: AdminModelRuntime;
+    readonly factoryDataRuntime: FactoryDataRuntime;
+}>;
+export declare const AdminSpecRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, code: SpecCodeMap | undefined) => AdminSpecRuntime;

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

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

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

@@ -0,0 +1,2 @@
+export { AdminRuntime } from './admin-runtime.js';
+export { AdminSpecRuntime } from './admin-spec-runtime.js';

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

@@ -0,0 +1 @@
+export{AdminRuntime}from"./admin-runtime.js";export{AdminSpecRuntime}from"./admin-spec-runtime.js";

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

@@ -0,0 +1,8 @@
+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 AdminStatesRuntime = Branded<'AdminStatesRuntime', {
+    readonly navigationStates: readonly string[];
+    readonly changed: boolean;
+}>;
+export declare const AdminStatesRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore) => AdminStatesRuntime;

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

@@ -0,0 +1,62 @@
+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 { AdminRuntime } from './admin-runtime/index.js';
+import { ConfiguratorRuntime } from './configurator-runtime/index.js';
+import type { InvariantImplementations, MissingExpression } from './expressions/index.js';
+import type { MigrationModules } from './migrations/index.js';
+import type { RuntimeReferenceStore } from './runtime-reference-store.js';
+import { DataRuntime } from './sections/index.js';
+import type { SpecCodeModule } from './spec-code/index.js';
+/**
+ * Runtime objects built from a RuntimeSpec.
+ * Domain-specific fields mirror the spec's configurator/admin nesting.
+ */
+export type ApplicationRuntime = Branded<'ApplicationRuntime', {
+    readonly configurator: ConfiguratorRuntime;
+    readonly admin: AdminRuntime;
+    readonly data: DataRuntime;
+}>;
+export type ApplicationRuntimeResult = {
+    readonly ok: true;
+    readonly runtime: ApplicationRuntime;
+} | {
+    readonly ok: false;
+    readonly missingExpressions: readonly MissingExpression[];
+    /**
+     * The migrations of both domains the migration modules do not export, which a built
+     * runtime lists in `migrationRuntime.missingMigrations` of each domain.
+     */
+    readonly missingMigrations: readonly string[];
+};
+/**
+ * Builds an ApplicationRuntime from a RuntimeSpec: the part of the parsed spec the runtime reads, which a
+ * parsed ApplicationSpec also is.
+ * A persistent RuntimeReferenceStore preserves per-item references and reports
+ * section-level changes across rebuilds.
+ * Each field on the result carries its own `changed` flag.
+ *
+ * `adminInvariantImplementations` are the project's admin invariants (`src/admin/invariants/`); the
+ * admin domain checks them after the invariants every admin domain has. `migrationModules` are the
+ * project's migration modules of both domains (`src/migrations/`, `src/admin/migrations/`), keyed by
+ * project path; a migration they do not provide is listed in `missingMigrations` of the domain's
+ * `migrationRuntime`. `specCode` is the generated `.phoenix/spec-code.ts` module: the runtime takes
+ * each piece of YAML code (`$eval` in expressions, component props and filters) from it by spec code
+ * id, and compiles the text with `new Function` only for an id it does not hold, or without it (the
+ * editor, which rebuilds from YAML it has no generated module for). The module must come from the
+ * same generation as `spec`; an id carries a hash of its code, so a module from another generation
+ * misses the ids of changed code instead of running an old closure.
+ *
+ * `expressionModules` and `adminExpressionModules` are the project's expression files
+ * (`src/expressions/`, `src/admin/expressions/`), as the generated barrels or the editor's reload
+ * hand them over; each domain merges them with the aliases of its spec (`mergeExpressionModules`).
+ *
+ * The mistakes of the project files are recorded in `errors` as `ImplementationError`s: a file with
+ * the wrong export, an expression two files define, or that a file defines although the spec or the
+ * SDK gives it a value (`DUPLICATE_DEFINITION`), and a declared expression no file implements
+ * (`MISSING_IMPLEMENTATION`), which also makes the result an error. Without `errors`, everything
+ * recorded is thrown together as one `ImplementationErrors` before the result is returned.
+ */
+export declare const ApplicationRuntime: (spec: RuntimeSpec, referenceStore: RuntimeReferenceStore, expressionModules: readonly ProjectModule[], importedTransformers: readonly ImportedTransformer[], invariantImplementations?: InvariantImplementations, adminExpressionModules?: readonly ProjectModule[], adminInvariantImplementations?: InvariantImplementations, migrationModules?: MigrationModules, specCode?: SpecCodeModule, errors?: ImplementationErrorCollector) => ApplicationRuntimeResult;

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

@@ -0,0 +1 @@
+import{Branded as i}from"@salsita-ai/common/utils";import{createImplementationErrorCollector as n}from"../errors/index.js";import{AdminRuntime as o}from"./admin-runtime/index.js";import{ConfiguratorRuntime as s}from"./configurator-runtime/index.js";import{DataRuntime as r}from"./sections/index.js";export const ApplicationRuntime=(m,t,e,a,g,u=[],p={},d={},f,k)=>{let x=k??n(),c=s(m,t,e,a,g,d,f?.configurator,x),M=o(m,t,u,p,d,f?.admin,x);return(void 0===k&&x.throwIfAny(),c.ok&&M.ok)?{ok:!0,runtime:i({configurator:c.runtime,admin:M.runtime,data:r(m,t)})}:{ok:!1,missingExpressions:[...c.ok?[]:c.missingExpressions,...M.ok?[]:M.missingExpressions],missingMigrations:[...c.ok?c.runtime.migrationRuntime.missingMigrations:c.missingMigrations,...M.ok?M.runtime.migrationRuntime.missingMigrations:M.missingMigrations]}};

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 t}from"@salsita-ai/common/utils";import{defaultI18n as i,mergeCatalogs as n,sdkCatalog as o}from"#package/i18n";import{checkSingleInstanceHandlers as r,createInitialPublishedData as s}from"../../application/index.js";import{NoopAnalyticsSystem as a}from"../../domain-context/index.js";import{createDomainRuntime as m,resolveTransformerModule as p}from"../../domain-runtime/index.js";import{ImplementationError as c,createImplementationErrorCollector as l}from"../errors/index.js";import{resolveActionModules as d,resolveComponentOpticModules as u,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,t,i)=>e.filter(e=>i.attempt(()=>(t(e),!0),!1)),M=(e,t,i)=>e.flatMap(e=>i.attempt(()=>t(e),[]));export const createApplication=j=>{let{spec:w,referenceStore:I,specCode:T,modules:b,environment:k={}}=j,A=l(),C=M(b.handlers,g,A),R=M(b.elements,f,A),y=M(b.transformers,e=>[p(e)],A),N=M(b.components,e=>u([e]),A),P=M(b.adminComponents,e=>u([e]),A),S=E(b.invariants,e=>h([e]),A),O=E(b.adminInvariants,e=>h([e]),A),L=E(b.actions,e=>d([e]),A),U=v(w,I,b.expressions,y,h(S),b.adminExpressions,h(O),b.migrations,T,A);if((U.ok?[...U.runtime.configurator.migrationRuntime.missingMigrations,...U.runtime.admin.migrationRuntime.missingMigrations]:U.missingMigrations).forEach(e=>A.add((e=>{let[t=e,i="migrateToVN"]=e.split("#");return new c({code:"MISSING_IMPLEMENTATION",origin:t,problem:`The migration ${i} is missing`,fix:`The spec declares the model version this file migrates to, so the file must export ${i}, 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:w,modules:{handlers:{handlers:C},elements:{elements:R},customComponentOptics:N,actionImplementations:d(L)},customAdminComponentOptics:P,defaultElements:j.defaultElements,themePresets:j.themePresets,environmentResourcesUrl:k.defaultEnvs?.resourcesUrl}),D=t(),F=s({adminDomainFactory:$.admin.factory,domainRuntime:m({application:{spec:$,environment:k},services:{analyticsService:new a,i18n:i,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:{...j.services,i18n:e({messages:n([o,b.catalogs]),locale:w.configurator.ui.availableLocales[0]})},tag:j.tag??w.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 {};