@salsita-ai/sdk 0.50.0-develop.d81d7591c5 → 0.50.0-develop.d87b28256e

package/dist/domain/domain-runtime/errors/index.js

@@ -0,0 +1 @@
+export{ImplementationError,isImplementationError}from"./implementation-error.js";export{createImplementationErrorCollector}from"./implementation-error-collector.js";export{ImplementationErrors,isImplementationErrors}from"./implementation-errors.js";export{toImplementationErrors}from"./to-implementation-errors.js";

package/dist/domain/domain-runtime/errors/to-implementation-errors.d.ts

@@ -0,0 +1,10 @@
+import { ImplementationErrors } from './implementation-errors.js';
+/** The step of an application start during which a failure that the SDK did not raise itself was caught. */
+export type StartupStage = 'import' | 'initialize' | 'render';
+/**
+ * Turns whatever stopped an application from starting into a list of implementation errors, so that
+ * a host handles one shape. A list is passed through and a single implementation error becomes a
+ * list of one. Anything else, such as a project file that throws while it loads, becomes one
+ * `STARTUP_FAILED` error that names the stage and keeps what was thrown as its `cause`.
+ */
+export declare const toImplementationErrors: (error: unknown, stage: StartupStage) => ImplementationErrors;

package/dist/domain/domain-runtime/errors/to-implementation-errors.js

@@ -0,0 +1 @@
+import{ImplementationError as e,isImplementationError as i}from"./implementation-error.js";import{ImplementationErrors as t,isImplementationErrors as r}from"./implementation-errors.js";let n={import:"while its code was loading",initialize:"while its runtime was initializing",render:"while it was rendering"};export const toImplementationErrors=(o,a)=>r(o)?o:i(o)?new t([o]):new t([new e({code:"STARTUP_FAILED",origin:null,problem:`The application failed ${n[a]}: ${o instanceof Error?o.message:String(o)}`,fix:"Read the stack trace of the cause to find the file that threw, and fix the code it points to.",cause:o})]);

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

@@ -1,6 +1,7 @@
 export * from './domain-runtime.js';
 export * from './domain-context/index.js';
 export * from './domain-services/index.js';
+export { type ImplementationErrorCode, type ImplementationErrorProps, type StartupStage, ImplementationError, ImplementationErrors, isImplementationError, isImplementationErrors, toImplementationErrors, } from './errors/index.js';
 export * from './spec/index.js';
 export * from './environment/index.js';
 export * from './access/index.js';

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

@@ -1 +1 @@
-export*from"./domain-runtime.js";export*from"./domain-context/index.js";export*from"./domain-services/index.js";export*from"./spec/index.js";export*from"./environment/index.js";export*from"./access/index.js";export*from"./overrides/index.js";export*from"./loaded-data/index.js";export*from"./domain-data/index.js";export*from"./session-context/index.js";export*from"./web-component/index.js";
+export*from"./domain-runtime.js";export*from"./domain-context/index.js";export*from"./domain-services/index.js";export{ImplementationError,ImplementationErrors,isImplementationError,isImplementationErrors,toImplementationErrors}from"./errors/index.js";export*from"./spec/index.js";export*from"./environment/index.js";export*from"./access/index.js";export*from"./overrides/index.js";export*from"./loaded-data/index.js";export*from"./domain-data/index.js";export*from"./session-context/index.js";export*from"./web-component/index.js";

package/dist/domain/domain-runtime/spec/create-violation-expressions.d.ts

@@ -0,0 +1,24 @@
+import { type AnonymousExpression, type AnyAliasMap, type Violation } from '../../core/index.js';
+import { type AnyInvariant, type ProjectModule } from './module-checks/index.js';
+/**
+ * The `$violations` expression of every entity type that has invariants, keyed by entity type.
+ *
+ * The entity and data types are erased: the expression only passes its arguments on to the invariants,
+ * and `DomainBuilder.withExpressions` accepts it for any project.
+ */
+type ViolationExpressions = Readonly<Record<string, {
+    readonly $violations: AnonymousExpression<any, any, any, any, any, any, ReadonlyArray<Violation<string>>>;
+}>>;
+/**
+ * Creates the `$violations` expressions of a domain from its invariants.
+ *
+ * Takes the invariants of the `src/invariants/` files, as the generated barrel lists them, after
+ * checking each file against the folder's contract. An invariant declared for an alias applies to
+ * every entity type of the alias. The `$violations` expression of an entity type returns the
+ * violations of all its invariants: those of `commonInvariants` first, then those of the files in
+ * the order of the barrel.
+ *
+ * @param commonInvariants Invariants the SDK adds to the domain, such as the ones every admin domain has.
+ */
+export declare const createViolationExpressions: (aliasMap: AnyAliasMap, modules: readonly ProjectModule[], commonInvariants?: Readonly<Record<string, readonly AnyInvariant[]>>) => ViolationExpressions;
+export {};

package/dist/domain/domain-runtime/spec/create-violation-expressions.js

@@ -0,0 +1 @@
+import{expandAlias as e}from"../../core/index.js";import{resolveInvariantModules as t}from"./module-checks/index.js";export const createViolationExpressions=(o,r,l={})=>{let f={};for(let i of[l,t(r)])for(let[t,r]of Object.entries(i))for(let l of e(o,t))f[l]=[...f[l]??[],...r];let i={};for(let[e,t]of Object.entries(f))i[e]={$violations:{evaluate:(e,o,r)=>t.flatMap(t=>t.evaluate(e,o,r)),meta:{}}};return i};

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

@@ -1,4 +1,9 @@
 export * from './selectors.js';
 export type * from './types.js';
 export * from './actions.js';
+export * from './create-violation-expressions.js';
 export * from './initialize.js';
+export * from './memoize-expression.js';
+export { type PhoenixEntityElementProps, type PhoenixEntityElementRegistration, type PhoenixLayoutElementRegistration, type PhoenixIconRegistration, type ElementRegistration, type CustomPhoenixEntityElementProps, type PhoenixLayoutElementDefinition, type PhoenixEntityElementDefinition, type CreateCustomPhoenixLayoutElement, type CreateCustomPhoenixEntityElement, createPhoenixLayoutElement, createPhoenixEntityElement, createCustomPhoenixLayoutElement, createCustomPhoenixEntityElement, resolveElementModule, resolveElementModules, type PhoenixHandlerDefinition, type SystemPhoenixHandlerDefinition, type PhoenixHandlerRegistration, type SystemPhoenixHandlerRegistration, type SystemPhoenixAsyncHandlerDefinition, type SystemPhoenixAsyncHandlerRegistration, type HandlerRegistration, type CreatePhoenixHandler, createPhoenixHandler, createSystemPhoenixHandler, createSystemPhoenixAsyncHandler, resolveHandlerModule, resolveHandlerModules, type ProjectModule, resolveActionModules, resolveComponentOpticModules, type ExpressionModule, resolveExpressionModules, resolveImportedTransformers, resolveTransformerModule, resolveTransformerModules, resolveInvariantModules, } from './module-checks/index.js';
+export * from './prepare-action-implementations.js';
+export * from './prepare-domain-expressions.js';

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

