@salsita-ai/sdk 0.50.0-develop.eb204e0da4 → 0.50.0-develop.ed1806b910

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

@@ -1 +1 @@
-import{BehaviorSubject as e}from"rxjs";import{createAccessInfoActions as t,createAccessInfoSelectors as n,initializeAccessInfo as a}from"./access/index.js";import{createDomainContextActions as o,createDomainContextSelectors as i,initializeDomainContext as s}from"./domain-context/index.js";import{createDomainDataActions as r,createDomainDataSelectors as m,initializeDomainData as l}from"./domain-data/index.js";import{createDomainServicesSelectors as d}from"./domain-services/index.js";import{createEnvironmentActions as c,createEnvironmentSelectors as u,initializeEnvironment as v}from"./environment/index.js";import{createLoadedDataActions as x,createLoadedDataSelectors as p,initializeLoadedData as S}from"./loaded-data/index.js";import{createOverridesActions as f,createOverridesSelectors as g,initializeOverrides as C}from"./overrides/index.js";import{createSessionContextActions as D,createSessionContextSelectors as b,initializeSessionContext as j}from"./session-context/index.js";import{createSpecActions as w,createSpecSelectors as y,initializeSpec as E}from"./spec/index.js";import{createWebComponentActions as z,createWebComponentSelectors as R,initializeWebComponent as T}from"./web-component/index.js";export function createDomainRuntimeSlices(e){let{config:h,getSubject:A,services:I,getExtensionSystems:L}=e,O=w({setSpec:e=>{let t=A(),n=e(t.value.spec);t.next({...t.value,spec:n})}}),W=y({getState:()=>A().value}),k=d({services:I,specSelectors:W}),q=f({setOverrides:e=>{let t=A(),n=e(t.value.overrides);t.next({...t.value,overrides:n})}}),B=g({getState:()=>A().value}),F=u({getState:()=>A().value,overridesSelectors:B}),G=c({setEnvironment:e=>{let t=A(),n=e(t.value.environment);t.next({...t.value,environment:n})}}),H=x({setLoadedData:e=>{let t=A(),n=e(t.value.loadedData);t.next({...t.value,loadedData:n})}}),J=p({getState:()=>A().value}),K=r({setDomainDataState:e=>{let t=A(),n=e(t.value.domainData);t.next({...t.value,domainData:n})}}),M=m({getState:()=>A().value,overridesSelectors:B}),N=D({setSessionContextState:e=>{let t=A(),n=e(t.value.sessionContext);t.next({...t.value,sessionContext:n})}}),P=b({getState:()=>A().value,overridesSelectors:B}),Q=t({setAccessInfoState:e=>{let t=A(),n=e(t.value.access);t.next({...t.value,access:n})}}),U=n({getState:()=>A().value,overridesSelectors:B}),V=z({setWebComponentState:e=>{let t=A(),n=e(t.value.webComponent);t.next({...t.value,webComponent:n})}}),X=R({getState:()=>A().value}),Y=o({setDomainContextState:e=>{let t=A(),n=e(t.value.domainContext);t.next({...t.value,domainContext:n})}}),Z={configurator:i({applicationType:"configurator",getState:()=>A().value,actions:Y.configurator,getExtensionSystems:()=>L?.("configurator")??[],specSelectors:W,accessSelectors:U,webComponentSelectors:X,domainDataSelectors:M,sessionContextSelectors:P,domainServicesSelectors:k,environmentSelectors:F}),admin:i({applicationType:"admin",getState:()=>A().value,actions:Y.admin,getExtensionSystems:()=>L?.("admin")??[],specSelectors:W,accessSelectors:U,webComponentSelectors:X,domainDataSelectors:M,sessionContextSelectors:P,domainServicesSelectors:k,environmentSelectors:F})};return{initialize:()=>({spec:E(h),overrides:C(),environment:v(h),loadedData:S(),domainData:l(),sessionContext:j(),access:a(),webComponent:T(),domainContext:s()}),selectors:{domainServices:k,spec:W,overrides:B,environment:F,loadedData:J,domainData:M,sessionContext:P,access:U,webComponent:X,domainContext:Z},actions:{spec:O,overrides:q,environment:G,loadedData:H,domainData:K,sessionContext:N,access:Q,webComponent:V,domainContext:Y}}}export const createDomainRuntime=t=>{let{config:n,services:a,getExtensionSystems:o}=t,i=null,s=createDomainRuntimeSlices({config:n,getSubject:()=>{if(!i)throw Error("Subject not yet initialized!");return i},services:a,getExtensionSystems:o});return i=new e(s.initialize()),{...s,getState:()=>i.value,subscribe:e=>{let t=i.subscribe(()=>e());return()=>t.unsubscribe()}}};
+import{BehaviorSubject as e}from"rxjs";import{createAccessInfoActions as t,createAccessInfoSelectors as n,initializeAccessInfo as a}from"./access/index.js";import{applicationFromConfig as o}from"./application.js";import{createDomainContextActions as i,createDomainContextSelectors as s,initializeDomainContext as r}from"./domain-context/index.js";import{createDomainDataActions as m,createDomainDataSelectors as l,initializeDomainData as c}from"./domain-data/index.js";import{createDomainServicesSelectors as d}from"./domain-services/index.js";import{createEnvironmentActions as u,createEnvironmentSelectors as v,initializeEnvironment as p}from"./environment/index.js";import{createLoadedDataActions as x,createLoadedDataSelectors as S,initializeLoadedData as f}from"./loaded-data/index.js";import{createOverridesActions as g,createOverridesSelectors as C,initializeOverrides as D}from"./overrides/index.js";import{createSessionContextActions as b,createSessionContextSelectors as j,initializeSessionContext as w}from"./session-context/index.js";import{createSpecActions as y,createSpecSelectors as E}from"./spec/index.js";import{createWebComponentActions as z,createWebComponentSelectors as R,initializeWebComponent as h}from"./web-component/index.js";export function createDomainRuntimeSlices(e){let{getSubject:A,services:T,getExtensionSystems:I}=e,L=y({setSpec:e=>{let t=A(),n=e(t.value.spec);t.next({...t.value,spec:n})}}),M=E({getState:()=>A().value}),O=d({services:T,specSelectors:M}),W=g({setOverrides:e=>{let t=A(),n=e(t.value.overrides);t.next({...t.value,overrides:n})}}),k=C({getState:()=>A().value}),q=v({getState:()=>A().value,overridesSelectors:k}),B=u({setEnvironment:e=>{let t=A(),n=e(t.value.environment);t.next({...t.value,environment:n})}}),F=x({setLoadedData:e=>{let t=A(),n=e(t.value.loadedData);t.next({...t.value,loadedData:n})}}),G=S({getState:()=>A().value}),H=m({setDomainDataState:e=>{let t=A(),n=e(t.value.domainData);t.next({...t.value,domainData:n})}}),J=l({getState:()=>A().value,overridesSelectors:k}),K=b({setSessionContextState:e=>{let t=A(),n=e(t.value.sessionContext);t.next({...t.value,sessionContext:n})}}),N=j({getState:()=>A().value,overridesSelectors:k}),P=t({setAccessInfoState:e=>{let t=A(),n=e(t.value.access);t.next({...t.value,access:n})}}),Q=n({getState:()=>A().value,overridesSelectors:k}),{setLocale:U,...V}=z({setWebComponentState:e=>{let t=A(),n=e(t.value.webComponent);t.next({...t.value,webComponent:n})}}),X=R({getState:()=>A().value}),Y=i({setDomainContextState:e=>{let t=A(),n=e(t.value.domainContext);t.next({...t.value,domainContext:n})}}),Z={configurator:s({applicationType:"configurator",getState:()=>A().value,actions:Y.configurator,getExtensionSystems:()=>I?.("configurator")??[],specSelectors:M,accessSelectors:Q,webComponentSelectors:X,domainDataSelectors:J,sessionContextSelectors:N,domainServicesSelectors:O,environmentSelectors:q}),admin:s({applicationType:"admin",getState:()=>A().value,actions:Y.admin,getExtensionSystems:()=>I?.("admin")??[],specSelectors:M,accessSelectors:Q,webComponentSelectors:X,domainDataSelectors:J,sessionContextSelectors:N,domainServicesSelectors:O,environmentSelectors:q})};return{initialize:()=>{let t=e.application??o(e.config);return{spec:t.spec,overrides:D(),environment:p(t.environment),loadedData:f(),domainData:c(),sessionContext:w(),access:a(),webComponent:h(),domainContext:r()}},selectors:{domainServices:O,spec:M,overrides:k,environment:q,loadedData:G,domainData:J,sessionContext:N,access:Q,webComponent:X,domainContext:Z},actions:{spec:L,overrides:W,environment:B,loadedData:F,domainData:H,sessionContext:K,access:P,webComponent:V,domainContext:Y},hostMirrorActions:{setLocale:U}}}export const createDomainRuntime=t=>{let n=null,a=createDomainRuntimeSlices({...t,getSubject:()=>{if(!n)throw Error("Subject not yet initialized!");return n}});return n=new e(a.initialize()),{...a,getState:()=>n.value,subscribe:e=>{let t=n.subscribe(()=>e());return()=>t.unsubscribe()}}};

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

