@salsita-ai/sdk 0.50.0-develop.f03b563886 → 0.50.0-develop.f16492b14e

package/dist/domain/domain-runtime/errors/implementation-error-collector.d.ts

@@ -0,0 +1,21 @@
+import { type ImplementationError } from './implementation-error.js';
+/**
+ * Gathers the implementation errors of one application start. Checks that do not depend on each
+ * other run through `attempt`, so that the failure of one does not hide the failures of the others.
+ */
+export interface ImplementationErrorCollector {
+    /**
+     * Runs one independent check. An implementation error it throws is recorded and `fallback` is
+     * returned, so the checks after it still run. Anything else it throws propagates.
+     */
+    readonly attempt: <T>(check: () => T, fallback: T) => T;
+    readonly add: (error: ImplementationError) => void;
+    /** The errors recorded so far, in the order they were recorded. A host that reports them itself, such as the editor, reads them here instead of throwing them. */
+    readonly recorded: () => readonly ImplementationError[];
+    /**
+     * Throws the recorded errors as one {@link ImplementationErrors}, in the order they were
+     * recorded. Does nothing when there are none.
+     */
+    readonly throwIfAny: () => void;
+}
+export declare const createImplementationErrorCollector: () => ImplementationErrorCollector;

package/dist/domain/domain-runtime/errors/implementation-error-collector.js

@@ -0,0 +1 @@
+import{isImplementationError as r}from"./implementation-error.js";import{ImplementationErrors as t,isImplementationErrors as e}from"./implementation-errors.js";export const createImplementationErrorCollector=()=>{let o=[],n=r=>{o.push(r)};return{add:n,attempt:(t,o)=>{try{return t()}catch(t){if(e(t))return t.errors.forEach(n),o;if(r(t))return n(t),o;throw t}},recorded:()=>[...o],throwIfAny:()=>{if(o.length>0)throw new t(o)}}};

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

@@ -0,0 +1,46 @@
+/**
+ * What kind of mistake an {@link ImplementationError} reports. A host that shows the error, such as
+ * a webhook log, reads the code instead of parsing the message.
+ *
+ * - `MISSING_EXPORT`: a convention file exports nothing where its folder requires an export.
+ * - `INVALID_EXPORT`: a convention file exports a value that does not match its folder's contract.
+ * - `MISSING_IMPLEMENTATION`: the spec declares something that no project file implements.
+ * - `DUPLICATE_DEFINITION`: two files define what only one may define.
+ * - `INVALID_CONFIGURATION`: the application's configuration is incomplete or contradictory.
+ * - `STARTUP_FAILED`: project or SDK code threw while the application was starting.
+ */
+export type ImplementationErrorCode = 'MISSING_EXPORT' | 'INVALID_EXPORT' | 'MISSING_IMPLEMENTATION' | 'DUPLICATE_DEFINITION' | 'INVALID_CONFIGURATION' | 'STARTUP_FAILED';
+/** The parts an {@link ImplementationError} is made of. Its message is built from them. */
+export interface ImplementationErrorProps {
+    readonly code: ImplementationErrorCode;
+    /** Project-relative path of the file to fix, or `null` when the mistake belongs to no single file. */
+    readonly origin: string | null;
+    /** What went wrong, without the file name and without a full stop. */
+    readonly problem: string;
+    /** What the SDK requires at that place, when the mistake is a wrong value. */
+    readonly expected?: string;
+    /** What it found instead. It is part of the message only together with `expected`. */
+    readonly received?: string;
+    /** What the developer can do to fix it, as one or more full sentences. */
+    readonly fix: string;
+    /** What was thrown, when the error reports a failure of other code. */
+    readonly cause?: unknown;
+}
+/**
+ * A mistake in a project's implementation that stops its application from starting: a convention
+ * file with the wrong export, a definition made twice, a project file that throws.
+ *
+ * The checks the domain runtime runs on a project's files throw it, so that every host of the
+ * runtime (the web component, the editor, a webhook) can tell it from a defect of its own and report
+ * it in its own medium. `message` is the whole report as one text; the fields hold its parts.
+ */
+export declare class ImplementationError extends Error {
+    readonly code: ImplementationErrorCode;
+    readonly origin: string | null;
+    readonly problem: string;
+    readonly expected: string | null;
+    readonly received: string | null;
+    readonly fix: string;
+    constructor(props: ImplementationErrorProps);
+}
+export declare const isImplementationError: (error: unknown) => error is ImplementationError;

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