@@ -1 +1 @@
-export*from"./selectors.js";export*from"./actions.js";export*from"./initialize.js";
+export*from"./selectors.js";export*from"./actions.js";export*from"./create-violation-expressions.js";export*from"./initialize.js";export*from"./memoize-expression.js";export{createPhoenixLayoutElement,createPhoenixEntityElement,createCustomPhoenixLayoutElement,createCustomPhoenixEntityElement,resolveElementModule,resolveElementModules,createPhoenixHandler,createSystemPhoenixHandler,createSystemPhoenixAsyncHandler,resolveHandlerModule,resolveHandlerModules,resolveActionModules,resolveComponentOpticModules,resolveExpressionModules,resolveImportedTransformers,resolveTransformerModule,resolveTransformerModules,resolveInvariantModules}from"./module-checks/index.js";export*from"./prepare-action-implementations.js";export*from"./prepare-domain-expressions.js";

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

@@ -1,3 +1,14 @@
 import type { AnyApplicationConfig } from '../../application/index.js';
 import type { ApplicationSpec } from './types.js';
+/**
+ * Builds the runtime spec of an application from its config.
+ *
+ * Project files reach the config unchecked; this is where each one is held to its folder's
+ * contract. Every file is checked on its own, and all the files that break their contract are
+ * thrown together as one `ImplementationErrors`. Its errors are ordered by folder (handlers,
+ * elements, transformers, configurator components, admin components) and inside a folder by the
+ * order of the config's list. No spec is returned when a file is wrong, so nothing that reads the
+ * spec, such as the transformer selection, runs on a list with a file missing and reports the
+ * mistake a second time.
+ */
 export declare const initializeSpec: (config: AnyApplicationConfig) => ApplicationSpec;

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

@@ -1 +1 @@
-import{SessionRole as t}from"@salsita-ai/contracts/api";import{resolveElementModules as e}from"../../application/element-registration.js";import{resolveHandlerModules as a}from"../../application/handler-registration.js";import{resolveImportedTransformers as n,resolveTransformerModules as o}from"../../application/resolve-imported-transformers.js";import{resolveComponentOpticModules as i}from"../../components/domain-component-optic.js";export const initializeSpec=s=>{let r=s.adminDomain.presets[0];if(!r)throw Error("Cannot register application spec because admin preset is required.");let m=a(s.handlers),c=e(s.elements),d=(t=>{let e={};for(let a of t)e[a.name]=(void 0)??a.name;return e})(m),l=(t=>{let e={},a=0;for(let n of t)if("entity"===n.type||"layout"===n.type)e[n.name]=(void 0)??n.name;else{let t=`icon:${a}`;e[t]=(void 0)??`${t}:${n.elements.length}`,a+=1}return e})(c),p=o(s.transformers?.importedTransformers??[]),y=s.transformers?.specTransformers??[];return{version:s.version,dataConfig:s.dataSpec??null,chunks:s.chunks,publishedDataHash:s.publishedDataHash,initialPublishedData:s.initialPublishedData,canCreate:s.features?.acl?.canCreate??Object.values(t),enableAdminRelease:s.features?.enableAdminRelease??!1,textLanguages:s.domain.textLanguages??s.adminDomain.textLanguages??["en"],baseResourcesUrl:s.resources?.baseResourcesUrl??s.defaultEnvs?.resourcesUrl??"",configurator:{factory:s.domain.domainFactory,presets:s.domain.presets,aliasMap:s.domain.domainFactory.context.aliasMap,entityReflections:s.domain.domainFactory.context.entityReflections,$entityReflections:s.domain.domainFactory.context.$entityReflections,expressions:s.domain.domainFactory.context.expressions,actions:s.domain.domainFactory.context.actions,actionImplementations:s.domain.domainFactory.context.actionImplementations,allowedRootEntityTypes:s.domain.domainFactory.context.allowedRootEntityTypes,migrate:s.domain.domainFactory.context.migrate,componentOptics:i(s.domain.componentOptics),createTransformers:t=>n(p,y,t),navigationStates:s.navigation?.navigationStates??[],viewStates:s.navigation?.viewStates??[],toolStates:s.navigation?.toolStates??[],exportStates:s.navigation?.exportStates??[],handlers:m,handlerHashes:d,elements:c,elementHashes:l,appLoader:s.ui?.appLoader??"universal",preview:s.ui?.preview??"auto",alwaysExpand:s.ui?.alwaysExpand??!1,theme:s.ui?.theme??{},assistant:s.assistant??null,deploymentQueryDisabled:s.resources?.deploymentQueryDisabled??!1,prefetchTextureUrls:s.resources?.prefetchTextureUrls??[],modelVersion:s.domain.domainFactory.modelVersion},admin:{factory:s.adminDomain.domainFactory,modelVersion:s.adminDomain.domainFactory.modelVersion,aliasMap:s.adminDomain.domainFactory.context.aliasMap,entityReflections:s.adminDomain.domainFactory.context.entityReflections,$entityReflections:s.adminDomain.domainFactory.context.$entityReflections,expressions:s.adminDomain.domainFactory.context.expressions,actions:s.adminDomain.domainFactory.context.actions,actionImplementations:s.adminDomain.domainFactory.context.actionImplementations,allowedRootEntityTypes:s.adminDomain.domainFactory.context.allowedRootEntityTypes,migrate:s.adminDomain.domainFactory.context.migrate,preset:r,componentOptics:i(s.adminDomain.componentOptics),navigationStates:s.adminNavigation?.navigationStates??[],viewStates:s.adminNavigation?.viewStates??[],handlers:m,handlerHashes:d,elements:c,elementHashes:l}}};
+import{SessionRole as e}from"@salsita-ai/contracts/api";import{createImplementationErrorCollector as t}from"../errors/index.js";import{resolveComponentOpticModules as a,resolveElementModule as n,resolveHandlerModule as o,resolveImportedTransformers as i,resolveTransformerModule as s}from"./module-checks/index.js";let r=(e,t,a)=>e.flatMap(e=>a.attempt(()=>t(e),[]));export const initializeSpec=m=>{let c=m.adminDomain.presets[0];if(!c)throw Error("Cannot register application spec because admin preset is required.");let d=t(),l=r(m.handlers,o,d),p=r(m.elements,n,d),y=r(m.transformers?.importedTransformers??[],e=>[s(e)],d),u=r(m.domain.componentOptics,e=>a([e]),d),f=r(m.adminDomain.componentOptics,e=>a([e]),d);d.throwIfAny();let x=(e=>{let t={};for(let a of e)t[a.name]=(void 0)??a.name;return t})(l),g=(e=>{let t={},a=0;for(let n of e)if("entity"===n.type||"layout"===n.type)t[n.name]=(void 0)??n.name;else{let e=`icon:${a}`;t[e]=(void 0)??`${e}:${n.elements.length}`,a+=1}return t})(p),v=m.transformers?.specTransformers??[];return{version:m.version,dataConfig:m.dataSpec??null,chunks:m.chunks,publishedDataHash:m.publishedDataHash,initialPublishedData:m.initialPublishedData,canCreate:m.features?.acl?.canCreate??Object.values(e),enableAdminRelease:m.features?.enableAdminRelease??!1,textLanguages:m.domain.textLanguages??m.adminDomain.textLanguages??["en"],baseResourcesUrl:m.resources?.baseResourcesUrl??m.defaultEnvs?.resourcesUrl??"",configurator:{factory:m.domain.domainFactory,presets:m.domain.presets,aliasMap:m.domain.domainFactory.context.aliasMap,entityReflections:m.domain.domainFactory.context.entityReflections,$entityReflections:m.domain.domainFactory.context.$entityReflections,expressions:m.domain.domainFactory.context.expressions,actions:m.domain.domainFactory.context.actions,actionImplementations:m.domain.domainFactory.context.actionImplementations,allowedRootEntityTypes:m.domain.domainFactory.context.allowedRootEntityTypes,migrate:m.domain.domainFactory.context.migrate,componentOptics:u,createTransformers:e=>i(y,v,e),navigationStates:m.navigation?.navigationStates??[],viewStates:m.navigation?.viewStates??[],toolStates:m.navigation?.toolStates??[],exportStates:m.navigation?.exportStates??[],handlers:l,handlerHashes:x,elements:p,defaultElements:m.defaultElements??[],elementHashes:g,appLoader:m.ui?.appLoader??"universal",preview:m.ui?.preview??"auto",alwaysExpand:m.ui?.alwaysExpand??!1,theme:m.ui?.theme??{},assistant:m.assistant??null,deploymentQueryDisabled:m.resources?.deploymentQueryDisabled??!1,prefetchTextureUrls:m.resources?.prefetchTextureUrls??[],modelVersion:m.domain.domainFactory.modelVersion},admin:{factory:m.adminDomain.domainFactory,modelVersion:m.adminDomain.domainFactory.modelVersion,aliasMap:m.adminDomain.domainFactory.context.aliasMap,entityReflections:m.adminDomain.domainFactory.context.entityReflections,$entityReflections:m.adminDomain.domainFactory.context.$entityReflections,expressions:m.adminDomain.domainFactory.context.expressions,actions:m.adminDomain.domainFactory.context.actions,actionImplementations:m.adminDomain.domainFactory.context.actionImplementations,allowedRootEntityTypes:m.adminDomain.domainFactory.context.allowedRootEntityTypes,migrate:m.adminDomain.domainFactory.context.migrate,preset:c,componentOptics:f,navigationStates:m.adminNavigation?.navigationStates??[],viewStates:m.adminNavigation?.viewStates??[],handlers:l,handlerHashes:x,elements:p,elementHashes:g}}};

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