@@ -2,4 +2,4 @@ import type { AnyApplicationConfig } from '../../application/index.js';
 import type { ApplicationEnvironmentConfig } from './types.js';
 export declare const GOD_MODE_SESSION_STORAGE_KEY = "salsita-god-mode";
 export declare const isNotRegisteredDeploymentId: (deploymentId: string) => boolean;
-export declare const initializeEnvironment: (config: AnyApplicationConfig) => ApplicationEnvironmentConfig;
+export declare const initializeEnvironment: (config: Pick<AnyApplicationConfig, 'defaultEnvs' | 'deploymentId' | 'isDev' | 'persistence'>) => ApplicationEnvironmentConfig;

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

@@ -18,7 +18,7 @@ export interface ApplicationEnvironmentConfig {
     /**
      * Whether the maintenance "god mode" is enabled — it unlocks destructive admin tooling
      * (eg. the maintenance menu). Seeded from session storage during mount and toggled at
-     * runtime via the `window.__salsita.setGodMode` global (see `registerGodModeGlobal`).
+     * runtime via the `window.__salsita.setGodMode` global, per runtime (see `SetGodMode`).
      */
     readonly godMode: boolean;
     /**

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,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 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';

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,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";let a=(e,a)=>{let t={};for(let n of e)t[n.name]=a?.[n.name]??n.name;return t},t=(e,a)=>{let t={},n=0;for(let i of e)if("entity"===i.type||"layout"===i.type)t[i.name]=a?.[i.name]??i.name;else{let e=`icon:${n}`;t[e]=a?.[e]??`${e}:${i.elements.length}`,n+=1}return t};export const initializeSpec=n=>{let i=n.adminDomain.presets[0];if(!i)throw Error("Cannot register application spec because admin preset is required.");return{version:n.version,dataConfig:n.dataSpec??null,chunks:n.chunks,publishedDataHash:n.publishedDataHash,initialPublishedData:n.initialPublishedData,canCreate:n.features?.acl?.canCreate??Object.values(e),enableAdminRelease:n.features?.enableAdminRelease??!1,textLanguages:n.domain.textLanguages??n.adminDomain.textLanguages??["en"],baseResourcesUrl:n.resources?.baseResourcesUrl??n.defaultEnvs?.resourcesUrl??"",configurator:{factory:n.domain.domainFactory,presets:n.domain.presets,aliasMap:n.domain.domainFactory.context.aliasMap,entityReflections:n.domain.domainFactory.context.entityReflections,$entityReflections:n.domain.domainFactory.context.$entityReflections,expressions:n.domain.domainFactory.context.expressions,allowedRootEntityTypes:n.domain.domainFactory.context.allowedRootEntityTypes,migrate:n.domain.domainFactory.context.migrate,componentOptics:n.domain.componentOptics,createTransformers:n.createTransformers??(()=>[]),navigationStates:n.navigation?.navigationStates??[],viewStates:n.navigation?.viewStates??[],toolStates:n.navigation?.toolStates??[],exportStates:n.navigation?.exportStates??[],handlers:n.handlers,handlerHashes:a(n.handlers),elements:n.elements,elementHashes:t(n.elements),appLoader:n.ui?.appLoader??"universal",preview:n.ui?.preview??"auto",alwaysExpand:n.ui?.alwaysExpand??!1,theme:n.ui?.theme??{},assistant:n.assistant??null,deploymentQueryDisabled:n.resources?.deploymentQueryDisabled??!1,prefetchTextureUrls:n.resources?.prefetchTextureUrls??[],modelVersion:n.domain.domainFactory.modelVersion},admin:{factory:n.adminDomain.domainFactory,modelVersion:n.adminDomain.domainFactory.modelVersion,aliasMap:n.adminDomain.domainFactory.context.aliasMap,entityReflections:n.adminDomain.domainFactory.context.entityReflections,$entityReflections:n.adminDomain.domainFactory.context.$entityReflections,expressions:n.adminDomain.domainFactory.context.expressions,allowedRootEntityTypes:n.adminDomain.domainFactory.context.allowedRootEntityTypes,migrate:n.adminDomain.domainFactory.context.migrate,preset:i,componentOptics:n.adminDomain.componentOptics,navigationStates:n.adminNavigation?.navigationStates??[],viewStates:n.adminNavigation?.viewStates??[],handlers:n.handlers,handlerHashes:a(n.handlers),elements:n.elements,elementHashes:t(n.elements)}}};
+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/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,125 @@
+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>;
+};
+/**
+ * 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;
+}
+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;
+/** 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>;
+}> = {
+    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 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/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,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/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,14 @@
+import type { AnonymousExpression } from '../../../core/index.js';
+import type { ProjectModule } from './project-modules.js';
+/** The expressions of one validated expression file, keyed by entity type or alias, then by expression name. */
+export interface ExpressionModule {
+    readonly origin: string;
+    readonly expressions: Readonly<Record<string, Readonly<Record<string, AnyAnonymousExpression>>>>;
+}
+type AnyAnonymousExpression = AnonymousExpression<any, any, any, any, any, any, unknown>;
+/**
+ * Validates the `src/expressions/` files with the checks of {@link mergeExpressionModules}, throws
+ * everything they find as one `ImplementationErrors`, and returns each file on its own, unmerged.
+ */
+export declare const resolveExpressionModules: (modules: readonly ProjectModule[], aliasMap: Readonly<Record<string, readonly string[]>>) => readonly ExpressionModule[];
+export {};