@salsita-ai/sdk 0.50.0-develop.ca72986c39 → 0.50.0-develop.cba048b0d7

package/dist/application-spec/parse-application-files/spec/components/components.d.ts

@@ -1,10 +1,9 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { ComponentEntry, Components as ComponentsData } from '#package/domain';
 import type { ParseContext } from '../../../core/index.js';
 import type { Aliases } from '../model/index.js';
-import type { ComponentEntry } from './component-entry.js';
 import type { UserComponents } from './user-components.js';
-/** Final merged components for a domain, including SDK/spec-derived entries. */
-export type Components = Branded<'Components', readonly ComponentEntry[]>;
+/** The merged components of a domain; see {@link ComponentsData | Components} in `domain`. */
+export type Components = ComponentsData;
 interface ComponentsProps {
     readonly userComponents: UserComponents;
     readonly generatedComponents: readonly ComponentEntry[];

package/dist/application-spec/parse-application-files/spec/components/filter-criterion-types.d.ts

@@ -0,0 +1,13 @@
+import type { EnhancedJsonSchemaType, FILTER_CRITERION_KEYS } from '../../../core/index.js';
+/**
+ * The type each filter criterion takes, as an SDK schema that states exactly the TypeScript type of
+ * `ComponentSystemFilterProps`: the modes, roles and viewports are their literal unions and the
+ * entity ids are `DomainEntityId`s. `FILTER_CRITERION_SCHEMAS`, which infers the type of an
+ * expression read in a criterion, is wider where the JSON schema of the filter is.
+ */
+export declare const FILTER_CRITERION_TYPE_SCHEMAS: Readonly<Record<(typeof FILTER_CRITERION_KEYS)[number], EnhancedJsonSchemaType>>;
+/**
+ * The type a root filter (`$filter: { $read: x }`) takes, `ComponentSystemFilter`: a boolean, or an
+ * object of the criteria other than the export ones.
+ */
+export declare const ROOT_FILTER_TYPE_SCHEMA: EnhancedJsonSchemaType;

package/dist/application-spec/parse-application-files/spec/components/filter-criterion-types.js

@@ -0,0 +1 @@
+import{SessionRole as e}from"@salsita-ai/contracts/api";import{VIEWPORTS as t}from"#package/domain";let r={type:"string",tsType:"DomainEntityId"},a={anyOf:[r,{type:"object",properties:{id:r},required:["id"]}]},i={anyOf:[{type:"array",items:a},a]},s={type:"array",items:{type:"string"}},o={type:"boolean"};export const FILTER_CRITERION_TYPE_SCHEMAS={navigationStates:s,viewStates:s,toolStates:s,exportStates:s,modes:{type:"array",items:{enum:["owner","read","finalize"]}},roles:{type:"array",items:{enum:Object.values(e)}},selectedEntityIds:i,hoveredEntityIds:i,draggedEntityIds:i,exportedEntityIds:i,active:o,fullscreen:o,debug:o,viewports:{type:"array",items:{enum:[...t]}}};let n=new Set(["exportedEntityIds","exportStates"]),p=Object.fromEntries(Object.entries(FILTER_CRITERION_TYPE_SCHEMAS).filter(([e])=>!n.has(e)));export const ROOT_FILTER_TYPE_SCHEMA={anyOf:[o,{type:"object",properties:p}]};

package/dist/application-spec/parse-application-files/spec/components/index.d.ts

@@ -1,7 +1,6 @@
+export { type ComponentEntry, type ComponentImplementation, type ComponentPropTarget, type CompositeImplementation, type RootReadImplementation, type SdkFactory, type SdkFactoryParam, isComponentPropTarget, } from '#package/domain';
 export * from './bindings/index.js';
-export type * from './component-entry.js';
 export * from './component-filter.js';
-export * from './component-prop-target.js';
 export * from './components.js';
 export * from './sdk-component-entry.js';
 export * from './user-component-entry.js';

package/dist/application-spec/parse-application-files/spec/components/index.js

@@ -1 +1 @@
-export*from"./bindings/index.js";export*from"./component-filter.js";export*from"./component-prop-target.js";export*from"./components.js";export*from"./sdk-component-entry.js";export*from"./user-component-entry.js";export*from"./user-components.js";
+export{isComponentPropTarget}from"#package/domain";export*from"./bindings/index.js";export*from"./component-filter.js";export*from"./components.js";export*from"./sdk-component-entry.js";export*from"./user-component-entry.js";export*from"./user-components.js";

package/dist/application-spec/parse-application-files/spec/components/sdk-component-entry.d.ts

@@ -1,5 +1,5 @@
+import type { ComponentEntry, SdkFactory } from '#package/domain';
 import type { Aliases, EntityOrAliasName, InstanceName } from '../model/index.js';
-import type { ComponentEntry, SdkFactory } from './component-entry.js';
 import type { ComponentFilters } from './component-filter.js';
 interface SdkComponentImplementation {
     readonly kind: 'sdk';

package/dist/application-spec/parse-application-files/spec/components/static-entity-id.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaPathSegment } from '../../../core/index.js';
+import { type ValueType } from '../common/index.js';
+import { type ComponentReadBindingContext } from './bindings/index.js';
+/**
+ * Reports a value written in a component prop or filter where the component expects an entity id
+ * (`DomainEntityId`). The schema checks the id's form, but the id's type is branded, so the type
+ * check of generated code rejects any string written in YAML: the id has to be read from the
+ * domain state with `$read` or `$bind`.
+ *
+ * @param value - A primitive value written in the spec
+ * @param path - The prop path or filter criterion the value is written at
+ * @param expected - The type the component expects there
+ */
+export declare const checkStaticEntityId: (value: string | number | boolean | null, path: readonly SchemaPathSegment[], expected: ValueType, context: Omit<ComponentReadBindingContext, 'resolvedShape'>) => void;

package/dist/application-spec/parse-application-files/spec/components/static-entity-id.js

@@ -0,0 +1 @@
+import{DiagnosticCode as i,diagnosticMessages as r}from"../../../errors/index.js";import{formatValueType as o,isAssignableValueType as n,literalValueType as t}from"../common/index.js";import{componentParseContext as e,componentPath as m}from"./bindings/index.js";export const checkStaticEntityId=(s,d,T,c)=>{!T.some(i=>"string"===i.kind&&void 0!==i.named&&void 0===i.named.acceptsLiteral)||n(t(s),T)||e(c.parsingContext,c,d).error(i.COMPONENT_STATIC_ENTITY_ID,r.COMPONENT_STATIC_ENTITY_ID(m(c,d),JSON.stringify(s),o(T)))};

package/dist/application-spec/parse-application-files/spec/components/user-component-entry.d.ts

@@ -1,7 +1,8 @@
+import type { ComponentEntry, SpecExpression } from '#package/domain';
 import { type EnhancedJsonObject, type ParseContext } from '../../../core/index.js';
-import type { Expression } from '../expressions/expression.js';
+import { type ValueTypeResolution } from '../common/index.js';
+import type { ExpressionRead } from '../expressions/expression-read.js';
 import type { EntityOrAliasName, InstanceName, ResolvedShape } from '../model/index.js';
-import type { ComponentEntry } from './component-entry.js';
 interface UserComponentProps {
     readonly typeOrAlias: EntityOrAliasName;
     readonly instanceName: InstanceName;
@@ -11,10 +12,14 @@ interface UserComponentProps {
 interface UserComponentContext {
     readonly resolvedShape: ResolvedShape;
     readonly parsingContext: ParseContext;
+    /** Resolves the refs of field schemas and the entity types of a name, for the type checks. */
+    readonly typeResolution: Omit<ValueTypeResolution, 'author' | 'definitions'>;
 }
 export interface UserComponentResult {
     readonly entry: ComponentEntry;
-    readonly inferredExpressions: readonly Expression[];
+    readonly inferredExpressions: readonly SpecExpression[];
+    /** Every `$read` of an expression in the instance, with the type expected where it is read. */
+    readonly expressionReads: readonly ExpressionRead[];
 }
 /**
  * Creates a user-declared ComponentEntry from raw YAML props.

package/dist/application-spec/parse-application-files/spec/components/user-component-entry.js

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{componentsByName as t}from"#package/domain";import{FILTER_KEY as n,READ_MARKER_KEY as r,isEvalMarker as i,isImportRefShaped as a,isRawBindMarker as o,isRawDataRefMarker as m,isRawEvalWriteMarker as p,isRawReadMarker as s,isRawReadWriteMarker as l,navigateSchema as d}from"../../../core/index.js";import{DiagnosticCode as f,diagnosticMessages as c}from"../../../errors/index.js";import{MemoEvalPlan as y}from"../expressions/memo-eval-plan.js";import{ComponentReadBinding as g,ComponentWriteBinding as u,isExpressionReadTarget as N}from"./bindings/index.js";import{ComponentFilters as $,FILTER_CRITERION_SCHEMAS as O}from"./component-filter.js";let S=e=>e.reduce((e,t)=>"number"==typeof t?`${e}[${t}]`:0===e.length?t:`${e}.${t}`,""),T=(e,t,n,r)=>{if(null==e||"object"!=typeof e)return e;if(s(e))return n.addReadBinding(e.$read,t),{$target:e.$read};if(m(e))return void r.parsingContext.at(String(r.entityKey),r.componentName,String(r.instanceName),...t.map(String)).error(f.COMPONENT_DATA_REF_UNSUPPORTED,c.COMPONENT_DATA_REF_UNSUPPORTED(String(r.entityKey),r.componentName,String(r.instanceName),S(t),e.$read,e.$data));if(o(e))return n.addReadBinding(e.$bind,t),{$target:e.$bind};if(i(e))return e;if(a(e))return void r.parsingContext.at(String(r.entityKey),r.componentName,String(r.instanceName),...t.map(String)).error(f.COMPONENT_IMPORT_REF_UNSUPPORTED,c.COMPONENT_IMPORT_REF_UNSUPPORTED(String(r.entityKey),r.componentName,String(r.instanceName),S(t),e.$importRef.module,e.$importRef.member));if(Array.isArray(e))return e.map((e,i)=>T(e,[...t,i],n,r)).filter(e=>void 0!==e);let p={};for(let[i,a]of Object.entries(e)){let e=T(a,[...t,i],n,r);void 0!==e&&(p[i]=e)}return p},A=(t,n,r)=>{for(let i of t.items)if("gradual"===i.kind){for(let[t,a]of Object.entries(i))if("kind"!==t&&a?.kind==="dynamic"&&a.target&&N(a.target)){let i=O[t];i&&r.push(e({entityKey:n,name:a.target,schema:i,implementation:{kind:"user"}}))}}};export const UserComponentEntry=(i,a)=>{let{implementation:m,inferredExpressions:s}=((i,a)=>{let m=t.get(i.componentName),s=m?.schema,O=new Set,S=[],P=[],E=[],R={entityKey:i.typeOrAlias,componentName:i.componentName,instanceName:i.instanceName,resolvedShape:a.resolvedShape,parsingContext:a.parsingContext},_={entityKey:i.typeOrAlias,componentName:i.componentName,instanceName:i.instanceName,resolvedShape:a.resolvedShape,parsingContext:a.parsingContext},h=(t,n)=>{if(!O.has(t)&&(O.add(t),S.push(g(t,R)),N(t)&&s)){let r=((t,n,r,i)=>{let{schema:a,lastDeclaredType:o,pathSinceDeclaredType:m}=d(r,n),p=n=>e({entityKey:i,name:t,schema:n,implementation:{kind:"user"}});if(void 0!==o){let e=m.map(e=>"number"==typeof e?"[number]":`['${e}']`).join("");return p({...a,tsType:`${o.tsType}${e}`,import:o.import})}if(Object.keys(a).length>0)return p(a)})(t,n,s,i.typeOrAlias);r&&E.push(r)}},b={addReadBinding:h},v=$(i.rawProps[n]),C=`${String(i.typeOrAlias)}.${String(i.instanceName)}`;if((e=>{if(!(r in e)||"string"!=typeof e[r])return!1;for(let t of Object.keys(e))if(t!==r&&t!==n)return!1;return!0})(i.rawProps)){let e=i.rawProps[r];return h(e,[]),A(v,i.typeOrAlias,E),{implementation:{kind:"userBound",filters:v,plan:y({$target:e},C),implementation:{kind:"rootRead",readBinding:S[0]}},inferredExpressions:E}}let k={};for(let[e,t]of Object.entries(i.rawProps)){if(e===n)continue;if(o(t)){P.push(u(e,t.$bind,_)),h(t.$bind,[e]),k[e]={$target:t.$bind};continue}if(l(t)){h(t.$read,[e]),P.push(u(e,t.$write,_)),k[e]={$target:t.$read};continue}if(p(t)){P.push(u(e,t.$write,_)),k[e]={$eval:t.$eval};continue}let r=T(t,[e],b,R);void 0!==r&&(k[e]=r)}let j=new Map;for(let e of P){let t=j.get(e.entityField);t?a.parsingContext.error(f.WRITE_BINDING_DUPLICATE_TARGET,c.WRITE_BINDING_DUPLICATE_TARGET(String(i.typeOrAlias),i.componentName,String(i.instanceName),e.entityField,t,e.propKey)):j.set(e.entityField,e.propKey)}return A(v,i.typeOrAlias,E),{implementation:{kind:"userBound",filters:v,plan:y(k,C),implementation:{kind:"composite",resolvedProps:k,readBindings:S,writeBindings:P}},inferredExpressions:E}})(i,a);return{entry:e({typeOrAlias:i.typeOrAlias,instanceName:i.instanceName,isAlias:"alias"===a.resolvedShape.kind,componentName:i.componentName,implementation:m}),inferredExpressions:s}};
+import{Branded as e}from"@salsita-ai/common/utils";import{componentsByName as t}from"#package/domain";import{FILTER_CRITERION_KEYS as n,FILTER_KEY as r,FILTER_OR_KEY as i,READ_MARKER_KEY as o,isEnhancedJsonObject as a,isEvalMarker as p,isImportRefShaped as m,isRawBindMarker as s,isRawDataRefMarker as d,isRawEvalWriteMarker as l,isRawReadMarker as c,isRawReadWriteMarker as f,navigateSchema as y}from"../../../core/index.js";import{DiagnosticCode as u,diagnosticMessages as g}from"../../../errors/index.js";import{ValueType as N,valueTypeAt as $}from"../common/index.js";import{MemoEvalPlan as O}from"../expressions/index.js";import{ComponentReadBinding as S,ComponentWriteBinding as A,checkReadBindingType as k,componentPath as R,formatComponentPropPath as T,isExpressionReadTarget as b}from"./bindings/index.js";import{ComponentFilters as h,FILTER_CRITERION_SCHEMAS as P}from"./component-filter.js";import{componentStateType as E}from"./component-state-type.js";import{FILTER_CRITERION_TYPE_SCHEMAS as j,ROOT_FILTER_TYPE_SCHEMA as x}from"./filter-criterion-types.js";import{checkStaticEntityId as _}from"./static-entity-id.js";let v=(e,t,n,r)=>{if(null==e||"object"!=typeof e)return void 0!==e&&n.checkStaticValue(e,t),e;if(c(e))return n.addReadBinding(e.$read,t,"$read"),{$target:e.$read};if(d(e))return void r.parsingContext.at(String(r.entityKey),r.componentName,String(r.instanceName),...t.map(String)).error(u.COMPONENT_DATA_REF_UNSUPPORTED,g.COMPONENT_DATA_REF_UNSUPPORTED(String(r.entityKey),r.componentName,String(r.instanceName),T(t),e.$read,e.$data));if(s(e))return n.addReadBinding(e.$bind,t,"$bind"),{$target:e.$bind};if(p(e))return e;if(m(e))return void r.parsingContext.at(String(r.entityKey),r.componentName,String(r.instanceName),...t.map(String)).error(u.COMPONENT_IMPORT_REF_UNSUPPORTED,g.COMPONENT_IMPORT_REF_UNSUPPORTED(String(r.entityKey),r.componentName,String(r.instanceName),T(t),e.$importRef.module,e.$importRef.member));if(Array.isArray(e))return e.map((e,i)=>v(e,[...t,i],n,r)).filter(e=>void 0!==e);let i={};for(let[o,a]of Object.entries(e)){let e=v(a,[...t,o],n,r);void 0!==e&&(i[o]=e)}return i},C=(t,n,r)=>{for(let i of t.items)if("gradual"===i.kind){for(let[t,o]of Object.entries(i))if("kind"!==t&&o?.kind==="dynamic"&&o.target&&b(o.target)){let i=P[t];i&&r.push(e({entityKey:n,name:o.target,schema:i,implementation:{kind:"user"}}))}}},U=(e,t,n,r)=>{if("string"==typeof e||"number"==typeof e||"boolean"==typeof e||null===e)return void _(e,t,n,r);if("object"==typeof e)for(let[i,o]of Object.entries(e)){let a=Array.isArray(e)?Number(i):i;U(o,[...t,a],$(n,[a]),r)}};export const UserComponentEntry=(p,m)=>{let{implementation:d,inferredExpressions:c,expressionReads:T}=((p,m)=>{let d,c=t.get(p.componentName),T=c?.schema,P=new Set,w=[],D=[],I=[],K={entityKey:p.typeOrAlias,componentName:p.componentName,instanceName:p.instanceName,resolvedShape:m.resolvedShape,parsingContext:m.parsingContext},B={entityKey:p.typeOrAlias,componentName:p.componentName,instanceName:p.instanceName,resolvedShape:m.resolvedShape,parsingContext:m.parsingContext},F={...K,typeResolution:m.typeResolution},M=e=>T?$(d??=E(T,m.typeResolution),e):[{kind:"unknown"}],G=[],V=e=>{b(e.target)?G.push({entityKey:p.typeOrAlias,name:e.target,expected:e.expected,location:R(K,e.path)}):k(e,F)},L=(t,n,r)=>{if(V({marker:r,target:t,path:n,expected:M(n)}),!P.has(t)&&(P.add(t),w.push(S(t,K)),b(t)&&T)){let r=((t,n,r,i)=>{let{schema:o,lastDeclaredType:a,pathSinceDeclaredType:p}=y(r,n),m=n=>e({entityKey:i,name:t,schema:n,implementation:{kind:"user"}});if(void 0!==a){let e=p.map(e=>"number"==typeof e?"[number]":`['${e}']`).join("");return m({...o,tsType:`${a.tsType}${e}`,import:a.import})}if(Object.keys(o).length>0)return m(o)})(t,n,T,p.typeOrAlias);r&&I.push(r)}},W={addReadBinding:L,checkStaticValue:(e,t)=>_(e,t,M(t),K)},q=h(p.rawProps[r]);((e,t,o,p)=>{let m=e=>N(e,{...o.typeResolution,author:"sdk"}),s=void 0!==e&&a(e)&&Array.isArray(e[i]);for(let[e,a]of t.items.entries()){let t=s?[r,i,e]:[r];if("root"===a.kind){p({marker:"$read",target:a.target,path:t,expected:m(x)});continue}for(let e of n){let n=a[e],r=[...t,e],i=m(j[e]);n?.kind==="dynamic"?p({marker:"$read",target:n.target,path:r,expected:i}):n?.kind==="static"&&U(n.value,r,i,o)}}})(p.rawProps[r],q,F,V);let z=`${String(p.typeOrAlias)}.${String(p.instanceName)}`;if((e=>{if(!(o in e)||"string"!=typeof e[o])return!1;for(let t of Object.keys(e))if(t!==o&&t!==r)return!1;return!0})(p.rawProps)){let e=p.rawProps[o];return L(e,[],"$read"),C(q,p.typeOrAlias,I),{implementation:{kind:"userBound",filters:q,plan:O({$target:e},z),implementation:{kind:"rootRead",readBinding:w[0]}},inferredExpressions:I,expressionReads:G}}let H={};for(let[e,t]of Object.entries(p.rawProps)){if(e===r)continue;if(s(t)){D.push(A(e,t.$bind,B)),L(t.$bind,[e],"$bind"),H[e]={$target:t.$bind};continue}if(f(t)){L(t.$read,[e],"$read"),D.push(A(e,t.$write,B)),H[e]={$target:t.$read};continue}if(l(t)){D.push(A(e,t.$write,B)),H[e]={$eval:t.$eval};continue}let n=v(t,[e],W,K);void 0!==n&&(H[e]=n)}let J=new Map;for(let e of D){let t=J.get(e.entityField);t?m.parsingContext.error(u.WRITE_BINDING_DUPLICATE_TARGET,g.WRITE_BINDING_DUPLICATE_TARGET(String(p.typeOrAlias),p.componentName,String(p.instanceName),e.entityField,t,e.propKey)):J.set(e.entityField,e.propKey)}return C(q,p.typeOrAlias,I),{implementation:{kind:"userBound",filters:q,plan:O(H,z),implementation:{kind:"composite",resolvedProps:H,readBindings:w,writeBindings:D}},inferredExpressions:I,expressionReads:G}})(p,m);return{entry:e({typeOrAlias:p.typeOrAlias,instanceName:p.instanceName,isAlias:"alias"===m.resolvedShape.kind,componentName:p.componentName,implementation:d}),inferredExpressions:c,expressionReads:T}};

package/dist/application-spec/parse-application-files/spec/components/user-components.d.ts

@@ -1,19 +1,21 @@
 import { Branded } from '@salsita-ai/common/utils';
-import type { ParseContext } from '../../../core/index.js';
+import type { ComponentEntry, SpecExpression } from '#package/domain';
+import type { ParseContext, PhoenixDefinitions } from '../../../core/index.js';
 import type { MergedComponents } from '../../merge/index.js';
-import type { Expression } from '../expressions/expression.js';
-import type { ResolvedShapes } from '../model/index.js';
-import type { ComponentEntry } from './component-entry.js';
+import type { ExpressionRead } from '../expressions/expression-read.js';
+import type { ModelVersion } from '../model/index.js';
 /** User-declared component entries, flattened from the nested merge map. */
 export type UserComponents = Branded<'UserComponents', readonly ComponentEntry[]>;
 interface UserComponentsContext {
-    readonly allNames: ReadonlySet<string>;
-    readonly resolvedShapes: ResolvedShapes;
+    readonly latestModel: ModelVersion;
+    readonly phxDefinitions: PhoenixDefinitions;
     readonly parsingContext: ParseContext;
 }
 interface UserComponentsResult {
     readonly components: UserComponents;
-    readonly expressions: readonly Expression[];
+    readonly expressions: readonly SpecExpression[];
+    /** Every `$read` of an expression in a component, with the type expected where it is read. */
+    readonly expressionReads: readonly ExpressionRead[];
 }
 /**
  * Flattens the nested merge map into a flat list of ComponentEntry objects.

package/dist/application-spec/parse-application-files/spec/components/user-components.js

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as r,diagnosticMessages as t}from"../../../errors/index.js";import{InstanceName as o,getResolvedShape as n}from"../model/index.js";import{UserComponentEntry as s}from"./user-component-entry.js";export const UserComponents=(i,p)=>{let{allNames:m,parsingContext:f}=p,l=[],N=[],O=[...m];for(let[e,c]of Object.entries(i)){if(!m.has(e)){f.error(r.COMPONENT_UNKNOWN_ENTITY_KEY,t.COMPONENT_UNKNOWN_ENTITY_KEY(e,O));continue}let i=n(p.resolvedShapes,e);for(let[r,t]of Object.entries(c))for(let[n,p]of Object.entries(t)){let t=o(n,e,r,f);if(!t)continue;let m=s({typeOrAlias:e,instanceName:t,componentName:r,rawProps:p},{resolvedShape:i,parsingContext:f});l.push(m.entry),N.push(...m.inferredExpressions)}}return{components:e(l),expressions:N}};
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as o,diagnosticMessages as r}from"../../../errors/index.js";import{InstanceName as t,ModelTypeResolution as s,getResolvedShape as n}from"../model/index.js";import{UserComponentEntry as i}from"./user-component-entry.js";export const UserComponents=(p,m)=>{let{latestModel:f,parsingContext:l}=m,N=f.allNames,a=s(f,m.phxDefinitions),O=[],c=[],u=[],x=[...N];for(let[e,s]of Object.entries(p)){if(!N.has(e)){l.error(o.COMPONENT_UNKNOWN_ENTITY_KEY,r.COMPONENT_UNKNOWN_ENTITY_KEY(e,x));continue}let p=n(f.resolvedShapes,e);for(let[o,r]of Object.entries(s))for(let[s,n]of Object.entries(r)){let r=t(s,e,o,l);if(!r)continue;let m=i({typeOrAlias:e,instanceName:r,componentName:o,rawProps:n},{resolvedShape:p,parsingContext:l,typeResolution:a});O.push(m.entry),c.push(...m.inferredExpressions),u.push(...m.expressionReads)}}return{components:e(O),expressions:c,expressionReads:u}};

package/dist/application-spec/parse-application-files/spec/expressions/expression-read-types.d.ts

@@ -0,0 +1,24 @@
+import type { SpecExpression } from '#package/domain';
+import type { ParseContext } from '../../../core/index.js';
+import type { EntityOrAliasName, ExpressionName, ModelTypeResolution } from '../model/index.js';
+import type { ExpressionRead } from './expression-read.js';
+/** Where an expression is declared: the spec section and the entity or alias under it. */
+export interface ExpressionLocation {
+    readonly section: string;
+    readonly entityKey: EntityOrAliasName;
+}
+interface ExpressionReadTypesInput {
+    readonly userExpressions: readonly SpecExpression[];
+    readonly expressionReads: readonly ExpressionRead[];
+    /** Finds where a read expression is declared, which is where a conflict is reported. */
+    readonly locateDeclaration: (entityKey: EntityOrAliasName, name: ExpressionName) => ExpressionLocation;
+}
+/**
+ * Reports an expression whose declared type and the types its `$read`s expect have no value in
+ * common, or whose `$read`s expect types that have none: generated code types the expression by
+ * the intersection of them all, which no value can be, so the implementation cannot type-check.
+ * A type given as `tsType` text is not read, and never reported. Relation and invariant
+ * expressions state their types only as `tsType`, so only a conflict among their reads is reported.
+ */
+export declare const checkExpressionReadTypes: ({ userExpressions, expressionReads, locateDeclaration }: ExpressionReadTypesInput, typeResolution: ModelTypeResolution, ctx: ParseContext) => void;
+export {};

package/dist/application-spec/parse-application-files/spec/expressions/expression-read-types.js

@@ -0,0 +1 @@
+import{DiagnosticCode as e,diagnosticMessages as t}from"../../../errors/index.js";import{ValueType as r,formatValueType as n,intersectValueTypes as o}from"../common/index.js";export const checkExpressionReadTypes=({userExpressions:i,expressionReads:a,locateDeclaration:c},d,l)=>{let s=new Map,m=(e,t)=>{let r=`${String(e)}\0${String(t)}`,n=s.get(r);return n||(n={entityKey:e,name:t,reads:[]},s.set(r,n)),n};for(let e of i)e.declaredSchema&&(m(e.entityKey,e.name).declared=r(e.declaredSchema,{...d,author:"project"}));for(let e of a)m(e.entityKey,e.name).reads.push(e);for(let{entityKey:r,name:i,declared:a,reads:d}of s.values()){let[s,...m]=[...a?[a]:[],...d.map(e=>e.expected)];if(!s||m.reduce(o,s).length>0)continue;let p=c(r,i);l.at(p.section,String(p.entityKey),String(i)).error(e.EXPRESSION_READ_TYPE_CONFLICT,t.EXPRESSION_READ_TYPE_CONFLICT(String(p.entityKey),String(i),a&&n(a),d.map(e=>`${n(e.expected)} at "${e.location}"`)))}};

package/dist/application-spec/parse-application-files/spec/expressions/expression-read.d.ts

@@ -0,0 +1,13 @@
+import type { ValueType } from '../common/index.js';
+import type { EntityOrAliasName, ExpressionName } from '../model/index.js';
+/**
+ * A `$read` of an expression in a component, with the type the component expects where the value
+ * goes: a prop, the whole state, a filter criterion or the whole filter.
+ */
+export interface ExpressionRead {
+    readonly entityKey: EntityOrAliasName;
+    readonly name: ExpressionName;
+    readonly expected: ValueType;
+    /** The place of the read, such as `Hole.detail.main.title`. */
+    readonly location: string;
+}

package/dist/application-spec/parse-application-files/spec/expressions/expression-value-type.d.ts

@@ -0,0 +1,9 @@
+import { type EnhancedJsonValue } from '../../../core/index.js';
+import { ValueType } from '../common/index.js';
+import type { ModelTypeResolution } from '../model/index.js';
+/**
+ * The type generated code gives the inline value of an expression that declares a schema: a `$msg`
+ * compiles to a lingui `MessageDescriptor`. The only other such value is an `$eval`, which is code
+ * whose type is not read; constants never declare a schema.
+ */
+export declare const expressionValueType: (value: EnhancedJsonValue, resolution: ModelTypeResolution) => ValueType;

package/dist/application-spec/parse-application-files/spec/expressions/expression-value-type.js

@@ -0,0 +1 @@
+import{isMsgMarker as e}from"../../../core/index.js";import{ValueType as o}from"../common/index.js";let r=[{kind:"unknown"}];export const expressionValueType=(n,s)=>e(n)?o({$ref:"phx:MessageDescriptor"},{...s,author:"sdk"}):r;

package/dist/application-spec/parse-application-files/spec/expressions/expressions.d.ts

@@ -1,42 +1,24 @@
-import { Branded } from '@salsita-ai/common/utils';
-import { type EvalExpressionParser, type ParseContext } from '../../../core/index.js';
+import type { Expressions as ExpressionsData, SpecExpression } from '#package/domain';
+import { type EvalExpressionParser, type ParseContext, type PhoenixDefinitions } from '../../../core/index.js';
 import type { MergedExpressions } from '../../merge/index.js';
-import type { Aliases, EntityOrAliasName, EntityTypeName, ExpressionName, ModelVersion } from '../model/index.js';
-import type { Expression } from './expression.js';
-import type { MemoEvalPlan } from './memo-eval-plan.js';
-export type { Expression, ExpressionImplementation } from './expression.js';
-/**
- * Resolved expressions for a single entity type. Holds the ordered list of
- * shape source keys (entity itself + aliases it belongs to) — codegen appends
- * `"Expressions"` to each key to reference the typed expression group.
- */
-export type EntityExpressions = Branded<'EntityExpressions', {
-    /** Entity/alias keys whose expressions this entity inherits. Codegen appends "Expressions" suffix. */
-    readonly shapeGroups: readonly EntityOrAliasName[];
-}>;
-/**
- * Final merged expressions for a domain — user-declared + inferred.
- * The internal `expressions` map groups by entity/alias for codegen/runtime lookups.
- * `entityExpressions` provides per-entity alias expansion.
- * `constants` projects the self-free `constants:` values, grouped like `expressions`;
- * codegen passes them to the enhanced entity/alias reflections so they are readable at
- * module level (`phx.domain.enhancedModel.$Wall.$maxWidth`). A constant whose plan uses
- * `self` needs an instance, so it stays an ordinary value expression and is absent here.
- */
-export type Expressions = Branded<'Expressions', {
-    readonly expressions: ReadonlyMap<EntityOrAliasName, ReadonlyMap<ExpressionName, Expression>>;
-    readonly entityExpressions: ReadonlyMap<EntityTypeName, EntityExpressions>;
-    readonly constants: ReadonlyMap<EntityOrAliasName, ReadonlyMap<ExpressionName, MemoEvalPlan>>;
-}>;
+import { type Aliases, type EntityTypeName, type ModelVersion } from '../model/index.js';
+import type { ExpressionRead } from './expression-read.js';
+export type { EntityExpressions } from '#package/domain';
+export type { ExpressionImplementation, SpecExpression as Expression } from '#package/domain';
+/** The merged expressions of a domain; see {@link ExpressionsData | Expressions} in `domain`. */
+export type Expressions = ExpressionsData;
 interface ExpressionsProps {
     readonly rawExpressions: MergedExpressions;
-    readonly inferredExpressions: readonly Expression[];
+    readonly inferredExpressions: readonly SpecExpression[];
+    /** The `$read`s of expressions in components, whose expected types the expressions must share. */
+    readonly expressionReads: readonly ExpressionRead[];
 }
 interface ExpressionsContext {
     readonly latestModel: ModelVersion;
     readonly aliases: Aliases;
     readonly entityTypes: readonly EntityTypeName[];
     readonly evalExpressionParser: EvalExpressionParser;
+    readonly phxDefinitions: PhoenixDefinitions;
     readonly parsingContext: ParseContext;
 }
 /**

package/dist/application-spec/parse-application-files/spec/expressions/expressions.js

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{intersectSchemas as t,isSdkExpressionImplementation as n}from"../../../core/index.js";import{DiagnosticCode as i,diagnosticMessages as o}from"../../../errors/index.js";import{UserExpressions as r}from"./user-expressions.js";let s=(e,t)=>{let n=e.get(t.entityKey);n||(n=new Map,e.set(t.entityKey,n)),n.set(t.name,t)},a=(n,i)=>{let o=n.get(i.entityKey);o||(o=new Map,n.set(i.entityKey,o));let r=o.get(i.name);r?o.set(i.name,e({...r,schema:t(r.schema,i.schema),...r.declaredSchema||!i.declaredSchema?{}:{declaredSchema:i.declaredSchema}})):o.set(i.name,i)},l=e=>"relation"===e.implementation.kind?"relations":"violations"===e.implementation.kind?"invariants":"expressions";export const Expressions=(t,m)=>{let{rawExpressions:f,inferredExpressions:p}=t,{latestModel:c,aliases:d,entityTypes:y,evalExpressionParser:u,parsingContext:g}=m,S=r(f,{latestModel:c,evalExpressionParser:u,parsingContext:g});if(void 0===S)return;let h=new Map;for(let e of S)s(h,e);for(let e of p)a(h,e);let w=((e,t)=>{let i=new Map,o=e=>{let t=i.get(e.entityKey);t||(t=new Set,i.set(e.entityKey,t)),t.add(e.name)};for(let t of e)o(t);for(let e of t)n(e.implementation)&&o(e);return i})(S,p),x=new Map;for(let e of S){let{implementation:t}=e;if("value"!==t.kind||!t.constant||t.plan.usesSelf)continue;let n=x.get(e.entityKey);n||(n=new Map,x.set(e.entityKey,n)),n.set(e.name,t.plan)}let K=new Map;for(let t of y){let n=[],r=new Map,s=e=>{let s=h.get(e);if(!s||0===s.size)return;n.push(e);let a=w.get(e);for(let[n,m]of s){if(!a?.has(n))continue;let s=r.get(n);if(s){g.at(l(m),e,n).error(i.DUPLICATE_EXPRESSION,o.DUPLICATE_EXPRESSION(t,n,s,e));continue}r.set(n,e)}};for(let[e,n]of d)n.includes(t)&&s(e);s(t),K.set(t,e({shapeGroups:n}))}return e({expressions:h,entityExpressions:K,constants:x})};
+import{Branded as e}from"@salsita-ai/common/utils";import{intersectSchemas as t,isSdkExpressionImplementation as n}from"../../../core/index.js";import{DiagnosticCode as o,diagnosticMessages as i}from"../../../errors/index.js";import{ModelTypeResolution as r}from"../model/index.js";import{checkExpressionReadTypes as s}from"./expression-read-types.js";import{UserExpressions as a}from"./user-expressions.js";let l=(e,t)=>{let n=e.get(t.entityKey);n||(n=new Map,e.set(t.entityKey,n)),n.set(t.name,t)},m=(n,o)=>{let i=n.get(o.entityKey);i||(i=new Map,n.set(o.entityKey,i));let r=i.get(o.name);r?i.set(o.name,e({...r,schema:t(r.schema,o.schema),...r.declaredSchema||!o.declaredSchema?{}:{declaredSchema:o.declaredSchema}})):i.set(o.name,o)},f=e=>"relation"===e.implementation.kind?"relations":"violations"===e.implementation.kind?"invariants":"expressions";export const Expressions=(t,p)=>{let{rawExpressions:c,inferredExpressions:d,expressionReads:y}=t,{latestModel:u,aliases:g,entityTypes:x,evalExpressionParser:h,parsingContext:S}=p,w=r(u,p.phxDefinitions),K=a(c,{latestModel:u,evalExpressionParser:h,typeResolution:w,parsingContext:S});if(void 0===K)return;let M=new Map;for(let e of K)l(M,e);for(let e of d)m(M,e);let E=((e,t)=>{let o=new Map,i=e=>{let t=o.get(e.entityKey);t||(t=new Set,o.set(e.entityKey,t)),t.add(e.name)};for(let t of e)i(t);for(let e of t)n(e.implementation)&&i(e);return o})(K,d);s({userExpressions:K,expressionReads:y,locateDeclaration:(e,t)=>{for(let n of[e,...[...g].filter(([,t])=>t.some(t=>t===e)).map(([e])=>e)]){let e=E.get(n)?.has(t)?M.get(n)?.get(t):void 0;if(e)return{section:f(e),entityKey:n}}return{section:"expressions",entityKey:e}}},w,S);let j=new Map;for(let e of K){let{implementation:t}=e;if("value"!==t.kind||!t.constant||t.plan.usesSelf)continue;let n=j.get(e.entityKey);n||(n=new Map,j.set(e.entityKey,n)),n.set(e.name,t.plan)}let v=new Map;for(let t of x){let n=[],r=new Map,s=e=>{let s=M.get(e);if(!s||0===s.size)return;n.push(e);let a=E.get(e);for(let[n,l]of s){if(!a?.has(n))continue;let s=r.get(n);if(s){S.at(f(l),e,n).error(o.DUPLICATE_EXPRESSION,i.DUPLICATE_EXPRESSION(t,n,s,e));continue}r.set(n,e)}};for(let[e,n]of g)n.includes(t)&&s(e);s(t),v.set(t,e({shapeGroups:n}))}return e({expressions:M,entityExpressions:v,constants:j})};

package/dist/application-spec/parse-application-files/spec/expressions/index.d.ts

@@ -1,4 +1,3 @@
-export type * from './expression.js';
 export * from './expressions.js';
 export * from './memo-eval-plan.js';
 export * from './user-expressions.js';

package/dist/application-spec/parse-application-files/spec/expressions/memo-eval-plan.d.ts

@@ -1,74 +1,7 @@
-import { Branded } from '@salsita-ai/common/utils';
-import { type EvalMarker, type MsgMarker } from '../../../core/index.js';
-import { type ComponentPropTarget } from '../components/component-prop-target.js';
-export type MemoEvalLiteral = string | number | boolean | null;
-/**
- * A single entry in the memoEval deps array.
- *
- * - `'eval'` — a `$eval` code fragment. At deps-build time the fragment is
- *   evaluated under `self` (`new Function('self', …)` at runtime, spliced
- *   verbatim under `self => [...]` in codegen). `label` annotates codegen
- *   output (e.g. `/* $eval: Entity.instance *\/`).
- * - `'read'` — a read binding that resolves to `self[target]` at deps-build
- *   time.
- */
-export type MemoEvalDep = Branded<'MemoEvalDep', {
-    readonly kind: 'eval';
-    readonly code: string;
-    readonly label: string;
-} | {
-    readonly kind: 'read';
-    readonly target: string;
-}>;
-/**
- * Tree of values with slots referencing entries in the plan's `deps` array.
- * Generated by codegen as a JS literal with params spliced in, or by runtime
- * by walking and substituting from the `deps`-materialised values array.
- */
-export type MemoEvalTemplate = Branded<'MemoEvalTemplate', {
-    readonly kind: 'literal';
-    readonly value: MemoEvalLiteral;
-} | {
-    readonly kind: 'msg';
-    readonly marker: MsgMarker;
-} | {
-    readonly kind: 'slot';
-    readonly depIndex: number;
-} | {
-    readonly kind: 'array';
-    readonly items: readonly MemoEvalTemplate[];
-} | {
-    readonly kind: 'object';
-    readonly entries: ReadonlyArray<readonly [string, MemoEvalTemplate]>;
-}>;
-export type MemoEvalPlanInput = MemoEvalLiteral | EvalMarker | MsgMarker | ComponentPropTarget | MemoEvalPlanInputArray | MemoEvalPlanInputObject;
-export interface MemoEvalPlanInputArray extends ReadonlyArray<MemoEvalPlanInput> {
-}
-export interface MemoEvalPlanInputObject {
-    readonly [key: string]: MemoEvalPlanInput;
-}
-/**
- * Normalized plan for producing a memoized reader from a tree containing
- * `$eval`, `$target`, `$msg`, and literal nodes. Built once during spec
- * parsing; codegen + runtime both generate from the same plan so their outputs
- * cannot drift.
- *
- * - `deps` — ordered evaluation slots in first-seen walk order. Each slot
- *   dedupes (`$eval` by trimmed code, `$target` by name) so a repeated marker
- *   shares one dep.
- * - `template` — rebuilt value tree with `slot { depIndex }` nodes in place
- *   of the consumed markers.
- * - `usesSelf` — true when deps collection must receive `self`, either
- *   because a read dep exists or because an eval dep references `self`.
- *
- * When `deps` is empty the tree is fully static — generators cache
- * non-primitive templates and keep primitive literals as bare thunks.
- */
-export type MemoEvalPlan = Branded<'MemoEvalPlan', {
-    readonly deps: readonly MemoEvalDep[];
-    readonly template: MemoEvalTemplate;
-    readonly usesSelf: boolean;
-}>;
+import { type MemoEvalPlan as MemoEvalPlanData, type MemoEvalPlanInput } from '#package/domain';
+export type { MemoEvalLiteral, MemoEvalDep, MemoEvalTemplate, MemoEvalPlanInput, MemoEvalPlanInputArray, MemoEvalPlanInputObject, } from '#package/domain';
+/** The plan a memoized reader is built from; see {@link MemoEvalPlanData | MemoEvalPlan} in `domain`. */
+export type MemoEvalPlan = MemoEvalPlanData;
 /**
  * Builds a {@link MemoEvalPlan} from a value tree that may contain `$eval`,
  * `$target`, and `$msg` markers. Called during spec parsing from

package/dist/application-spec/parse-application-files/spec/expressions/memo-eval-plan.js

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{isEvalMarker as r,isMsgMarker as t}from"../../../core/index.js";import{evalCodeUsesSelf as n}from"../../../enhanced-json/eval-code-uses-self.js";import{isComponentPropTarget as o}from"../components/component-prop-target.js";let l=(e,r)=>0===r.length?e:`${e}.${r.join(".")}`,i=(n,a,d,u)=>{if(void 0===n)throw Error(`MemoEvalPlan: found undefined at ${l(d,u)}, undefined cannot be generated, remove the property or use null.`);if(r(n)){let r=((r,t,n)=>{let o=t.trim();for(let e=0;e<r.length;e++){let t=r[e];if("eval"===t.kind&&t.code===o)return e}return r.push(e({kind:"eval",code:o,label:n})),r.length-1})(a,n.$eval,d);return e({kind:"slot",depIndex:r})}if(o(n)){let r=((r,t)=>{for(let e=0;e<r.length;e++){let n=r[e];if("read"===n.kind&&n.target===t)return e}return r.push(e({kind:"read",target:t})),r.length-1})(a,n.$target);return e({kind:"slot",depIndex:r})}if(t(n))return e({kind:"msg",marker:n});if(null===n||"object"!=typeof n)return e({kind:"literal",value:n});if(Array.isArray(n))return e({kind:"array",items:n.map((e,r)=>i(e,a,d,[...u,String(r)]))});if("object"!=typeof n||null===n)throw Error(`MemoEvalPlan: found unsupported value at ${l(d,u)}, remove it or use null.`);let s=[];for(let e in n){let r=n[e];s.push([e,i(r,a,d,[...u,e])])}return e({kind:"object",entries:s})};export const MemoEvalPlan=(r,t)=>{let o=[],l=i(r,o,t,[]),a=o.some(e=>"read"===e.kind||n(e.code));return e({deps:o,template:l,usesSelf:a})};
+import{Branded as e}from"@salsita-ai/common/utils";import{isComponentPropTarget as r}from"#package/domain";import{isEvalMarker as t,isMsgMarker as n}from"../../../core/index.js";import{evalCodeUsesSelf as o}from"../../../enhanced-json/eval-code-uses-self.js";let l=(e,r)=>0===r.length?e:`${e}.${r.join(".")}`,i=(o,a,d,u)=>{if(void 0===o)throw Error(`MemoEvalPlan: found undefined at ${l(d,u)}, undefined cannot be generated, remove the property or use null.`);if(t(o)){let r=((r,t,n)=>{let o=t.trim();for(let e=0;e<r.length;e++){let t=r[e];if("eval"===t.kind&&t.code===o)return e}return r.push(e({kind:"eval",code:o,label:n})),r.length-1})(a,o.$eval,d);return e({kind:"slot",depIndex:r})}if(r(o)){let r=((r,t)=>{for(let e=0;e<r.length;e++){let n=r[e];if("read"===n.kind&&n.target===t)return e}return r.push(e({kind:"read",target:t})),r.length-1})(a,o.$target);return e({kind:"slot",depIndex:r})}if(n(o))return e({kind:"msg",marker:o});if(null===o||"object"!=typeof o)return e({kind:"literal",value:o});if(Array.isArray(o))return e({kind:"array",items:o.map((e,r)=>i(e,a,d,[...u,String(r)]))});if("object"!=typeof o||null===o)throw Error(`MemoEvalPlan: found unsupported value at ${l(d,u)}, remove it or use null.`);let f=[];for(let e in o){let r=o[e];f.push([e,i(r,a,d,[...u,e])])}return e({kind:"object",entries:f})};export const MemoEvalPlan=(r,t)=>{let n=[],l=i(r,n,t,[]),a=n.some(e=>"read"===e.kind||o(e.code));return e({deps:n,template:l,usesSelf:a})};

package/dist/application-spec/parse-application-files/spec/expressions/user-expressions.d.ts

@@ -1,7 +1,7 @@
+import type { SpecExpression } from '#package/domain';
 import { type EvalExpressionParser, type ParseContext } from '../../../core/index.js';
 import type { MergedExpressions } from '../../merge/index.js';
-import type { ModelVersion } from '../model/index.js';
-import type { Expression } from './expression.js';
+import type { ModelTypeResolution, ModelVersion } from '../model/index.js';
 /**
  * Validates user-declared expressions from merged YAML.
  *
@@ -15,7 +15,9 @@ import type { Expression } from './expression.js';
 interface UserExpressionsContext {
     readonly latestModel: ModelVersion;
     readonly evalExpressionParser: EvalExpressionParser;
+    /** Resolves the refs of the declared schemas, for checking an inline value against its schema. */
+    readonly typeResolution: ModelTypeResolution;
     readonly parsingContext: ParseContext;
 }
-export declare const UserExpressions: (rawExpressions: MergedExpressions, context: UserExpressionsContext) => readonly Expression[] | undefined;
+export declare const UserExpressions: (rawExpressions: MergedExpressions, context: UserExpressionsContext) => readonly SpecExpression[] | undefined;
 export {};

package/dist/application-spec/parse-application-files/spec/expressions/user-expressions.js

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{schemaFromValue as t}from"../../../enhanced-json/index.js";import{DiagnosticCode as r,diagnosticMessages as n}from"../../../errors/index.js";import{ExpressionName as s}from"../model/index.js";import{MemoEvalPlan as a}from"./memo-eval-plan.js";let o=(e,r,n,s)=>{if("user"===e.kind)return{schema:e.schema,implementation:{kind:"user"}};let o=a(e.value,r),i={kind:"value",constant:e.constant,value:e.value,plan:o};if(Object.keys(e.schema).length>0)return{schema:e.schema,implementation:i};let m=t(e.value,n,s);if(void 0!==m)return{schema:m,implementation:i}};export const UserExpressions=(t,a)=>{let{latestModel:i,evalExpressionParser:m,parsingContext:l}=a,{allNames:c}=i,h=[...c].map(String),f=[];for(let[a,i]of Object.entries(t)){c.has(a)||l.error(r.EXPRESSION_UNKNOWN_ENTITY_KEY,n.EXPRESSION_UNKNOWN_ENTITY_KEY(a,h));let t=e(a);for(let[r,n]of Object.entries(i)){let i=l.at(a),c=s(r,i);if(!c)continue;let h=o(n,`${a}.${r}`,i.at(r),m);h&&f.push(e({entityKey:t,name:c,schema:h.schema,declaredSchema:h.schema,implementation:h.implementation}))}}if(!l.hasErrors)return f};
+import{Branded as e}from"@salsita-ai/common/utils";import{schemaFromValue as r}from"../../../enhanced-json/index.js";import{DiagnosticCode as t,diagnosticMessages as o}from"../../../errors/index.js";import{ValueType as s,formatValueType as m,isAssignableValueType as a}from"../common/index.js";import{ExpressionName as n}from"../model/index.js";import{expressionValueType as i}from"./expression-value-type.js";import{MemoEvalPlan as l}from"./memo-eval-plan.js";let c=(e,n,c,p,E)=>{if("user"===e.kind)return{schema:e.schema,implementation:{kind:"user"}};let h=l(e.value,n),u={kind:"value",constant:e.constant,value:e.value,plan:h};if(Object.keys(e.schema).length>0){var f,d;let r,l;return f=e.value,d=e.schema,r=i(f,E),a(r,l=s(d,{...E,author:"project"}))||c.error(t.EXPRESSION_VALUE_TYPE_MISMATCH,o.EXPRESSION_VALUE_TYPE_MISMATCH(n,m(r),m(l))),{schema:e.schema,implementation:u}}let N=r(e.value,c,p);if(void 0!==N)return{schema:N,implementation:u}};export const UserExpressions=(r,s)=>{let{latestModel:m,evalExpressionParser:a,typeResolution:i,parsingContext:l}=s,{allNames:p}=m,E=[...p].map(String),h=[];for(let[s,m]of Object.entries(r)){p.has(s)||l.error(t.EXPRESSION_UNKNOWN_ENTITY_KEY,o.EXPRESSION_UNKNOWN_ENTITY_KEY(s,E));let r=e(s);for(let[t,o]of Object.entries(m)){let m=l.at(s),p=n(t,m);if(!p)continue;let E=c(o,`${s}.${t}`,m.at(t),a,i);E&&h.push(e({entityKey:r,name:p,schema:E.schema,declaredSchema:E.schema,implementation:E.implementation}))}}if(!l.hasErrors)return h};

package/dist/application-spec/parse-application-files/spec/invariants/invariant.d.ts

@@ -1,23 +1,7 @@
-import { Branded } from '@salsita-ai/common/utils';
-import type { MsgMarker, ParseContext } from '../../../core/index.js';
+import type { SpecInvariant } from '#package/domain';
+import type { ParseContext } from '../../../core/index.js';
 import type { RawInvariantEntry } from '../../raw-spec/index.js';
-import { InvariantName, ViolationTypeName } from '../model/index.js';
-export type InvariantSeverity = 'fatal' | 'fixable' | 'warning' | 'notice';
-/** A YAML invariant whose violation metadata is fully declared in the application spec. */
-export type StaticInvariant = Branded<'StaticInvariant', {
-    readonly kind: 'static';
-    readonly name: InvariantName;
-    readonly violationType: ViolationTypeName;
-    readonly severity: InvariantSeverity;
-    readonly message: string | MsgMarker;
-    readonly controlViolationPriority?: number;
-}>;
-/** A YAML invariant whose implementation may return any of the declared violation types. */
-export type DynamicInvariant = Branded<'DynamicInvariant', {
-    readonly kind: 'dynamic';
-    readonly name: InvariantName;
-    readonly violationTypes: readonly ViolationTypeName[];
-}>;
-/** A validated static or dynamic invariant declaration. */
-export type Invariant = StaticInvariant | DynamicInvariant;
+export type { InvariantSeverity, StaticInvariant, DynamicInvariant } from '#package/domain';
+/** A validated static or dynamic invariant declaration; see {@link SpecInvariant} in `domain`. */
+export type Invariant = SpecInvariant;
 export declare const Invariant: (rawName: string, entry: RawInvariantEntry, ctx: ParseContext) => Invariant | undefined;

package/dist/application-spec/parse-application-files/spec/invariants/invariants.d.ts

@@ -1,19 +1,9 @@
-import { Branded } from '@salsita-ai/common/utils';
-import type { ParseContext } from '../../../core/index.js';
+import type { Invariants as InvariantsData } from '#package/domain';
+import type { ParseContext, PhoenixDefinitions } from '../../../core/index.js';
 import type { MergedComponents, MergedExpressions, MergedInvariants, MergedRelations } from '../../merge/index.js';
-import type { ComponentEntry } from '../components/index.js';
-import type { Expression } from '../expressions/index.js';
-import type { EntityOrAliasName, InvariantName, ModelVersion } from '../model/index.js';
-import { Invariant } from './invariant.js';
-/**
- * Validated invariants and the expressions/components they contribute to the application spec.
- * Entries retain their entity-or-alias declaration keys while artifacts expand to concrete entity types.
- */
-export type Invariants = Branded<'Invariants', {
-    readonly entries: Readonly<Record<EntityOrAliasName, Readonly<Record<InvariantName, Invariant>>>>;
-    readonly expressions: readonly Expression[];
-    readonly components: readonly ComponentEntry[];
-}>;
+import type { ModelVersion } from '../model/index.js';
+/** The validated invariants of a domain; see {@link InvariantsData | Invariants} in `domain`. */
+export type Invariants = InvariantsData;
 interface InvariantsProps {
     readonly rawInvariants: MergedInvariants;
     readonly rawExpressions: MergedExpressions;
@@ -22,5 +12,5 @@ interface InvariantsProps {
 }
 /** Explicit empty invariants aggregate for consumers that do not declare invariants. */
 export declare const EmptyInvariants: () => Invariants;
-export declare const Invariants: (props: InvariantsProps, latestModel: ModelVersion, ctx: ParseContext) => Invariants;
+export declare const Invariants: (props: InvariantsProps, latestModel: ModelVersion, phxDefinitions: PhoenixDefinitions, ctx: ParseContext) => Invariants;
 export {};

package/dist/application-spec/parse-application-files/spec/invariants/invariants.js

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as t,diagnosticMessages as o}from"../../../errors/index.js";import{UserComponentEntry as r}from"../components/index.js";import{ExpressionName as n,InstanceName as i,getResolvedShape as a}from"../model/index.js";import{Invariant as s}from"./invariant.js";let l="violations",p="$violations",N=(e,t)=>t.get(e)??[e],m=e=>"dynamic"===e.kind?e.violationTypes:[e.violationType],O=(t,o,r)=>{if(!r)return;let n=[...o.violationTypes].map(e=>`'${String(e)}'`).join(" | "),i={tsType:`ReadonlyArray<Violation<${n}>>`,import:[{module:"@salsita-ai/sdk/domain",member:"Violation"}]};return e({entityKey:t,name:r,schema:i,declaredSchema:i,implementation:{kind:"violations",params:[{entityType:String(t),invariants:o.declaredGroups}]}})},I=(e,t,o)=>{let n=i("default",String(e),l,o);if(n)return r({typeOrAlias:e,instanceName:n,componentName:l,rawProps:{violations:{$read:p}}},{resolvedShape:a(t.resolvedShapes,e),parsingContext:o}).entry};export const EmptyInvariants=()=>e({entries:{},expressions:[],components:[]});export const Invariants=(r,i,a)=>{let{rawInvariants:f,rawExpressions:T,rawRelations:d,rawComponents:A}=r,{allNames:c,aliases:S}=i,y=[...c].map(String),_={},v=new Map;for(let[e,r]of Object.entries(f)){let n=a.at(e);if(!c.has(e)){n.error(t.INVARIANT_UNKNOWN_ENTITY_KEY,o.INVARIANT_UNKNOWN_ENTITY_KEY(e,y));continue}let i={};for(let[e,t]of Object.entries(r)){let o=s(e,t,n.at(e));o&&(i[String(o.name)]=o)}_[String(e)]=i;let l=Object.values(i);if(0!==l.length)for(let t of N(e,S)){let o=v.get(t);for(let r of(o||(o={violationTypes:new Set,declaredGroups:[]},v.set(t,o)),o.declaredGroups.push({typeOrAlias:e,invariants:l}),l))for(let e of m(r))o.violationTypes.add(e)}}let u=[],g=[],h=n(p,a);for(let[e,t]of v){let o=O(e,t,h),r=I(e,i,a);o&&u.push(o),r&&g.push(r)}for(let[e,r]of Object.entries(A))Object.hasOwn(r,l)&&a.at("components",e,l).error(t.INVARIANT_MANUAL_VIOLATIONS_COMPONENT,o.INVARIANT_MANUAL_VIOLATIONS_COMPONENT(e));return((e,r)=>{let{invariantEntityTypes:n,rawExpressions:i,rawRelations:a,aliases:s}=e,l=e=>{let t=s.get(e);return t?t.some(e=>n.has(String(e))):n.has(e)},N=(e,n)=>{for(let[i,a]of Object.entries(e))Object.hasOwn(a,p)&&l(i)&&r.at(n,i,p).error(t.INVARIANT_VIOLATIONS_EXPRESSION_CONFLICT,o.INVARIANT_VIOLATIONS_EXPRESSION_CONFLICT(i,n))};N(i,"expressions"),N(a,"relations")})({invariantEntityTypes:new Set([...v.keys()].map(String)),rawExpressions:T,rawRelations:d,aliases:S},a),e({entries:_,expressions:u,components:g})};
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as t,diagnosticMessages as o}from"../../../errors/index.js";import{UserComponentEntry as r}from"../components/index.js";import{ExpressionName as n,InstanceName as i,ModelTypeResolution as a,getResolvedShape as s}from"../model/index.js";import{Invariant as l}from"./invariant.js";let p="violations",N="$violations",m=(e,t)=>t.get(e)??[e],O=e=>"dynamic"===e.kind?e.violationTypes:[e.violationType],I=(t,o,r)=>{if(!r)return;let n=[...o.violationTypes].map(e=>`'${String(e)}'`).join(" | "),i={tsType:`ReadonlyArray<Violation<${n}>>`,import:[{module:"@salsita-ai/sdk/domain",member:"Violation"}]};return e({entityKey:t,name:r,schema:i,declaredSchema:i,implementation:{kind:"violations",params:[{entityType:String(t),invariants:o.declaredGroups}]}})},f=(e,t,o,n)=>{let l=i("default",String(e),p,n);if(l)return r({typeOrAlias:e,instanceName:l,componentName:p,rawProps:{violations:{$read:N}}},{resolvedShape:s(t.resolvedShapes,e),parsingContext:n,typeResolution:a(t,o)}).entry};export const EmptyInvariants=()=>e({entries:{},expressions:[],components:[]});export const Invariants=(r,i,a,s)=>{let{rawInvariants:T,rawExpressions:d,rawRelations:A,rawComponents:c}=r,{allNames:y,aliases:S}=i,_=[...y].map(String),u={},v=new Map;for(let[e,r]of Object.entries(T)){let n=s.at(e);if(!y.has(e)){n.error(t.INVARIANT_UNKNOWN_ENTITY_KEY,o.INVARIANT_UNKNOWN_ENTITY_KEY(e,_));continue}let i={};for(let[e,t]of Object.entries(r)){let o=l(e,t,n.at(e));o&&(i[String(o.name)]=o)}u[String(e)]=i;let a=Object.values(i);if(0!==a.length)for(let t of m(e,S)){let o=v.get(t);for(let r of(o||(o={violationTypes:new Set,declaredGroups:[]},v.set(t,o)),o.declaredGroups.push({typeOrAlias:e,invariants:a}),a))for(let e of O(r))o.violationTypes.add(e)}}let g=[],h=[],j=n(N,s);for(let[e,t]of v){let o=I(e,t,j),r=f(e,i,a,s);o&&g.push(o),r&&h.push(r)}for(let[e,r]of Object.entries(c))Object.hasOwn(r,p)&&s.at("components",e,p).error(t.INVARIANT_MANUAL_VIOLATIONS_COMPONENT,o.INVARIANT_MANUAL_VIOLATIONS_COMPONENT(e));return((e,r)=>{let{invariantEntityTypes:n,rawExpressions:i,rawRelations:a,aliases:s}=e,l=e=>{let t=s.get(e);return t?t.some(e=>n.has(String(e))):n.has(e)},p=(e,n)=>{for(let[i,a]of Object.entries(e))Object.hasOwn(a,N)&&l(i)&&r.at(n,i,N).error(t.INVARIANT_VIOLATIONS_EXPRESSION_CONFLICT,o.INVARIANT_VIOLATIONS_EXPRESSION_CONFLICT(i,n))};p(i,"expressions"),p(a,"relations")})({invariantEntityTypes:new Set([...v.keys()].map(String)),rawExpressions:d,rawRelations:A,aliases:S},s),e({entries:u,expressions:g,components:h})};

package/dist/application-spec/parse-application-files/spec/model/aliases.d.ts

@@ -1,16 +1,10 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { SpecAliases } from '#package/domain';
 import type { ParseContext } from '../../../core/index.js';
 import type { MergedModelVersion } from '../../merge/index.js';
 import type { EntityTypes } from './entity-types.js';
 import { AliasName } from './names/alias-name.js';
-import type { EntityTypeName } from './names/entity-type-name.js';
-/**
- * Flattened alias map — each alias name maps to the concrete entity types it resolves to.
- * Nested aliases (e.g. AllLegs → [SteelLegs, LegsOak] where SteelLegs is itself an alias)
- * are fully resolved to leaf entity types. Includes the synthetic "AnyDomainEntity" alias
- * that maps to all entity types in the version.
- */
-export type Aliases = Branded<'Aliases', ReadonlyMap<AliasName, readonly EntityTypeName[]>>;
+/** The flattened alias map of a model version; see {@link SpecAliases} in `domain`. */
+export type Aliases = SpecAliases;
 /** Well-known alias name for root entity types — required in every model version. */
 export declare const ROOT_ENTITY_ALIAS: AliasName;
 export declare const Aliases: (merged: MergedModelVersion, entityTypes: EntityTypes, ctx: ParseContext) => Aliases | undefined;

package/dist/application-spec/parse-application-files/spec/model/common-types.d.ts

@@ -1,18 +1,10 @@
-import { Branded } from '@salsita-ai/common/utils';
-import { type EnhancedJsonSchemaType, type JsonSchema, type ParseContext, type PhoenixDefinitions } from '../../../core/index.js';
+import type { CommonType as CommonTypeData, CommonTypes as CommonTypesData } from '#package/domain';
+import { type ParseContext, type PhoenixDefinitions } from '../../../core/index.js';
 import type { MergedModelVersion } from '../../merge/index.js';
-/** A single common type definition with both enhanced schema (for type inference) and resolved runtime schema. */
-export type CommonType = Branded<'CommonType', {
-    readonly name: string;
-    readonly schema: EnhancedJsonSchemaType;
-    readonly runtimeSchema: JsonSchema;
-}>;
-/**
- * Branded map of common type name to CommonType.
- * Entries are in topo-sorted order (dependencies before dependents),
- * so iterating the map yields types in valid emission order.
- */
-export type CommonTypes = Branded<'CommonTypes', ReadonlyMap<string, CommonType>>;
+/** A common type with its enhanced and runtime schemas; see {@link CommonTypeData | CommonType} in `domain`. */
+export type CommonType = CommonTypeData;
+/** The common types of a model version by name; see {@link CommonTypesData | CommonTypes} in `domain`. */
+export type CommonTypes = CommonTypesData;
 /**
  * Validates, topo-sorts, and resolves commonType entries from the merged model version.
  *