@@ -0,0 +1,16 @@
+import type { DomainEntity, DomainEntityId, Expression, ExpressionOrigin } from '../../core/index.js';
+export interface ExpressionTrace {
+    origin: ExpressionOrigin;
+    entityId: DomainEntityId<string>;
+}
+export declare const traceToString: (trace: ExpressionTrace) => string;
+export declare class ExpressionEvaluationError extends Error {
+    readonly _tag = "expression-evaluation-error";
+    constructor(trace: ExpressionTrace, error: any);
+}
+export declare class CircularDependencyError extends Error {
+    readonly _tag = "circular-dependency-error";
+    readonly path: ExpressionTrace[];
+    constructor(trace: ExpressionTrace, cause?: CircularDependencyError);
+}
+export declare const memoizeExpression: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends ENTITIES, T>(expression: Expression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T>) => Expression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T>;

package/dist/domain/domain-runtime/spec/module-checks/element-registration.d.ts

@@ -0,0 +1,111 @@
+import type { SvgIconProps } from '@mui/material';
+import type { PropsWithChildren, ReactNode } from 'react';
+import type { ExtendedJsonSchema } from '@salsita-ai/common/utils';
+import type { DomainEntityId } from '../../../core/index.js';
+import { type ProjectModule } from './project-modules.js';
+export interface PhoenixEntityElementProps {
+    entityId: DomainEntityId<string>;
+    children?: ReactNode;
+}
+export type PhoenixEntityElementRegistration = {
+    type: 'entity';
+    name: string;
+    element: (props: PhoenixEntityElementProps) => JSX.Element;
+};
+export type PhoenixLayoutElementRegistration = {
+    type: 'layout';
+    name: string;
+    element: (props: PropsWithChildren) => JSX.Element;
+};
+export type PhoenixIconRegistration = {
+    type: 'icon';
+    elements: ReadonlyArray<(props: SvgIconProps) => JSX.Element>;
+};
+export type ElementRegistration = PhoenixEntityElementRegistration | PhoenixLayoutElementRegistration | PhoenixIconRegistration;
+export interface CustomPhoenixEntityElementProps {
+    entityId: DomainEntityId<string>;
+    children?: ReactNode;
+}
+type SchemaOfPhoenixLayoutElement<SCHEMA extends {
+    kind: string;
+    props?: Record<string, unknown>;
+}> = {
+    type: 'object';
+    properties: {
+        kind: {
+            type: 'string';
+            enum: [SCHEMA['kind']];
+        };
+        props?: {
+            type: 'object';
+            properties: Record<keyof SCHEMA['props'], any>;
+        };
+    };
+} & ExtendedJsonSchema;
+export interface PhoenixLayoutElementDefinition<SCHEMA extends {
+    kind: string;
+    props?: Record<string, unknown>;
+}> {
+    schema: SchemaOfPhoenixLayoutElement<SCHEMA>;
+    component: React.FunctionComponent<SCHEMA['props'] & {
+        children?: ReactNode;
+    }>;
+}
+/**
+ * Returns the component of a built-in layout element definition; it registers nothing. A layout
+ * element reaches the runtime only through a registration in `elements` or `defaultElements`.
+ *
+ * @deprecated Register a layout element with `createCustomPhoenixLayoutElement(name, component)`;
+ * the built-in ones are in `defaultConfiguratorElements` and `defaultAdminElements`. This API will
+ * be removed in a future version.
+ */
+export declare const createPhoenixLayoutElement: <SCHEMA extends {
+    kind: string;
+    props?: Record<string, unknown>;
+} = never>(element: PhoenixLayoutElementDefinition<SCHEMA>) => import("react").FunctionComponent<SCHEMA["props"] & {
+    children?: ReactNode;
+}>;
+export declare const createCustomPhoenixLayoutElement: (name: string, element: (props: PropsWithChildren) => JSX.Element) => PhoenixLayoutElementRegistration;
+export type CreateCustomPhoenixLayoutElement = (name: string, element: (props: PropsWithChildren) => JSX.Element) => PhoenixLayoutElementRegistration;
+type SchemaOfPhoenixElement<SCHEMA extends {
+    kind: string;
+    props?: Record<string, unknown>;
+}> = {
+    type: 'object';
+    properties: {
+        kind: {
+            type: 'string';
+            enum: [SCHEMA['kind']];
+        };
+        props?: {
+            type: 'object';
+            properties: Record<keyof SCHEMA['props'], any>;
+        };
+    };
+} & ExtendedJsonSchema;
+export interface PhoenixEntityElementDefinition<SCHEMA extends {
+    kind: string;
+    props?: Record<string, unknown>;
+}> {
+    schema: SchemaOfPhoenixElement<SCHEMA>;
+    component: React.FunctionComponent<SCHEMA['props'] & CustomPhoenixEntityElementProps>;
+}
+/**
+ * Returns the component of a built-in entity element definition; it registers nothing. An entity
+ * element reaches the runtime only through a registration in `elements` or `defaultElements`.
+ *
+ * @deprecated Register an entity element with `createCustomPhoenixEntityElement(name, component)`;
+ * the built-in ones are in `defaultConfiguratorElements` and `defaultAdminElements`. This API will
+ * be removed in a future version.
+ */
+export declare const createPhoenixEntityElement: <SCHEMA extends {
+    kind: string;
+    props?: Record<string, unknown>;
+} = never>(element: PhoenixEntityElementDefinition<SCHEMA>) => import("react").FunctionComponent<SCHEMA["props"] & CustomPhoenixEntityElementProps>;
+export declare const createCustomPhoenixEntityElement: (name: string, element: (props: CustomPhoenixEntityElementProps) => JSX.Element) => PhoenixEntityElementRegistration;
+export type CreateCustomPhoenixEntityElement = (name: string, element: (props: CustomPhoenixEntityElementProps) => JSX.Element) => PhoenixEntityElementRegistration;
+/** The element registrations of one `src/elements/` file; the editor keys its per-file reload cache on this. */
+export declare const resolveElementModule: (module: ProjectModule) => readonly ElementRegistration[];
+/** Validates the `src/elements/` files of an application config and flattens their registrations. */
+export declare const resolveElementModules: (modules: readonly ProjectModule[]) => readonly ElementRegistration[];
+export {};