@@ -0,0 +1 @@
+export class ImplementationError extends Error{code;origin;problem;expected;received;fix;constructor(e){let i,r,o;super((i=null===e.origin?"":` in ${e.origin}`,r=void 0===e.received?"":`, but got ${e.received}`,o=void 0===e.expected?"":`: expected ${e.expected}${r}`,`${e.problem}${i}${o}. ${e.fix}`),void 0===e.cause?void 0:{cause:e.cause}),this.name="ImplementationError",this.code=e.code,this.origin=e.origin,this.problem=e.problem,this.expected=e.expected??null,this.received=e.received??null,this.fix=e.fix}}export const isImplementationError=e=>e instanceof ImplementationError;

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

@@ -0,0 +1,13 @@
+import type { ImplementationError } from './implementation-error.js';
+/**
+ * Every {@link ImplementationError} one start of an application found, reported together, so that a
+ * developer with four wrong files reads four errors instead of fixing them one reload at a time.
+ *
+ * The message of a list with one error is that error's message. The message of a longer list is a
+ * headline with the count, followed by one numbered line per error in the order of `errors`.
+ */
+export declare class ImplementationErrors extends Error {
+    readonly errors: readonly ImplementationError[];
+    constructor(errors: readonly ImplementationError[]);
+}
+export declare const isImplementationErrors: (error: unknown) => error is ImplementationErrors;

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

@@ -0,0 +1 @@
+export class ImplementationErrors extends Error{errors;constructor(r){super((r=>{let[e]=r;return 1===r.length&&e?e.message:[`The application cannot start: ${r.length} implementation errors were found.`,...r.map((r,e)=>`${e+1}. ${r.message}`)].join("\n")})(r)),this.name="ImplementationErrors",this.errors=r}}export const isImplementationErrors=r=>r instanceof ImplementationErrors;

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

@@ -0,0 +1,4 @@
+export { type ImplementationErrorCode, type ImplementationErrorProps, ImplementationError, isImplementationError, } from './implementation-error.js';
+export { type ImplementationErrorCollector, createImplementationErrorCollector, } from './implementation-error-collector.js';
+export { ImplementationErrors, isImplementationErrors } from './implementation-errors.js';
+export { type StartupStage, toImplementationErrors } from './to-implementation-errors.js';

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,8 @@
 export * from './domain-runtime.js';
+export { type Application, applicationFromConfig } from './application.js';
 export * from './domain-context/index.js';
 export * from './domain-services/index.js';
