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

package/dist/domain/spec/modules/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/spec/modules/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/spec/modules/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/spec/modules/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/spec/modules/index.d.ts

@@ -0,0 +1,9 @@
+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 { findAssistantFormElementErrors } from './find-assistant-form-element-errors.js';
+export { type PhoenixHandlerDefinition, type SystemPhoenixHandlerDefinition, type PhoenixHandlerRegistration, type SystemPhoenixHandlerRegistration, type SystemPhoenixAsyncHandlerDefinition, type SystemPhoenixAsyncHandlerRegistration, type HandlerRegistration, type CreatePhoenixHandler, createPhoenixHandler, createSystemPhoenixHandler, createSystemPhoenixAsyncHandler, resolveHandlerModule, resolveHandlerModules, } from './handler-registration.js';
+export { type ProjectModule, type ProjectModuleContract, SHARED_FOLDER_HINT, createContractError, isRecord, } 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 { type AnyInvariant, resolveInvariantModules } from './resolve-invariant-modules.js';

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

@@ -0,0 +1 @@
+export{createPhoenixLayoutElement,createPhoenixEntityElement,createCustomPhoenixLayoutElement,createCustomPhoenixEntityElement,createAssistantFormElement,resolveElementModule,resolveElementModules}from"./element-registration.js";export{findAssistantFormElementErrors}from"./find-assistant-form-element-errors.js";export{createPhoenixHandler,createSystemPhoenixHandler,createSystemPhoenixAsyncHandler,resolveHandlerModule,resolveHandlerModules}from"./handler-registration.js";export{SHARED_FOLDER_HINT,createContractError,isRecord}from"./project-modules.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{resolveInvariantModules}from"./resolve-invariant-modules.js";

package/dist/domain/spec/modules/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/spec/modules/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/spec/modules/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/spec/modules/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/spec/modules/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/spec/modules/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/spec/modules/resolve-expression-modules.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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