package/dist/domain/domain-runtime/spec/module-checks/element-registration.js

@@ -0,0 +1 @@
+import{SHARED_FOLDER_HINT as e,isRecord as t,resolveListModule as o}from"./project-modules.js";export const createPhoenixLayoutElement=e=>e.component;export const createCustomPhoenixLayoutElement=(e,t)=>({type:"layout",name:e,element:t});export const createPhoenixEntityElement=e=>e.component;export const createCustomPhoenixEntityElement=(e,t)=>({type:"entity",name:e,element:t});let n={expected:"an element registration, or an array of them",fix:`Create it with phx.frontend.createCustomPhoenixLayoutElement(...) or phx.frontend.createCustomPhoenixEntityElement(...), ${e}.`},r=e=>!!t(e)&&("icon"===e.type?Array.isArray(e.elements):("entity"===e.type||"layout"===e.type)&&"string"==typeof e.name&&"function"==typeof e.element);export const resolveElementModule=e=>o(e,n,r);export const resolveElementModules=e=>e.flatMap(resolveElementModule);

package/dist/domain/domain-runtime/spec/module-checks/handler-registration.d.ts

@@ -0,0 +1,34 @@
+import { type ProjectModule } from './project-modules.js';
+export type PhoenixHandlerDefinition = {
+    handler: () => Promise<void>;
+};
+export type SystemPhoenixHandlerDefinition<P, R> = {
+    handler: (props: P) => R;
+};
+export type SystemPhoenixAsyncHandlerDefinition<P, R> = {
+    handler: (props: P) => Promise<R>;
+};
+export type SystemPhoenixHandlerRegistration<P, R> = {
+    type: 'system';
+    name: string;
+    handler: () => SystemPhoenixHandlerDefinition<P, R>;
+};
+export type SystemPhoenixAsyncHandlerRegistration<P, R> = {
+    type: 'system-async';
+    name: string;
+    handler: () => SystemPhoenixAsyncHandlerDefinition<P, R>;
+};
+export type PhoenixHandlerRegistration = {
+    type: 'phoenix';
+    name: string;
+    handler: () => PhoenixHandlerDefinition;
+};
+export type HandlerRegistration<P, R> = SystemPhoenixHandlerRegistration<P, R> | SystemPhoenixAsyncHandlerRegistration<P, R> | PhoenixHandlerRegistration;
+export declare const createPhoenixHandler: (name: string, handler: () => PhoenixHandlerDefinition) => PhoenixHandlerRegistration;
+export type CreatePhoenixHandler = (name: string, handler: () => PhoenixHandlerDefinition) => PhoenixHandlerRegistration;
+export declare const createSystemPhoenixHandler: <P, R>(name: string, handler: () => SystemPhoenixHandlerDefinition<P, R>) => SystemPhoenixHandlerRegistration<P, R>;
+export declare const createSystemPhoenixAsyncHandler: <P, R>(name: string, handler: () => SystemPhoenixAsyncHandlerDefinition<P, R>) => SystemPhoenixAsyncHandlerRegistration<P, R>;
+/** The handler registrations of one `src/handlers/` file; the editor keys its per-file reload cache on this. */
+export declare const resolveHandlerModule: (module: ProjectModule) => ReadonlyArray<HandlerRegistration<any, any>>;
+/** Validates the `src/handlers/` files of an application config and flattens their registrations. */
+export declare const resolveHandlerModules: (modules: readonly ProjectModule[]) => ReadonlyArray<HandlerRegistration<any, any>>;

package/dist/domain/domain-runtime/spec/module-checks/handler-registration.js

@@ -0,0 +1 @@
+import{SHARED_FOLDER_HINT as e,isRecord as t,resolveListModule as o}from"./project-modules.js";export const createPhoenixHandler=(e,t)=>({type:"phoenix",name:e,handler:t});export const createSystemPhoenixHandler=(e,t)=>({type:"system",name:e,handler:t});export const createSystemPhoenixAsyncHandler=(e,t)=>({type:"system-async",name:e,handler:t});let r={expected:"a handler registration, or an array of them",fix:`Create it with phx.frontend.createPhoenixHandler(...) or one of the other phx.frontend.create…Handler(...) factories, ${e}.`},n=e=>t(e)&&("phoenix"===e.type||"system"===e.type||"system-async"===e.type)&&"string"==typeof e.name&&"function"==typeof e.handler;export const resolveHandlerModule=e=>o(e,r,n);export const resolveHandlerModules=e=>e.flatMap(resolveHandlerModule);

package/dist/domain/domain-runtime/spec/module-checks/index.d.ts

@@ -0,0 +1,8 @@
+export { type PhoenixEntityElementProps, type PhoenixEntityElementRegistration, type PhoenixLayoutElementRegistration, type PhoenixIconRegistration, type ElementRegistration, type CustomPhoenixEntityElementProps, type PhoenixLayoutElementDefinition, type PhoenixEntityElementDefinition, type CreateCustomPhoenixLayoutElement, type CreateCustomPhoenixEntityElement, createPhoenixLayoutElement, createPhoenixEntityElement, createCustomPhoenixLayoutElement, createCustomPhoenixEntityElement, resolveElementModule, resolveElementModules, } from './element-registration.js';
+export { type PhoenixHandlerDefinition, type SystemPhoenixHandlerDefinition, type PhoenixHandlerRegistration, type SystemPhoenixHandlerRegistration, type SystemPhoenixAsyncHandlerDefinition, type SystemPhoenixAsyncHandlerRegistration, type HandlerRegistration, type CreatePhoenixHandler, createPhoenixHandler, createSystemPhoenixHandler, createSystemPhoenixAsyncHandler, resolveHandlerModule, resolveHandlerModules, } from './handler-registration.js';
+export { type ProjectModule } from './project-modules.js';
+export { resolveActionModules } from './resolve-action-modules.js';
+export { resolveComponentOpticModules } from './resolve-component-optic-modules.js';
+export { type ExpressionModule, resolveExpressionModules } from './resolve-expression-modules.js';
+export { resolveImportedTransformers, resolveTransformerModule, resolveTransformerModules, } from './resolve-imported-transformers.js';
+export { type AnyInvariant, resolveInvariantModules } from './resolve-invariant-modules.js';

package/dist/domain/domain-runtime/spec/module-checks/index.js

@@ -0,0 +1 @@
+export{createPhoenixLayoutElement,createPhoenixEntityElement,createCustomPhoenixLayoutElement,createCustomPhoenixEntityElement,resolveElementModule,resolveElementModules}from"./element-registration.js";export{createPhoenixHandler,createSystemPhoenixHandler,createSystemPhoenixAsyncHandler,resolveHandlerModule,resolveHandlerModules}from"./handler-registration.js";export{resolveActionModules}from"./resolve-action-modules.js";export{resolveComponentOpticModules}from"./resolve-component-optic-modules.js";export{resolveExpressionModules}from"./resolve-expression-modules.js";export{resolveImportedTransformers,resolveTransformerModule,resolveTransformerModules}from"./resolve-imported-transformers.js";export{resolveInvariantModules}from"./resolve-invariant-modules.js";

package/dist/domain/domain-runtime/spec/module-checks/project-modules.d.ts