+export { type ImplementationErrorCode, type ImplementationErrorCollector, type ImplementationErrorProps, type StartupStage, ImplementationError, ImplementationErrors, createImplementationErrorCollector, 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{applicationFromConfig}from"./application.js";export*from"./domain-context/index.js";export*from"./domain-services/index.js";export{ImplementationError,ImplementationErrors,createImplementationErrorCollector,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,12 +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 './invariant-builder.js';
 export * from './memoize-expression.js';
+export { type PhoenixEntityElementProps, type PhoenixEntityElementRegistration, type PhoenixLayoutElementRegistration, type PhoenixIconRegistration, type AssistantFormElementRegistration, type ElementRegistration, type CustomPhoenixEntityElementProps, type PhoenixLayoutElementDefinition, type PhoenixEntityElementDefinition, type CreateCustomPhoenixLayoutElement, type CreateCustomPhoenixEntityElement, createPhoenixLayoutElement, createPhoenixEntityElement, createCustomPhoenixLayoutElement, createCustomPhoenixEntityElement, createAssistantFormElement, findAssistantFormElementErrors, 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, type ValuedExpressions, mergeExpressionModules, resolveImportedTransformers, resolveTransformerModule, resolveTransformerModules, resolveInvariantModules, } from './module-checks/index.js';
 export * from './prepare-action-implementations.js';
 export * from './prepare-domain-expressions.js';
-export * from './resolve-action-modules.js';
-export * from './resolve-component-optic-modules.js';
-export * from './resolve-expression-modules.js';
-export * from './resolve-invariant-modules.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"./invariant-builder.js";export*from"./memoize-expression.js";export*from"./prepare-action-implementations.js";export*from"./prepare-domain-expressions.js";export*from"./resolve-action-modules.js";export*from"./resolve-component-optic-modules.js";export*from"./resolve-expression-modules.js";export*from"./resolve-invariant-modules.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,createAssistantFormElement,findAssistantFormElementErrors,resolveElementModule,resolveElementModules,createPhoenixHandler,createSystemPhoenixHandler,createSystemPhoenixAsyncHandler,resolveHandlerModule,resolveHandlerModules,resolveActionModules,resolveComponentOpticModules,resolveExpressionModules,mergeExpressionModules,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 e}from"@salsita-ai/contracts/api";import{resolveElementModules as t}from"../../application/element-registration.js";import{resolveHandlerModules as a}from"../../application/handler-registration.js";import{resolveImportedTransformers as o,resolveTransformerModules as n}from"../../application/resolve-imported-transformers.js";import{resolveComponentOpticModules as i}from"./resolve-component-optic-modules.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=t(s.elements),d=(e=>{let t={};for(let a of e)t[a.name]=(void 0)??a.name;return t})(m),l=(e=>{let t={},a=0;for(let o of e)if("entity"===o.type||"layout"===o.type)t[o.name]=(void 0)??o.name;else{let e=`icon:${a}`;t[e]=(void 0)??`${e}:${o.elements.length}`,a+=1}return t})(c),p=n(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(e),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:e=>o(p,y,e),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("assistantFormElement"!==n.type)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/{application → domain-runtime/spec/module-checks}/element-registration.d.ts

@@ -1,8 +1,8 @@
 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/index.js';
+import type { DomainEntityId } from '../../../core/index.js';
+import { type ProjectModule } from './project-modules.js';
 export interface PhoenixEntityElementProps {
     entityId: DomainEntityId<string>;
     children?: ReactNode;
@@ -21,20 +21,23 @@ export type PhoenixIconRegistration = {
     type: 'icon';
     elements: ReadonlyArray<(props: SvgIconProps) => JSX.Element>;
 };
-export type ElementRegistration = PhoenixEntityElementRegistration | PhoenixLayoutElementRegistration | PhoenixIconRegistration;
+/**
+ * The component of one of the project's own assistant form elements, registered under the name its
+ * YAML declares it by in `assistant.formElements`. The component's props depend on the element's
+ * role and are typed by `phx.frontend.createAssistantFormElement` from the YAML; the registration
+ * itself is untyped, since the panel validates an element's attributes against the very declaration
+ * its props are typed from.
+ */
+export type AssistantFormElementRegistration = {
+    type: 'assistantFormElement';
+    name: string;
+    element: (props: never) => ReactNode;
+};
+export type ElementRegistration = PhoenixEntityElementRegistration | PhoenixLayoutElementRegistration | PhoenixIconRegistration | AssistantFormElementRegistration;
 export interface CustomPhoenixEntityElementProps {
     entityId: DomainEntityId<string>;
     children?: ReactNode;
 }
-export interface SystemElementRegistry {
-    layoutElements: Record<string, (props: PropsWithChildren) => JSX.Element>;
-    entityElements: Record<string, (props: CustomPhoenixEntityElementProps) => JSX.Element>;
-}
-/**
- * Internal registry for system-level elements registered at import time
- * via createPhoenixLayoutElement / createPhoenixEntityElement.
- */
-export declare const systemElementRegistry: SystemElementRegistry;
 type SchemaOfPhoenixLayoutElement<SCHEMA extends {
     kind: string;
     props?: Record<string, unknown>;
@@ -61,7 +64,12 @@ export interface PhoenixLayoutElementDefinition<SCHEMA extends {
     }>;
 }
 /**
- * For internal use in PHX only.
+ * 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;
@@ -71,6 +79,8 @@ export declare const createPhoenixLayoutElement: <SCHEMA extends {
 }>;
 export declare const createCustomPhoenixLayoutElement: (name: string, element: (props: PropsWithChildren) => JSX.Element) => PhoenixLayoutElementRegistration;
 export type CreateCustomPhoenixLayoutElement = (name: string, element: (props: PropsWithChildren) => JSX.Element) => PhoenixLayoutElementRegistration;
+/** Registers a component as the assistant form element of the name. */
+export declare const createAssistantFormElement: (name: string, element: (props: never) => ReactNode) => AssistantFormElementRegistration;
 type SchemaOfPhoenixElement<SCHEMA extends {
     kind: string;
     props?: Record<string, unknown>;
@@ -95,7 +105,12 @@ export interface PhoenixEntityElementDefinition<SCHEMA extends {
     component: React.FunctionComponent<SCHEMA['props'] & CustomPhoenixEntityElementProps>;
 }
 /**
- * For internal use in PHX only.
+ * 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;

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 createAssistantFormElement=(e,t)=>({type:"assistantFormElement",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(...), phx.frontend.createCustomPhoenixEntityElement(...) or phx.frontend.createAssistantFormElement(...), ${e}.`},r=e=>!!t(e)&&("icon"===e.type?Array.isArray(e.elements):("entity"===e.type||"layout"===e.type||"assistantFormElement"===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/find-assistant-form-element-errors.d.ts

@@ -0,0 +1,12 @@
+import { ImplementationError } from '../../errors/index.js';
+import type { ElementRegistration } from './element-registration.js';
+/**
+ * The mistakes in pairing the project's assistant form elements with their components: an element
+ * the YAML declares under `assistant.formElements` that no file in `src/elements/` registers, or
+ * that two register, and a registration of a name the YAML does not declare. Spec parsing cannot
+ * see which name a file registers, so the application checks this when it starts and on every hot
+ * reload, on the registrations of all element files together.
+ */
+export declare const findAssistantFormElementErrors: (formElements: ReadonlyArray<{
+    readonly name: string;
+}>, elements: readonly ElementRegistration[]) => readonly ImplementationError[];

package/dist/domain/domain-runtime/spec/module-checks/find-assistant-form-element-errors.js

@@ -0,0 +1 @@
+import{ImplementationError as e}from"../../errors/index.js";export const findAssistantFormElementErrors=(t,n)=>{let s=n.flatMap(e=>"assistantFormElement"===e.type?[e.name]:[]),r=new Set(t.map(({name:e})=>e));return[...t.flatMap(({name:t})=>{let n=s.filter(e=>e===t).length;return 0===n?[new e({code:"MISSING_IMPLEMENTATION",origin:null,problem:`The assistant form element "${t}" declared under assistant.formElements has no component`,fix:`Add a file to src/elements/ that default-exports phx.frontend.createAssistantFormElement('${t}', Component), or remove the element from the YAML.`})]:n>1?[new e({code:"DUPLICATE_DEFINITION",origin:null,problem:`The assistant form element "${t}" is registered by ${n} files in src/elements/`,fix:`Each element has one component. Keep one phx.frontend.createAssistantFormElement('${t}', …) and remove the others.`})]:[]}),...[...new Set(s)].filter(e=>!r.has(e)).map(t=>new e({code:"MISSING_IMPLEMENTATION",origin:null,problem:`A file in src/elements/ registers the assistant form element "${t}", which assistant.formElements does not declare`,fix:`Declare "${t}" under assistant.formElements with its description, role and attributes, so the assistant knows the element, or remove the registration.`}))]};

package/dist/domain/{application → domain-runtime/spec/module-checks}/handler-registration.d.ts

@@ -1,4 +1,4 @@
-import { type ProjectModule } from '../project-modules/index.js';
+import { type ProjectModule } from './project-modules.js';
 export type PhoenixHandlerDefinition = {
     handler: () => Promise<void>;
 };

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,10 @@
+export { type PhoenixEntityElementProps, type PhoenixEntityElementRegistration, type PhoenixLayoutElementRegistration, type PhoenixIconRegistration, type AssistantFormElementRegistration, type ElementRegistration, type CustomPhoenixEntityElementProps, type PhoenixLayoutElementDefinition, type PhoenixEntityElementDefinition, type CreateCustomPhoenixLayoutElement, type CreateCustomPhoenixEntityElement, createPhoenixLayoutElement, createPhoenixEntityElement, createCustomPhoenixLayoutElement, createCustomPhoenixEntityElement, createAssistantFormElement, 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 { findAssistantFormElementErrors } from './find-assistant-form-element-errors.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 ValuedExpressions, mergeExpressionModules } from './merge-expression-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,createAssistantFormElement,resolveElementModule,resolveElementModules}from"./element-registration.js";export{createPhoenixHandler,createSystemPhoenixHandler,createSystemPhoenixAsyncHandler,resolveHandlerModule,resolveHandlerModules}from"./handler-registration.js";export{findAssistantFormElementErrors}from"./find-assistant-form-element-errors.js";export{resolveActionModules}from"./resolve-action-modules.js";export{resolveComponentOpticModules}from"./resolve-component-optic-modules.js";export{mergeExpressionModules}from"./merge-expression-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/merge-expression-modules.d.ts

@@ -0,0 +1,23 @@
+import type { AnonymousExpression, AnyExpressions } from '../../../core/index.js';
+import { type ImplementationErrorCollector } from '../../errors/index.js';
+import { type ProjectModule } from './project-modules.js';
+type AnyAnonymousExpression = AnonymousExpression<any, any, any, any, any, any, unknown>;
+type AliasMap = Readonly<Record<string, readonly string[]>>;
+/** The expression names that already have a value, by entity type, so no project file may define them. */
+export type ValuedExpressions = ReadonlyMap<string, ReadonlySet<string>>;
+/** Whether a file's default export has the shape of the expressions folder contract. */
+export declare const isExpressionExport: (value: unknown) => value is Record<string, Record<string, AnyAnonymousExpression>>;
+/**
+ * Merges the `src/expressions/` files (or `src/admin/expressions/`) into the expressions of each
+ * entity type. It checks each file against the folder contract, rejects an expression that two
+ * files, or two keys of one file, define for one entity type after the aliases of `aliasMap` are
+ * expanded, and rejects an expression listed in `valued`, which the application gives a value
+ * already. Each accepted expression gets its `origin`: its name and the entity type or alias the
+ * file keys it by.
+ *
+ * Each file is checked on its own: a wrong file is recorded in `errors` with all its conflicts and
+ * left out, and the files after it still merge. Without `errors`, everything recorded is thrown at
+ * the end as one `ImplementationErrors`.
+ */
+export declare const mergeExpressionModules: (modules: readonly ProjectModule[], aliasMap: AliasMap, errors?: ImplementationErrorCollector, valued?: ValuedExpressions) => AnyExpressions;
+export {};

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

@@ -0,0 +1 @@
+import{ImplementationError as e,ImplementationErrors as o,createImplementationErrorCollector as t}from"../../errors/index.js";import{SHARED_FOLDER_HINT as i,createContractError as n,isRecord as r}from"./project-modules.js";let s={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/), ${i}.`},a=e=>r(e)&&"function"==typeof e.evaluate,p=e=>r(e)&&Object.values(e).every(a);export const isExpressionExport=e=>r(e)&&Object.values(e).every(p);let l=(o,t,i)=>new e({code:"DUPLICATE_DEFINITION",origin:o,problem:`Duplicate expression ${t}`,fix:i}),d=(e,t,i,r)=>{if(!isExpressionExport(e.exports))throw n(e,s,e.exports);let a=[],p=new Map,d=[];for(let[o,n]of Object.entries(e.exports))for(let s of t[o]??[o])for(let[t,f]of Object.entries(n)){let n=`${s}.${t}`,h=p.get(n),m=i.get(n);r.get(s)?.has(t)?d.push(l(e.origin,n,"The application already gives it a value (an $eval, $msg or read in the spec, a relation, the $violations of its invariants, or a built-in expression of the SDK), so this implementation would be ignored. Remove it from the file, or declare the expression in the spec with a type and no value.")):void 0!==h?d.push(l(e.origin,n,`The file defines it on both ${h} and ${o}, so its value would depend on the order the definitions are merged in. Define it once, on the alias or on the entity type.`)):void 0!==m&&d.push(l(e.origin,n,`It is also defined in ${m}, so its value would depend on file order. Keep one definition and remove the other.`)),p.set(n,o),a.push({key:n,entityType:s,typeOrAlias:o,name:t,expression:f})}if(d.length>0)throw new o(d);return a};export const mergeExpressionModules=(e,o,i,n=new Map)=>{let r=i??t(),s=new Map,a={};for(let t of e)for(let{key:e,entityType:i,typeOrAlias:p,name:l,expression:f}of r.attempt(()=>d(t,o,s,n),[]))s.set(e,t.origin),a[i]={...a[i],[l]:{...f,origin:{name:l,typeOrAlias:p}}};return void 0===i&&r.throwIfAny(),a};

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

@@ -1,3 +1,4 @@
+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.
@@ -17,7 +18,13 @@ export interface ProjectModuleContract {
 }
 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>;
-export declare const createContractError: (origin: string, contract: ProjectModuleContract, received: unknown) => Error;
+/**
+ * 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.

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/{resolve-action-modules.d.ts → module-checks/resolve-action-modules.d.ts}

@@ -1,4 +1,4 @@
-import type { AnyActionImplementations } from '../../core/index.js';
-import { type ProjectModule } from '../../project-modules/index.js';
+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/{resolve-component-optic-modules.d.ts → module-checks/resolve-component-optic-modules.d.ts}

@@ -1,4 +1,4 @@
-import type { AnyDomainComponentOptic } from '../../core/index.js';
-import { type ProjectModule } from '../../project-modules/index.js';
+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/{resolve-expression-modules.d.ts → module-checks/resolve-expression-modules.d.ts}

@@ -1,5 +1,5 @@
-import type { AnonymousExpression } from '../../core/index.js';
-import { type ProjectModule } from '../../project-modules/index.js';
+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;
@@ -7,9 +7,8 @@ export interface ExpressionModule {
 }
 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.
+ * 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/domain-runtime/spec/module-checks/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/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/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 { ComponentType, PropsWithChildren } from 'react';
+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,10 +42,11 @@ 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>;
+        assistantFormElements: Record<string, ComponentType<never>>;
         hashes: Record<string, string>;
     }>;
     selectDataConfig: import("@salsita-ai/common/utils").Selector<SpecSelectorState, import("../../index.js").DataSpec | null>;
@@ -78,7 +78,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,10 +86,11 @@ 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>;
+        assistantFormElements: Record<string, ComponentType<never>>;
         hashes: Record<string, string>;
     };
     getDataConfig: () => import("../../index.js").DataSpec | null;