@@ -0,0 +1,32 @@
+import { ImplementationError } from '../../errors/index.js';
+/**
+ * The default export of one file in a project convention folder (`src/elements/`, `src/handlers/`,
+ * `src/expressions/`, …), paired with the project-relative path it was imported from.
+ *
+ * Generated barrels and the editor's hot reload hand project code to the SDK in this shape, without
+ * inspecting it. Each folder's resolver then checks the export against the folder's contract, so an
+ * invalid file fails with an error naming it instead of an unrelated crash later.
+ */
+export interface ProjectModule {
+    readonly origin: string;
+    readonly exports: unknown;
+}
+/** What a convention folder requires of its files, in the words used by the contract error. */
+export interface ProjectModuleContract {
+    readonly expected: string;
+    readonly fix: string;
+}
+export declare const SHARED_FOLDER_HINT = "or move the file to an underscore-prefixed folder such as src/_shared/ when it is shared code";
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+/**
+ * The error of a file whose default export does not match its folder's contract. `received` is the
+ * value the message reports: the export itself, or the item of an array export that fails. The
+ * code is `MISSING_EXPORT` when the file has no default export at all, and `INVALID_EXPORT`
+ * otherwise, also when an item of an array export is `undefined`.
+ */
+export declare const createContractError: (module: ProjectModule, contract: ProjectModuleContract, received: unknown) => ImplementationError;
+/**
+ * Checks a file of a folder whose contract is one item or an array of them, and returns its items.
+ * The first item that fails the check is the value the error reports.
+ */
+export declare const resolveListModule: <Item>(module: ProjectModule, contract: ProjectModuleContract, isItem: (value: unknown) => value is Item) => readonly Item[];

package/dist/domain/domain-runtime/spec/module-checks/project-modules.js

@@ -0,0 +1 @@
+import{ImplementationError as e}from"../../errors/index.js";export const SHARED_FOLDER_HINT="or move the file to an underscore-prefixed folder such as src/_shared/ when it is shared code";export const isRecord=e=>"object"==typeof e&&null!==e&&!Array.isArray(e);export const createContractError=(r,t,o)=>new e({code:void 0===r.exports?"MISSING_EXPORT":"INVALID_EXPORT",origin:r.origin,problem:"Invalid default export",expected:t.expected,received:(e=>{if(void 0===e)return"nothing (the file has no default export)";if(null===e)return"null";if("function"==typeof e)return e.name?`the function "${e.name}"`:"an anonymous function";if(Array.isArray(e))return`an array of ${e.length} item(s)`;if(isRecord(e)){let r=Object.keys(e);return r.length>0?`an object with the keys ${r.join(", ")}`:"an empty object"}return`the ${typeof e} ${JSON.stringify(e)}`})(o),fix:`Every file in this folder is loaded by convention, so each one must default-export that shape. ${t.fix}`});export const resolveListModule=(e,r,t)=>{let o=Array.isArray(e.exports)?e.exports:[e.exports],n=[];for(let i of o){if(!t(i))throw createContractError(e,r,i);n.push(i)}return n};

package/dist/domain/domain-runtime/spec/module-checks/resolve-action-modules.d.ts

@@ -0,0 +1,4 @@
+import type { AnyActionImplementations } from '../../../core/index.js';
+import { type ProjectModule } from './project-modules.js';
+/** Validates the `src/actions/` files and merges their implementations by action name; a later file wins. */
+export declare const resolveActionModules: (modules: readonly ProjectModule[]) => AnyActionImplementations;

package/dist/domain/domain-runtime/spec/module-checks/resolve-action-modules.js

@@ -0,0 +1 @@
+import{SHARED_FOLDER_HINT as e,createContractError as t,isRecord as o}from"./project-modules.js";let i={expected:"an object of action implementations keyed by action name",fix:`Create it with phx.domain.implementActions({ ... }), ${e}.`},n=e=>"function"==typeof e;export const resolveActionModules=e=>e.reduce((e,r)=>{let c;if(!(o(c=r.exports)&&Object.values(c).every(n)))throw t(r,i,r.exports);return{...e,...r.exports}},{});

package/dist/domain/domain-runtime/spec/module-checks/resolve-component-optic-modules.d.ts

@@ -0,0 +1,4 @@
+import type { AnyDomainComponentOptic } from '../../../core/index.js';
+import { type ProjectModule } from './project-modules.js';
+/** Validates the `src/components/` files, or the optics a generated file lists, and flattens them. */
+export declare const resolveComponentOpticModules: (modules: readonly ProjectModule[]) => readonly AnyDomainComponentOptic[];

package/dist/domain/domain-runtime/spec/module-checks/resolve-component-optic-modules.js

@@ -0,0 +1 @@
+import{SHARED_FOLDER_HINT as t,isRecord as e,resolveListModule as n}from"./project-modules.js";let o={expected:"an attached component, or an array of them",fix:`Create it with phx.domain.attachComponent(...) (phx.domain.admin.attachComponent(...) under src/admin/), ${t}.`},a=t=>e(t)&&("simple"===t.kind||"dynamic"===t.kind)&&"string"==typeof t.instanceName&&"function"==typeof t.read;export const resolveComponentOpticModules=t=>t.flatMap(t=>n(t,o,a));

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

@@ -0,0 +1,15 @@
+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 and rejects an expression that two files define for the
+ * same entity type. Merging stays with the caller, because the domain builder and the editor expand
+ * aliases at different points; within one file the builder's own duplicate check applies.
+ */
+export declare const resolveExpressionModules: (modules: readonly ProjectModule[], aliasMap: Readonly<Record<string, readonly string[]>>) => readonly ExpressionModule[];
+export {};

package/dist/domain/domain-runtime/spec/module-checks/resolve-expression-modules.js

@@ -0,0 +1 @@
+import{SHARED_FOLDER_HINT as e,createContractError as o,isRecord as t}from"./project-modules.js";let i={expected:"an object of expressions keyed by entity type or alias, then by expression name",fix:`Create it with phx.domain.implementCustomExpressions({ ... }) (phx.domain.admin.implementCustomExpressions({ ... }) under src/admin/), ${e}.`},r=e=>t(e)&&"function"==typeof e.evaluate,n=e=>t(e)&&Object.values(e).every(r);export const resolveExpressionModules=(e,r)=>{let s=new Map;return e.map(e=>{let p;if(!(t(p=e.exports)&&Object.values(p).every(n)))throw o(e,i,e.exports);for(let[o,t]of Object.entries(e.exports))for(let i of r[o]??[o])for(let o of Object.keys(t)){let t=`${i}.${o}`,r=s.get(t);if(void 0!==r&&r!==e.origin)throw Error(`Duplicate expression ${t}: it is defined in both ${r} and ${e.origin}, which would make its value depend on file order. Keep one definition and remove the other.`);s.set(t,e.origin)}return{origin:e.origin,expressions:e.exports}})};

package/dist/domain/domain-runtime/spec/module-checks/resolve-imported-transformers.d.ts

@@ -0,0 +1,22 @@
+import type { ImportedTransformer, SpecTransformer } from '../../../application/index.js';
+import type { AnyDomainContextSystems, Transformers } from '../../../domain-context/index.js';
+import { type ProjectModule } from './project-modules.js';
+/**
+ * The transformer of one `src/transformers/` file, named after the file. The spec's `transformers` section
+ * selects a plain-function export by that name; a transformer made with `build(name)` registers under its own.
+ */
+export declare const resolveTransformerModule: (module: ProjectModule) => ImportedTransformer;
+/** Validates the `src/transformers/` files of an application config and names each after its file. */
+export declare const resolveTransformerModules: (modules: readonly ProjectModule[]) => readonly ImportedTransformer[];
+/**
+ * Resolves imported transformer modules against spec transformer declarations.
+ * Each imported transformer is registered/executed with the domain context,
+ * then matched by name against spec entries to apply priority ordering.
+ *
+ * Used both when the runtime spec is initialized from the application config and at hot-reload time
+ * (via domain-context subscription to registry changes).
+ *
+ * The transformers come from untyped project modules, so the context and the result have the open types of
+ * `AnyCreateTransformersFactory`, the slot of the runtime spec this function fills.
+ */
+export declare const resolveImportedTransformers: (importedTransformers: readonly ImportedTransformer[], specTransformers: readonly SpecTransformer[], ctx: AnyDomainContextSystems) => Transformers<any>;

package/dist/domain/domain-runtime/spec/module-checks/resolve-imported-transformers.js

@@ -0,0 +1 @@
+import{SHARED_FOLDER_HINT as r,createContractError as e,isRecord as t}from"./project-modules.js";let o={expected:"a transformer (a function of the domain context, or an object with a register method), or an array of them",fix:`Create it with phx.frontend.transformerBuilder, ${r}.`},n=r=>"function"==typeof r||t(r)&&"function"==typeof r.register;export const resolveTransformerModule=r=>{let t;if(!(Array.isArray(t=r.exports)?t.every(n):n(t)))throw e(r,o,r.exports);return{name:r.origin.replace(/^.*\//,"").replace(/\.tsx?$/,""),transformer:r.exports}};export const resolveTransformerModules=r=>r.map(resolveTransformerModule);export const resolveImportedTransformers=(r,e,t)=>{let o=r.flatMap(({name:r,transformer:e})=>{if(Array.isArray(e))return e.map((e,o)=>{if("register"in e)return e.register(t);if("function"==typeof e)return{priority:1/0,transformer:e(t),name:`${r}[${o}]`};throw Error(`Transformer '${r}[${o}]' must be either a RegistrableTransformer (with register method) or a TransformerFactory (function)`)});if("register"in e)return e.register(t);if("function"==typeof e)return{priority:1/0,transformer:e(t),name:r};throw Error(`Transformer '${r}' must be either a RegistrableTransformer (with register method) or a TransformerFactory (function)`)}),n=[];for(let r of e){let e=o.find(e=>e.name===r.name);if(!e){let e=o.map(r=>r.name).filter(Boolean).join(", ");throw Error(`Transformer '${r.name}' not found in imported transformer files. Available transformers: ${e||"none"}`)}n.push({priority:r.priority??1/0,transformer:e.transformer,name:r.name})}return n};

package/dist/domain/domain-runtime/spec/module-checks/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/domain-runtime/spec/module-checks/resolve-invariant-modules.js

@@ -0,0 +1 @@
+import{SHARED_FOLDER_HINT as e,createContractError as t,isRecord as r}from"./project-modules.js";let o={expected:"an object of invariant lists keyed by entity type or alias",fix:`Create it with phx.domain.implementCustomInvariants({ ... }) (phx.domain.admin.implementCustomInvariants({ ... }) under src/admin/), ${e}.`},i=e=>r(e)&&"function"==typeof e.evaluate,n=e=>r(e)&&Object.values(e).every(e=>Array.isArray(e)&&e.every(i));export const resolveInvariantModules=e=>{let r={};for(let i of e){if(!n(i.exports))throw t(i,o,i.exports);for(let[e,t]of Object.entries(i.exports))r[e]=[...r[e]??[],...t]}return r};

package/dist/domain/domain-runtime/spec/prepare-action-implementations.d.ts

@@ -0,0 +1,15 @@
+import type { ActionDefinitions, AnyActionImplementations } from '../../core/index.js';
+/** The declared actions that have no implementation, and the implementations of undeclared names. */
+export interface ActionImplementationConflicts {
+    readonly missing: readonly string[];
+    readonly extra: readonly string[];
+}
+/** Compares the names of the declared actions with the implemented ones. */
+export declare const findActionImplementationConflicts: (declared: readonly string[], implementations: AnyActionImplementations) => ActionImplementationConflicts;
+/**
+ * Validates the implemented actions against the declared ones, as `prepareDomainExpressions` does
+ * for expressions: a declared action without an implementation throws, so the domain is not
+ * instantiated with an action that can only fail when it is called; an implementation of an
+ * undeclared name is logged. Returns the implementations unchanged.
+ */
+export declare const prepareActionImplementations: (definitions: ActionDefinitions, implementations: AnyActionImplementations) => AnyActionImplementations;

package/dist/domain/domain-runtime/spec/prepare-action-implementations.js

@@ -0,0 +1,5 @@
+export const findActionImplementationConflicts=(e,t)=>{let n=Object.entries(t).filter(([,e])=>"function"==typeof e).map(([e])=>e);return{missing:e.filter(e=>!n.includes(e)),extra:n.filter(t=>!e.includes(t))}};export const prepareActionImplementations=(e,t)=>{let{missing:n,extra:i}=findActionImplementationConflicts(Object.values(e).map(e=>e.name),t);if(0===n.length&&0===i.length)return t;let o=Error("Domain cannot be instantiated because there are conflicts between declared and implemented actions."+(n.length>0?`
+
+Missing actions: ${n.join(", ")}. Add each to a default export of phx.domain.implementActions({ ... }) in src/actions/.`:"")+(i.length>0?`
+
+Extra actions: ${i.join(", ")}. Declare each under "actions" in a spec file or remove its implementation.`:"")+"\n");if(n.length>0)throw o;return console.error(o),t};

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

@@ -0,0 +1,16 @@
+import type { AnyExpressions } from '../../core/index.js';
+interface DomainExpressionsSource {
+    readonly expressions: AnyExpressions;
+    readonly $entityReflections: Record<string, {
+        readonly expressions: readonly string[];
+    }>;
+}
+/**
+ * Derives the runnable expression table from the factory's spec data: validates the declared
+ * (reflection) expressions against the implemented ones — missing implementations throw, extra
+ * ones log — and wraps every expression in the per-state memoization. Pure with respect to its
+ * input, so it can back a registry selector keyed on the factory identity: a hot-reloaded factory
+ * produces a fresh table, an unchanged one keeps the memoized result.
+ */
+export declare const prepareDomainExpressions: (source: DomainExpressionsSource) => AnyExpressions;
+export {};

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

@@ -1,6 +1,5 @@
 import type { PropsWithChildren } from 'react';
-import type { CustomPhoenixEntityElementProps } from '../../application/element-registration.js';
-import type { PhoenixHandlerDefinition, SystemPhoenixAsyncHandlerDefinition, SystemPhoenixHandlerDefinition } from '../../application/handler-registration.js';
+import { type CustomPhoenixEntityElementProps, type PhoenixHandlerDefinition, type SystemPhoenixAsyncHandlerDefinition, type SystemPhoenixHandlerDefinition } from './module-checks/index.js';
 import type { ApplicationSpec } from './types.js';
 /**
  * Structural slice of the runtime state the spec selectors read. The selectors are keyed on this
@@ -35,7 +34,7 @@ export declare const createSpecSelectors: (context: Context) => {
     selectPrefetchTextureUrls: import("@salsita-ai/common/utils").Selector<SpecSelectorState, readonly string[]>;
     selectTextLanguages: import("@salsita-ai/common/utils").Selector<SpecSelectorState, readonly string[]>;
     selectHandlerHashes: import("@salsita-ai/common/utils").Selector<SpecSelectorState, Record<string, string>>;
-    selectHandlers: import("@salsita-ai/common/utils").Selector<SpecSelectorState, readonly import("../../index.js").HandlerRegistration<any, any>[]>;
+    selectHandlers: import("@salsita-ai/common/utils").Selector<SpecSelectorState, readonly import("./index.js").HandlerRegistration<any, any>[]>;
     selectHandlerSlots: import("@salsita-ai/common/utils").Selector<SpecSelectorState, {
         handlers: Record<string, () => PhoenixHandlerDefinition>;
         systemHandlers: Record<string, () => SystemPhoenixHandlerDefinition<unknown, unknown>>;
@@ -43,7 +42,7 @@ export declare const createSpecSelectors: (context: Context) => {
         hashes: Record<string, string>;
     }>;
     selectElementHashes: import("@salsita-ai/common/utils").Selector<SpecSelectorState, Record<string, string>>;
-    selectElements: import("@salsita-ai/common/utils").Selector<SpecSelectorState, readonly import("../../index.js").ElementRegistration[]>;
+    selectElements: import("@salsita-ai/common/utils").Selector<SpecSelectorState, readonly import("./index.js").ElementRegistration[]>;
     selectElementSlots: import("@salsita-ai/common/utils").Selector<SpecSelectorState, {
         entityElements: Record<string, (props: CustomPhoenixEntityElementProps) => JSX.Element>;
         layoutElements: Record<string, (props: PropsWithChildren) => JSX.Element>;
@@ -78,7 +77,7 @@ export declare const createSpecSelectors: (context: Context) => {
     getPrefetchTextureUrls: () => readonly string[];
     getTextLanguages: () => readonly string[];
     getHandlerHashes: () => Record<string, string>;
-    getHandlers: () => readonly import("../../index.js").HandlerRegistration<any, any>[];
+    getHandlers: () => readonly import("./index.js").HandlerRegistration<any, any>[];
     getHandlerSlots: () => {
         handlers: Record<string, () => PhoenixHandlerDefinition>;
         systemHandlers: Record<string, () => SystemPhoenixHandlerDefinition<unknown, unknown>>;
@@ -86,7 +85,7 @@ export declare const createSpecSelectors: (context: Context) => {
         hashes: Record<string, string>;
     };
     getElementHashes: () => Record<string, string>;
-    getElements: () => readonly import("../../index.js").ElementRegistration[];
+    getElements: () => readonly import("./index.js").ElementRegistration[];
     getElementSlots: () => {
         entityElements: Record<string, (props: CustomPhoenixEntityElementProps) => JSX.Element>;
         layoutElements: Record<string, (props: PropsWithChildren) => JSX.Element>;

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

@@ -1 +1 @@
-import{createSelector as e}from"@salsita-ai/common/utils";import{buildAssistantManifest as t}from"../../application/assistant/index.js";import{systemElementRegistry as n}from"../../application/element-registration.js";export const createSpecSelectors=a=>{let{getState:s}=a,r=e.withTypes(),o=r([r.leaf(e=>e.spec)],e=>e),l=r([o],e=>e.version),i=r([o],e=>e.baseResourcesUrl),m=r([o],e=>e.configurator),g=r([o],e=>e.dataConfig),p=r([o],e=>e.chunks),d=r([o],e=>e.publishedDataHash),c=r([o],e=>e.initialPublishedData),u=r([o],e=>e.canCreate),y=r([o],e=>e.enableAdminRelease),h=r([o],e=>e.textLanguages),f=r([m],e=>e.modelVersion),C=r([o],e=>e.admin),A=r([C],e=>e.preset),E=r([C],e=>e.modelVersion),b=r([m],e=>e.theme),x=r([m],e=>e.assistant),H=r([x],e=>e?t(e):null),D=r([m],e=>e.factory),P=r([C],e=>e.factory),S=r([m],e=>e.componentOptics),w=r([C],e=>e.componentOptics),O=r([m],e=>e.appLoader),T=r([m],e=>e.preview),V=r([m],e=>e.alwaysExpand),L=r([m],e=>e.presets),R=r([m],e=>e.deploymentQueryDisabled),U=r([m],e=>e.prefetchTextureUrls),v=r([m],e=>e.handlerHashes),j=r([m],e=>e.handlers),k=r([j,v],(e,t)=>({...(e=>{let t={},n={},a={};for(let s of e)"phoenix"===s.type&&(t[s.name]=s.handler),"system"===s.type&&(n[s.name]=s.handler),"system-async"===s.type&&(a[s.name]=s.handler);return{handlers:t,systemHandlers:n,systemAsyncHandlers:a}})(e),hashes:t})),F=r([m],e=>e.elementHashes),M=r([m],e=>e.elements),Q=r([M,F],(e,t)=>({...(e=>{let t={},a={};for(let n of e)"layout"===n.type&&(t[n.name]=n.element),"entity"===n.type&&(a[n.name]=n.element);return{entityElements:{...n.entityElements,...a},layoutElements:{...n.layoutElements,...t}}})(e),hashes:t}));return{selectSpec:o,selectVersion:l,selectBaseResourcesUrl:i,selectConfiguratorSpec:m,selectConfiguratorModelVersion:f,selectAdminSpec:C,selectAdminPreset:A,selectAdminModelVersion:E,selectThemeOptions:b,selectAssistant:H,selectConfiguratorFactory:D,selectAdminFactory:P,selectConfiguratorComponentOptics:S,selectAdminComponentOptics:w,selectAppLoader:O,selectPreview:T,selectAlwaysExpand:V,selectPresetSeed:L,selectDeploymentQueryDisabled:R,selectPrefetchTextureUrls:U,selectTextLanguages:h,selectHandlerHashes:v,selectHandlers:j,selectHandlerSlots:k,selectElementHashes:F,selectElements:M,selectElementSlots:Q,selectDataConfig:g,selectChunks:p,selectPublishedDataHash:d,selectInitialPublishedData:c,selectCanCreate:u,selectEnableAdminRelease:y,getVersion:()=>l(s()),getBaseResourcesUrl:()=>i(s()),getConfiguratorSpec:()=>m(s()),getConfiguratorModelVersion:()=>f(s()),getAdminSpec:()=>C(s()),getAdminPreset:()=>A(s()),getAdminModelVersion:()=>E(s()),getThemeOptions:()=>b(s()),getAssistant:()=>H(s()),getConfiguratorFactory:()=>D(s()),getAdminFactory:()=>P(s()),getConfiguratorComponentOptics:()=>S(s()),getAdminComponentOptics:()=>w(s()),getAppLoader:()=>O(s()),getPreview:()=>T(s()),getAlwaysExpand:()=>V(s()),getPresetSeed:()=>L(s()),getDeploymentQueryDisabled:()=>R(s()),getPrefetchTextureUrls:()=>U(s()),getTextLanguages:()=>h(s()),getHandlerHashes:()=>v(s()),getHandlers:()=>j(s()),getHandlerSlots:()=>k(s()),getElementHashes:()=>F(s()),getElements:()=>M(s()),getElementSlots:()=>Q(s()),getDataConfig:()=>g(s()),getChunks:()=>p(s()),getPublishedDataHash:()=>d(s()),getInitialPublishedData:()=>c(s()),getCanCreate:()=>u(s()),getEnableAdminRelease:()=>y(s())}};
+import{createSelector as e}from"@salsita-ai/common/utils";import{buildAssistantManifest as t}from"../../application/assistant/index.js";export const createSpecSelectors=a=>{let{getState:n}=a,s=e.withTypes(),r=s([s.leaf(e=>e.spec)],e=>e),l=s([r],e=>e.version),o=s([r],e=>e.baseResourcesUrl),i=s([r],e=>e.configurator),g=s([r],e=>e.dataConfig),m=s([r],e=>e.chunks),p=s([r],e=>e.publishedDataHash),d=s([r],e=>e.initialPublishedData),c=s([r],e=>e.canCreate),u=s([r],e=>e.enableAdminRelease),h=s([r],e=>e.textLanguages),y=s([i],e=>e.modelVersion),f=s([r],e=>e.admin),C=s([f],e=>e.preset),A=s([f],e=>e.modelVersion),b=s([i],e=>e.theme),x=s([i],e=>e.assistant),E=s([x],e=>e?t(e):null),H=s([i],e=>e.factory),D=s([f],e=>e.factory),P=s([i],e=>e.componentOptics),S=s([f],e=>e.componentOptics),w=s([i],e=>e.appLoader),O=s([i],e=>e.preview),T=s([i],e=>e.alwaysExpand),V=s([i],e=>e.presets),L=s([i],e=>e.deploymentQueryDisabled),R=s([i],e=>e.prefetchTextureUrls),U=s([i],e=>e.handlerHashes),v=s([i],e=>e.handlers),k=s([v,U],(e,t)=>({...(e=>{let t={},a={},n={};for(let s of e)"phoenix"===s.type&&(t[s.name]=s.handler),"system"===s.type&&(a[s.name]=s.handler),"system-async"===s.type&&(n[s.name]=s.handler);return{handlers:t,systemHandlers:a,systemAsyncHandlers:n}})(e),hashes:t})),F=s([i],e=>e.elementHashes),M=s([i],e=>e.elements),Q=s([i],e=>e.defaultElements),j=s([Q,M,F],(e,t,a)=>({...(e=>{let t={},a={};for(let n of e)"layout"===n.type&&(t[n.name]=n.element),"entity"===n.type&&(a[n.name]=n.element);return{entityElements:a,layoutElements:t}})([...e,...t]),hashes:a}));return{selectSpec:r,selectVersion:l,selectBaseResourcesUrl:o,selectConfiguratorSpec:i,selectConfiguratorModelVersion:y,selectAdminSpec:f,selectAdminPreset:C,selectAdminModelVersion:A,selectThemeOptions:b,selectAssistant:E,selectConfiguratorFactory:H,selectAdminFactory:D,selectConfiguratorComponentOptics:P,selectAdminComponentOptics:S,selectAppLoader:w,selectPreview:O,selectAlwaysExpand:T,selectPresetSeed:V,selectDeploymentQueryDisabled:L,selectPrefetchTextureUrls:R,selectTextLanguages:h,selectHandlerHashes:U,selectHandlers:v,selectHandlerSlots:k,selectElementHashes:F,selectElements:M,selectElementSlots:j,selectDataConfig:g,selectChunks:m,selectPublishedDataHash:p,selectInitialPublishedData:d,selectCanCreate:c,selectEnableAdminRelease:u,getVersion:()=>l(n()),getBaseResourcesUrl:()=>o(n()),getConfiguratorSpec:()=>i(n()),getConfiguratorModelVersion:()=>y(n()),getAdminSpec:()=>f(n()),getAdminPreset:()=>C(n()),getAdminModelVersion:()=>A(n()),getThemeOptions:()=>b(n()),getAssistant:()=>E(n()),getConfiguratorFactory:()=>H(n()),getAdminFactory:()=>D(n()),getConfiguratorComponentOptics:()=>P(n()),getAdminComponentOptics:()=>S(n()),getAppLoader:()=>w(n()),getPreview:()=>O(n()),getAlwaysExpand:()=>T(n()),getPresetSeed:()=>V(n()),getDeploymentQueryDisabled:()=>L(n()),getPrefetchTextureUrls:()=>R(n()),getTextLanguages:()=>h(n()),getHandlerHashes:()=>U(n()),getHandlers:()=>v(n()),getHandlerSlots:()=>k(n()),getElementHashes:()=>F(n()),getElements:()=>M(n()),getElementSlots:()=>j(n()),getDataConfig:()=>g(n()),getChunks:()=>m(n()),getPublishedDataHash:()=>p(n()),getInitialPublishedData:()=>d(n()),getCanCreate:()=>c(n()),getEnableAdminRelease:()=>u(n())}};

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

@@ -1,9 +1,9 @@
 import type { ThemeOptions } from '@mui/material';
 import type { SessionRole } from '@salsita-ai/contracts/api';
-import type { AssistantResolvedManifest, ChunksSpec, DataSpec, ElementRegistration, HandlerRegistration } from '../../application/index.js';
-import type { AnyDomainComponentOptic } from '../../components/index.js';
-import type { ActionDefinitions, Any$EntityReflections, AnyActionImplementations, AnyAliasMap, AnyAllowedRootEntityTypes, AnyDomainFactory, AnyEntityReflections, AnyExpressions, AnyProductPreset, DomainEntity, MigrateFunction } from '../../core/index.js';
-import type { AnyCreateTransformersFactory } from '../../domain-context/store-system/store-system.js';
+import type { AssistantResolvedManifest, ChunksSpec, DataSpec } from '../../application/index.js';
+import type { ActionDefinitions, Any$EntityReflections, AnyActionImplementations, AnyAliasMap, AnyAllowedRootEntityTypes, AnyDomainComponentOptic, AnyDomainFactory, AnyEntityReflections, AnyExpressions, AnyProductPreset, DomainEntity, MigrateFunction } from '../../core/index.js';
+import type { AnyCreateTransformersFactory } from '../../domain-context/index.js';
+import type { ElementRegistration, HandlerRegistration } from './module-checks/index.js';
 export interface ApplicationConfiguratorSpec {
     readonly modelVersion: number;
     readonly factory: AnyDomainFactory;
@@ -35,6 +35,8 @@ export interface ApplicationConfiguratorSpec {
      */
     readonly handlerHashes: Record<string, string>;
     readonly elements: readonly ElementRegistration[];
+    /** The SDK's default element registrations; an entry of `elements` with the same name replaces one. */
+    readonly defaultElements: readonly ElementRegistration[];
     /**
      * Per-element content hash. Used as remount key so only the specific element
      * whose source changed remounts. Unchanged elements keep their hash and stay mounted.

package/dist/domain/extensions/angle-indicator.d.ts

@@ -0,0 +1,21 @@
+import { type Localizable } from '@salsita-ai/common/utils';
+import { type ComponentSnapshot } from '../core/index.js';
+import { type AngleIndicatorBaseState } from './common/index.js';
+export type AngleIndicatorComponentState = AngleIndicatorBaseState & {
+    /**
+     * Indicator label. If no label is provided, the measured angle in degrees will be shown.
+     */
+    readonly label?: Localizable;
+    /**
+     * If true, the indicator will be visible. Default is true.
+     */
+    readonly visible?: boolean;
+    /**
+     * If true, the indicator will always be shown regardless of the global dimension indicator visibility setting.
+     */
+    readonly force?: boolean;
+};
+export declare const angleIndicatorComponent: import("../index.js").SystemComponentType<"angleIndicator", AngleIndicatorComponentState, never>;
+export type AngleIndicatorComponent = typeof angleIndicatorComponent;
+export type AngleIndicatorComponentSnapshot = ComponentSnapshot<AngleIndicatorComponent>;
+export declare const isAngleIndicatorSnapshot: (snapshot: ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<import("../index.js").SystemComponentType<"angleIndicator", AngleIndicatorComponentState, never>>;