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

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.
  *

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

@@ -1,32 +1,12 @@
-import { Branded } from '@salsita-ai/common/utils';
-import { type EnhancedJsonValue, type ParseContext } from '../../../core/index.js';
+import type { Defaults as DefaultsData } from '#package/domain';
+import { type ParseContext } from '../../../core/index.js';
 import type { MergedDefaults } from '../../merge/index.js';
 import type { ModelVersion } from './model-version.js';
-import type { EntityTypeName } from './names/entity-type-name.js';
-import { ShapePropertyName } from './names/shape-property-name.js';
+export type { DefaultEntries } from '#package/domain';
 /**
- * A map of shape property names to their default values inside a single entity block.
- * Raw YAML values — markers intact — keyed by a validated {@link ShapePropertyName}.
- * Codegen emits these as-is via `stringifyEnhancedJsonValue`; runtime consumers
- * (`RecipeFactoryBuilder`) consume the generated `createRecipe` factory.
- */
-export type DefaultEntries = Readonly<Record<ShapePropertyName, EnhancedJsonValue>>;
-/**
- * Validated defaults map — source keys confirmed to exist in `model.latest`,
- * property names confirmed to exist on the (effective) shape of the entity
- * or on every alias member's effective shape, values type-checked against the
- * relaxed entity shape (all properties optional). Alias-keyed defaults are
- * flattened here to concrete entity entries so downstream codegen only serialises
- * a runtime-ready per-entity map.
- *
- * Values are raw `EnhancedJsonValue` so codegen can emit them via
- * `stringifyEnhancedJsonValue` with `$msg` markers preserved.
+ * The validated defaults of a domain by entity type; see {@link DefaultsData | Defaults} in `domain`.
  *
- * **Deprecated feature.** The whole defaults surface is retained for legacy parity.
- * New specs should express initial values as `$data` entries. When the merged map is
- * non-empty, the factory emits a `DEFAULTS_DEPRECATED` warning.
+ * **Deprecated feature.** New specs express initial values as `$data` entries.
  */
-export type Defaults = Branded<'Defaults', {
-    readonly entries: Readonly<Record<EntityTypeName, DefaultEntries>>;
-}>;
+export type Defaults = DefaultsData;
 export declare const Defaults: (merged: MergedDefaults, latestModel: ModelVersion, ctx: ParseContext) => Defaults | undefined;

package/dist/application-spec/parse-application-files/spec/model/defaults.js

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{CONSTANT_CAPS as t,resolveEnhancedJsonValue as r}from"../../../core/index.js";import{DiagnosticCode as o,diagnosticMessages as i}from"../../../errors/index.js";import{ShapePropertyName as n}from"./names/shape-property-name.js";let s=(e,t,r,n,s)=>{for(let l of r.validatePartialShape(t).errors){let t=l.instancePath?l.instancePath:"(root)",r=l.instancePath.split("/").filter(Boolean)[0]??"";n.error(o.DEFAULTS_SCHEMA_VIOLATION,i[o.DEFAULTS_SCHEMA_VIOLATION](e,r,t,l.message,s))}};export const Defaults=(l,a,f)=>{let E=a.allNames,T=[...E].map(String),N=new Map,S=new Map;for(let e of a.entitySchemas)N.set(e.entityType,new Set(Object.keys(e.shapeProperties))),S.set(e.entityType,e);let _={};for(let[e,O]of Object.entries(l)){let l=f.at(e);if(!E.has(e)){f.error(o.DEFAULTS_UNKNOWN_ENTITY_KEY,i[o.DEFAULTS_UNKNOWN_ENTITY_KEY](e,T));continue}let p=a.aliases.get(e),c=void 0!==p,g={};for(let[t,r]of Object.entries(O)){let s=n(t,l);if(s){if(c){let t=[];for(let e of p){let r=N.get(e);r&&r.has(s)||t.push(String(e))}if(t.length>0){let r=p[0],n=r?[...N.get(r)??[]]:[];f.error(o.DEFAULTS_UNKNOWN_PROPERTY,i[o.DEFAULTS_UNKNOWN_PROPERTY](e,s,n,t));continue}}else{let t=N.get(e);if(!t||!t.has(s)){let r=t?[...t]:[];f.error(o.DEFAULTS_UNKNOWN_PROPERTY,i[o.DEFAULTS_UNKNOWN_PROPERTY](e,s,r));continue}}g[s]=r}}if(0===Object.keys(g).length)continue;let m=r(g,void 0,t,l);if(void 0!==m){if(c)for(let t of p){let r=S.get(t);r&&s(e,m,r,l,String(t))}else{let t=S.get(e);t&&s(e,m,t,l)}for(let t of p??[e])_[String(t)]={..._[String(t)],...g}}}if(Object.keys(l).length>0&&f.warning(o.DEFAULTS_DEPRECATED,i[o.DEFAULTS_DEPRECATED]()),!f.hasErrors)return e({entries:_})};
+import{Branded as e}from"@salsita-ai/common/utils";import{CONSTANT_CAPS as t}from"../../../core/index.js";import{resolveEnhancedJsonValue as r}from"../../../enhanced-json/index.js";import{DiagnosticCode as i,diagnosticMessages as n}from"../../../errors/index.js";import{ShapePropertyName as o}from"./names/shape-property-name.js";let s=(e,t,r,o,s)=>{for(let l of r.validatePartialShape(t).errors){let t=l.instancePath?l.instancePath:"(root)",r=l.instancePath.split("/").filter(Boolean)[0]??"";o.error(i.DEFAULTS_SCHEMA_VIOLATION,n[i.DEFAULTS_SCHEMA_VIOLATION](e,r,t,l.message,s))}};export const Defaults=(l,a,f)=>{let E=a.allNames,T=[...E].map(String),S=new Map,N=new Map;for(let e of a.entitySchemas)S.set(e.entityType,new Set(Object.keys(e.shapeProperties))),N.set(e.entityType,e);let g={},O=new Map;for(let[e,_]of Object.entries(l)){let l=f.at(e);if(!E.has(e)){f.error(i.DEFAULTS_UNKNOWN_ENTITY_KEY,n[i.DEFAULTS_UNKNOWN_ENTITY_KEY](e,T));continue}let c=a.aliases.get(e),p=void 0!==c,h={};for(let[t,r]of Object.entries(_)){let s=o(t,l);if(s){if(p){let t=[];for(let e of c){let r=S.get(e);r&&r.has(s)||t.push(String(e))}if(t.length>0){let r=c[0],o=r?[...S.get(r)??[]]:[];f.error(i.DEFAULTS_UNKNOWN_PROPERTY,n[i.DEFAULTS_UNKNOWN_PROPERTY](e,s,o,t));continue}}else{let t=S.get(e);if(!t||!t.has(s)){let r=t?[...t]:[];f.error(i.DEFAULTS_UNKNOWN_PROPERTY,n[i.DEFAULTS_UNKNOWN_PROPERTY](e,s,r));continue}}h[s]=r}}if(0===Object.keys(h).length)continue;let m=r(h,void 0,t,l);if(void 0!==m){if(p)for(let t of c){let r=N.get(t);r&&s(e,m,r,l,String(t))}else{let t=N.get(e);t&&s(e,m,t,l)}for(let t of c??[e])g[String(t)]={...g[String(t)],...h},O.set(t,[...O.get(t)??[],e])}}for(let[e,t]of O){let r=g[String(e)]??{},o=(N.get(e)?.shapeSchema.required??[]).filter(e=>!Object.hasOwn(r,e));if(0===o.length)continue;let s=t.includes(String(e))?String(e):t.at(-1);f.at(s).error(i.DEFAULTS_INCOMPLETE,n[i.DEFAULTS_INCOMPLETE](String(e),o,t))}if(Object.keys(l).length>0&&f.warning(i.DEFAULTS_DEPRECATED,n[i.DEFAULTS_DEPRECATED]()),!f.hasErrors)return e({entries:g})};

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

@@ -1,13 +1,8 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { EntityTypes as EntityTypesData } from '#package/domain';
 import type { ParseContext } from '../../../core/index.js';
 import type { MergedModelVersion } from '../../merge/index.js';
-import { EntityTypeName } from './names/entity-type-name.js';
-/**
- * Validated list of entity type names declared in a model version (e.g. [Table, TopCircle, Legs3D]).
- * Entity types are the concrete domain objects that can be instantiated in the configurator.
- * Each name must be unique PascalCase.
- */
-export type EntityTypes = Branded<'EntityTypes', readonly EntityTypeName[]>;
+/** The entity type names a model version declares; see {@link EntityTypesData | EntityTypes} in `domain`. */
+export type EntityTypes = EntityTypesData;
 /**
  * Validates and brands entity type names from a merged model version.
  * Checks PascalCase naming and rejects duplicates.

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

@@ -8,6 +8,7 @@ export * from './entity-schema.js';
 export * from './entity-types.js';
 export * from './model-version.js';
 export * from './model-version-key.js';
+export * from './model-type-resolution.js';
 export * from './names/index.js';
 export * from './presets.js';
 export * from './resolved-shapes.js';

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

@@ -1 +1 @@
-export*from"./aliases.js";export*from"./all-names.js";export*from"./common-types.js";export*from"./configuration-schema.js";export*from"./data-schemas.js";export*from"./defaults.js";export*from"./entity-schema.js";export*from"./entity-types.js";export*from"./model-version.js";export*from"./model-version-key.js";export*from"./names/index.js";export*from"./presets.js";export*from"./resolved-shapes.js";export*from"./session-data-schema.js";export*from"./shapes/index.js";
+export*from"./aliases.js";export*from"./all-names.js";export*from"./common-types.js";export*from"./configuration-schema.js";export*from"./data-schemas.js";export*from"./defaults.js";export*from"./entity-schema.js";export*from"./entity-types.js";export*from"./model-version.js";export*from"./model-version-key.js";export*from"./model-type-resolution.js";export*from"./names/index.js";export*from"./presets.js";export*from"./resolved-shapes.js";export*from"./session-data-schema.js";export*from"./shapes/index.js";

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

@@ -0,0 +1,10 @@
+import type { PhoenixDefinitions } from '../../../core/index.js';
+import { type ValueTypeResolution } from '../common/index.js';
+import type { ModelVersion } from './model-version.js';
+/** What reading the type of a schema of the model needs: its refs and its entity names. */
+export type ModelTypeResolution = Omit<ValueTypeResolution, 'author' | 'definitions'>;
+/**
+ * Resolves the refs of a model's schemas (its common types and the phoenix definitions) and the
+ * entity types an entity type or alias name stands for.
+ */
+export declare const ModelTypeResolution: (model: ModelVersion, phxDefinitions: PhoenixDefinitions) => ModelTypeResolution;

package/dist/application-spec/parse-application-files/spec/model/model-type-resolution.js

@@ -0,0 +1 @@
+import{createSchemaRefResolver as e}from"../common/index.js";export const ModelTypeResolution=(o,r)=>({resolveRef:e(o.commonTypes,r),entityTypes:e=>{for(let[r,t]of o.aliases)if(String(r)===e)return t.map(String);return[e]}});

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

@@ -1,6 +1,6 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { ModelVersionKey as ModelVersionKeyData } from '#package/domain';
 import type { ParseContext } from '../../../core/index.js';
-/** Branded string for a model version key ("latest", "v1", "v2", etc.). */
-export type ModelVersionKey = Branded<'ModelVersionKey', string>;
+/** A model version key (`latest`, `v1`, `v2`, …); see {@link ModelVersionKeyData | ModelVersionKey} in `domain`. */
+export type ModelVersionKey = ModelVersionKeyData;
 /** Validates that a version key is "latest" or "v{N}" (e.g. "v1", "v2"). */
 export declare const ModelVersionKey: (key: string, ctx: ParseContext) => ModelVersionKey | undefined;

package/dist/application-spec/parse-application-files/spec/model/names/action-name.d.ts

@@ -0,0 +1,6 @@
+import type { ActionName as ActionNameData } from '#package/domain';
+import type { ParseContext } from '../../../../core/index.js';
+/** A branded action name; see {@link ActionNameData | ActionName} in `domain`. */
+export type ActionName = ActionNameData;
+/** Validates that a name follows the action naming convention (camelCase, no prefix). */
+export declare const ActionName: (name: string, ctx: ParseContext) => ActionName | undefined;

package/dist/application-spec/parse-application-files/spec/model/names/action-name.js

@@ -0,0 +1 @@
+import{Branded as o}from"@salsita-ai/common/utils";import{DiagnosticCode as r,diagnosticMessages as t}from"../../../../errors/index.js";let i=/^[a-z][A-Za-z0-9]*$/;export const ActionName=(A,e)=>i.test(A)?o(A):void e.error(r.INVALID_ACTION_NAME,t.INVALID_ACTION_NAME(A));

package/dist/application-spec/parse-application-files/spec/model/names/alias-name.d.ts

@@ -1,11 +1,7 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { AliasName as AliasNameData } from '#package/domain';
 import type { ParseContext } from '../../../../core/index.js';
-/**
- * Branded PascalCase alias name (e.g. "RootEntity", "AllLegs").
- * Aliases group entity types so that shapes, expressions, and rules can target
- * multiple entities at once. "RootEntity" is required in every model version.
- */
-export type AliasName = Branded<'AliasName', string>;
+/** A branded alias name; see {@link AliasNameData | AliasName} in `domain`. */
+export type AliasName = AliasNameData;
 export declare const RESERVED_ALIAS_NAMES: readonly ['AnyDomainEntity'];
 /** Validates PascalCase naming and rejects reserved names (AnyDomainEntity). */
 export declare const AliasName: (name: string, ctx: ParseContext) => AliasName | undefined;

package/dist/application-spec/parse-application-files/spec/model/names/entity-or-alias-name.d.ts

@@ -1,11 +1,6 @@
+import type { EntityOrAliasName as EntityOrAliasNameData } from '#package/domain';
 import type { ParseContext } from '../../../../core/index.js';
-import { AliasName } from './alias-name.js';
-import { EntityTypeName } from './entity-type-name.js';
-/**
- * A PascalCase name that identifies either a concrete entity type (e.g. "Table")
- * or an alias group (e.g. "RootEntity"). Used as shape keys since shapes
- * can be defined for both entity types and aliases.
- */
-export type EntityOrAliasName = EntityTypeName | AliasName;
+/** The name of an entity type or an alias; see {@link EntityOrAliasNameData | EntityOrAliasName} in `domain`. */
+export type EntityOrAliasName = EntityOrAliasNameData;
 /** Validates that a name is valid PascalCase for either an entity type or alias. */
 export declare const EntityOrAliasName: (name: string, ctx: ParseContext) => EntityOrAliasName | undefined;

package/dist/application-spec/parse-application-files/spec/model/names/entity-type-name.d.ts

@@ -1,11 +1,6 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { EntityTypeName as EntityTypeNameData } from '#package/domain';
 import type { ParseContext } from '../../../../core/index.js';
-/**
- * Branded PascalCase entity type name (e.g. "Table", "TopCircle", "Legs3D").
- * Entity types are the concrete domain objects declared in a model version.
- * Each entity type can have shapes, be referenced by aliases, and be instantiated
- * in the configurator at runtime.
- */
-export type EntityTypeName = Branded<'EntityTypeName', string>;
+/** A branded entity type name; see {@link EntityTypeNameData | EntityTypeName} in `domain`. */
+export type EntityTypeName = EntityTypeNameData;
 /** Validates that a name is PascalCase for use as an entity type identifier. */
 export declare const EntityTypeName: (name: string, ctx: ParseContext) => EntityTypeName | undefined;

package/dist/application-spec/parse-application-files/spec/model/names/expression-name.d.ts

@@ -1,9 +1,6 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { ExpressionName as ExpressionNameData } from '#package/domain';
 import type { ParseContext } from '../../../../core/index.js';
-/**
- * Branded expression name starting with $ followed by camelCase (e.g. "$price", "$isValid", "$availableColors").
- * Expressions are computed properties on entities — their names are prefixed with $ to distinguish them from shape properties.
- */
-export type ExpressionName = Branded<'ExpressionName', string>;
+/** A branded expression name; see {@link ExpressionNameData | ExpressionName} in `domain`. */
+export type ExpressionName = ExpressionNameData;
 /** Validates that a name follows the expression naming convention ($camelCase). */
 export declare const ExpressionName: (name: string, ctx: ParseContext) => ExpressionName | undefined;

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

@@ -1,3 +1,4 @@
+export * from './action-name.js';
 export * from './alias-name.js';
 export * from './entity-or-alias-name.js';
 export * from './entity-type-name.js';

package/dist/application-spec/parse-application-files/spec/model/names/index.js

@@ -1 +1 @@
-export*from"./alias-name.js";export*from"./entity-or-alias-name.js";export*from"./entity-type-name.js";export*from"./expression-name.js";export*from"./instance-name.js";export*from"./invariant-name.js";export*from"./relation-name.js";export*from"./shape-property-name.js";export*from"./violation-type-name.js";
+export*from"./action-name.js";export*from"./alias-name.js";export*from"./entity-or-alias-name.js";export*from"./entity-type-name.js";export*from"./expression-name.js";export*from"./instance-name.js";export*from"./invariant-name.js";export*from"./relation-name.js";export*from"./shape-property-name.js";export*from"./violation-type-name.js";

package/dist/application-spec/parse-application-files/spec/model/names/instance-name.d.ts

@@ -1,9 +1,5 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { InstanceName as InstanceNameData } from '#package/domain';
 import type { ParseContext } from '../../../../core/index.js';
-/**
- * Branded component instance name.
- * User-declared names must start with a letter (e.g. "default", "body", "main").
- * SDK-derived names may include `$` prefix and `.` separators (e.g. "$top", "Table.$top").
- */
-export type InstanceName = Branded<'InstanceName', string>;
+/** A branded component instance name; see {@link InstanceNameData | InstanceName} in `domain`. */
+export type InstanceName = InstanceNameData;
 export declare const InstanceName: (name: string, entityKey: string, componentName: string, ctx: ParseContext) => InstanceName | undefined;

package/dist/application-spec/parse-application-files/spec/model/names/invariant-name.d.ts

@@ -1,5 +1,5 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { InvariantName as InvariantNameData } from '#package/domain';
 import type { ParseContext } from '../../../../core/index.js';
-/** A camelCase identifier for an invariant implementation declared in YAML. */
-export type InvariantName = Branded<'InvariantName', string>;
+/** A branded invariant name; see {@link InvariantNameData | InvariantName} in `domain`. */
+export type InvariantName = InvariantNameData;
 export declare const InvariantName: (name: string, ctx: ParseContext) => InvariantName | undefined;

package/dist/application-spec/parse-application-files/spec/model/names/shape-property-name.d.ts

@@ -1,15 +1,7 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { ShapePropertyName as ShapePropertyNameData } from '#package/domain';
 import { ParseContext } from '../../../../core/index.js';
-/**
- * Branded shape property name — the key under which an entity shape (or
- * alias shape) declares a field, and the key under which `defaults:` attaches
- * initial values. Must match /^[a-z]\w*$/: start with a lowercase letter,
- * then word characters (letters, digits, underscore).
- *
- * Examples: `height`, `positionX`, `hoodId`. Rejected: `Height`, `$height`,
- * `3D`, `height-px`.
- */
-export type ShapePropertyName = Branded<'ShapePropertyName', string>;
+/** A branded shape property name; see {@link ShapePropertyNameData | ShapePropertyName} in `domain`. */
+export type ShapePropertyName = ShapePropertyNameData;
 /** Validates `name` as a shape property identifier. Emits `INVALID_SHAPE_PROPERTY_NAME` on failure. */
 export declare const ShapePropertyName: (name: string, ctx: ParseContext) => ShapePropertyName | undefined;
 /**

package/dist/application-spec/parse-application-files/spec/model/names/violation-type-name.d.ts

@@ -1,5 +1,5 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { ViolationTypeName as ViolationTypeNameData } from '#package/domain';
 import type { ParseContext } from '../../../../core/index.js';
-/** A stable violation discriminator returned by an invariant. */
-export type ViolationTypeName = Branded<'ViolationTypeName', string>;
+/** A branded violation type name; see {@link ViolationTypeNameData | ViolationTypeName} in `domain`. */
+export type ViolationTypeName = ViolationTypeNameData;
 export declare const ViolationTypeName: (name: string, ctx: ParseContext) => ViolationTypeName | undefined;

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

@@ -1,37 +1,14 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { Presets as PresetsData, SpecPreset } from '#package/domain';
 import type { ParseContext } from '../../../core/index.js';
 import type { MergedPresets } from '../../merge/index.js';
 import type { RawPreset } from '../../raw-spec/index.js';
 import type { Relations } from '../relations/index.js';
 import type { ModelVersion } from './model-version.js';
-/**
- * A single entity within a preset — id, type, and shape properties.
- * Properties are validated against the entity's schema from ConfigurationSchema.
- */
-export type PresetEntity = Branded<'PresetEntity', {
-    readonly id: string;
-    readonly type: string;
-    readonly properties: Readonly<Record<string, unknown>>;
-}>;
-/**
- * A single parsed preset — the root entity type, initial entities, and optional metadata.
- * Represents one initial configuration state for a configurator deployment.
- */
-export type Preset = Branded<'Preset', {
-    readonly rootEntityType: string;
-    readonly initialDomainEntities: readonly PresetEntity[];
-    readonly name?: string;
-    readonly description?: string;
-    readonly img?: string;
-    readonly imgAlt?: string;
-    readonly detailTitle?: string;
-    readonly detailDescription?: string;
-    readonly tags?: readonly string[];
-}>;
-/** All parsed presets for a parsed configurator or admin model. */
-export type Presets = Branded<'Presets', {
-    readonly presets: readonly Preset[];
-}>;
+export type { PresetEntity } from '#package/domain';
+/** The parsed preset; see {@link SpecPreset} in `domain`. */
+export type Preset = SpecPreset;
+/** The parsed presets of a domain; see {@link PresetsData | Presets} in `domain`. */
+export type Presets = PresetsData;
 export declare const Preset: (raw: RawPreset, latestModel: ModelVersion, relations: Relations, ctx: ParseContext) => Preset | undefined;
 /**
  * Parses and validates merged presets against the domain model.

package/dist/application-spec/parse-application-files/spec/relations/reference-field-type.d.ts

@@ -0,0 +1,25 @@
+import { type EnhancedJsonSchemaType, type PhoenixDefinitions } from '../../../core/index.js';
+import type { ModelVersion } from '../model/index.js';
+/**
+ * What the type of a shape field means to a relation that reads its related entities from it.
+ *
+ * - `single`: the id of one entity of `entityTypes`, or `null` when `nullable`.
+ * - `array`: an array of ids of entities of `entityTypes`.
+ * - `other`: anything else, such as a string, an id without `references`, or a mix of the above.
+ * - `unknown`: the schema does not say, because it states its type as TypeScript text (`tsType`)
+ *   or combines schemas with `allOf`.
+ */
+export type ReferenceFieldType = {
+    readonly kind: 'single';
+    readonly entityTypes: ReadonlySet<string>;
+    readonly nullable: boolean;
+} | {
+    readonly kind: 'array';
+    readonly entityTypes: ReadonlySet<string>;
+} | {
+    readonly kind: 'other';
+} | {
+    readonly kind: 'unknown';
+};
+/** Classifies the schema of a shape field of the latest model by the reference it holds. */
+export declare const referenceFieldType: (schema: EnhancedJsonSchemaType, latestModel: ModelVersion, phxDefinitions: PhoenixDefinitions) => ReferenceFieldType;

package/dist/application-spec/parse-application-files/spec/relations/reference-field-type.js

@@ -0,0 +1 @@
+import{COMMON_SHORT_PREFIX as e,INTERNAL_REF_PATTERN as t,extractPhxDefName as n}from"../../../core/index.js";let r={entityTypes:new Set,hasNull:!1,arrays:[],hasOther:!1,hasUnknown:!1},s={...r,hasNull:!0},a={...r,hasOther:!0},y={...r,hasUnknown:!0},i=e=>({entityTypes:new Set(e.flatMap(e=>[...e.entityTypes])),hasNull:e.some(e=>e.hasNull),arrays:e.flatMap(e=>e.arrays),hasOther:e.some(e=>e.hasOther),hasUnknown:e.some(e=>e.hasUnknown)}),l=(o,p)=>{if(o.tsType)return y;if(o.$ref){let s,i=n(o.$ref);if(void 0!==i)return p.phxDefinitions[i]?.tsType==="DomainEntityId"&&o.references?{...r,entityTypes:new Set(((e,t)=>{for(let[n,r]of t.aliases)if(String(n)===e)return r.map(String);return[e]})(o.references,p.latestModel))}:a;let h=(s=o.$ref).startsWith(e)?s.slice(e.length):t.exec(s)?.[2];if(void 0===h)return a;let u=p.latestModel.commonTypes.get(h);return!u||p.openCommonTypes.has(h)?y:l(u.schema,{...p,openCommonTypes:new Set([...p.openCommonTypes,h])})}if(o.enum)return i(o.enum.map(e=>null===e?s:a));let h=o.anyOf??o.oneOf;if(h)return i(h.map(e=>l(e,p)));if(o.allOf)return y;let u=e=>"array"===e?(()=>{let{items:e}=o;return!e||Array.isArray(e)?a:{...r,arrays:[l(e,p)]}})():"null"===e?s:a;return"string"==typeof o.type?u(o.type):Array.isArray(o.type)?i(o.type.map(u)):a};export const referenceFieldType=(e,t,n)=>(e=>{if(e.hasUnknown||e.arrays.some(e=>e.hasUnknown))return{kind:"unknown"};if(e.hasOther)return{kind:"other"};let[t,...n]=e.arrays;if(!t)return e.entityTypes.size>0?{kind:"single",entityTypes:e.entityTypes,nullable:e.hasNull}:{kind:"other"};let r=e=>e.entityTypes.size>0&&!e.hasNull&&!e.hasOther&&0===e.arrays.length;return 0===e.entityTypes.size&&!e.hasNull&&r(t)&&n.every(e=>{let n,s;return r(e)&&(n=e.entityTypes,s=t.entityTypes,n.size===s.size&&[...n].every(e=>s.has(e)))})?{kind:"array",entityTypes:t.entityTypes}:{kind:"other"}})(l(e,{latestModel:t,phxDefinitions:n,openCommonTypes:new Set}));

package/dist/application-spec/parse-application-files/spec/relations/relation-field-mismatch.d.ts

@@ -0,0 +1,46 @@
+import type { ReferenceFieldType } from './reference-field-type.js';
+type Cardinality = '0-1' | '1-1' | '0-N' | '1-N';
+/** How a field holds its reference: one id, one id or `null`, or an array of ids. */
+export type ReferenceFieldShape = 'single' | 'nullableSingle' | 'array';
+/**
+ * Why a relation cannot read its related entities from its field.
+ *
+ * - `notReference`: the field does not hold entity ids.
+ * - `otherEntityTypes`: the field holds ids of other entity types than the relation relates to.
+ * - `cardinality`: the field of a direct relation holds its ids in another shape than the
+ *   cardinality of the relation needs.
+ */
+export type RelationFieldMismatch = {
+    readonly kind: 'notReference';
+} | {
+    readonly kind: 'otherEntityTypes';
+    readonly referenced: readonly string[];
+} | {
+    readonly kind: 'cardinality';
+    readonly shape: ReferenceFieldShape;
+    readonly required: ReferenceFieldShape;
+};
+interface RelationReadingField {
+    readonly kind: 'direct' | 'indirect';
+    readonly cardinality: Cardinality;
+}
+/**
+ * Checks the field of a direct or indirect relation against what the relation reads from it.
+ *
+ * The field must reference exactly `relatedEntityTypes`: for a direct relation the entity types of
+ * its target, for an indirect relation the entity types it is declared on, because there the field
+ * belongs to the target and points back. A direct relation also fixes the shape of the field by
+ * its cardinality. An indirect relation reads every shape, since its cardinality counts the
+ * entities that point back and not the ids in the field.
+ *
+ * When an alias holds the field, the field can have another type in each entity type of the alias.
+ * The relation is accepted when the field fits in at least one of them. Requiring all of them
+ * would be the stricter reading, but projects whose specs type-check rely on the looser one, so
+ * it would reject working projects.
+ *
+ * @param fieldTypes The type of the field in each entity type that holds it.
+ * @returns The mismatch of the first entity type, or `undefined` when the field fits in one of
+ *   them or its type there is unknown.
+ */
+export declare const relationFieldMismatch: (relation: RelationReadingField, fieldTypes: readonly ReferenceFieldType[], relatedEntityTypes: readonly string[]) => RelationFieldMismatch | undefined;
+export {};

package/dist/application-spec/parse-application-files/spec/relations/relation-field-mismatch.js

@@ -0,0 +1 @@
+let e={"0-1":"nullableSingle","1-1":"single","0-N":"array","1-N":"array"};export const relationFieldMismatch=(n,i,r)=>{let t=i.map(i=>((n,i,r)=>{if("unknown"===i.kind)return;if("other"===i.kind)return{kind:"notReference"};let t=i.entityTypes;if(!(t.size===new Set(r).size&&r.every(e=>t.has(e))))return{kind:"otherEntityTypes",referenced:[...t]};if("indirect"===n.kind)return;let l="array"===i.kind?"array":i.nullable?"nullableSingle":"single",a=e[n.cardinality];return l===a?void 0:{kind:"cardinality",shape:l,required:a}})(n,i,r));return t.includes(void 0)?void 0:t[0]};

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

@@ -1,5 +1,5 @@
 import { Branded } from '@salsita-ai/common/utils';
-import type { ParseContext } from '../../../core/index.js';
+import type { ParseContext, PhoenixDefinitions } from '../../../core/index.js';
 import type { MergedRelations } from '../../merge/index.js';
 import type { ComponentEntry } from '../components/index.js';
 import type { Expression } from '../expressions/index.js';
@@ -19,7 +19,8 @@ export type Relations = Branded<'Relations', {
  * Validates merged relations against the latest model, then expands into components + expressions.
  *
  * Each relation is individually constructed via `Relation()` which builds its own expression
- * and component entries. This factory validates cross-relation concerns (counterpart pairing,
+ * and component entries. This factory validates the field a direct or indirect relation reads
+ * against the shape that holds it, validates cross-relation concerns (counterpart pairing,
  * composition tree reachability) and aggregates the per-relation artifacts.
  */
-export declare const Relations: (rawRelations: MergedRelations, latestModel: ModelVersion, ctx: ParseContext) => Relations;
+export declare const Relations: (rawRelations: MergedRelations, latestModel: ModelVersion, phxDefinitions: PhoenixDefinitions, ctx: ParseContext) => Relations;

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

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as t,diagnosticMessages as r}from"../../../errors/index.js";import{IMPLICIT_ENTITY_FIELDS as i,RelationName as o,getResolvedShape as n}from"../model/index.js";import{Relation as f}from"./relation.js";let l=(e,t,r)=>{let i=r[t.target];if(!i)return;let o="direct"===t.kind?"indirect":"indirect"===t.kind?"direct":"allOfType";for(let[r,n]of Object.entries(i))if(n.kind===o&&n.target===e&&("allOfType"===t.kind||"allOfType"===n.kind||t.field===n.field))return{entityKey:t.target,name:r,relation:n}},T=(e,t)=>{let r=t.aliases.get(e);return r||[e]};export const Relations=(O,N,E)=>{let{allNames:I,resolvedShapes:_}=N,a=[...I].map(String),s=(e,t)=>n(_,e).fieldSchemas.has(t),d={};for(let[e,n]of Object.entries(O)){let l=E.at(e);if(!I.has(e)){l.error(t.RELATION_UNKNOWN_ENTITY_KEY,r.RELATION_UNKNOWN_ENTITY_KEY(e,a));continue}for(let[T,O]of Object.entries(n)){if(!o(T,l))continue;if(!I.has(O.target)){l.error(t.RELATION_UNKNOWN_TARGET,r.RELATION_UNKNOWN_TARGET(e,T,O.target,a));continue}if("direct"===O.kind){if(i.has(O.field)){l.error(t.RELATION_IMMUTABLE_FIELD,r.RELATION_IMMUTABLE_FIELD(e,T,O.field,e));continue}if(!s(e,O.field)){l.error(t.RELATION_UNKNOWN_FIELD_DIRECT,r.RELATION_UNKNOWN_FIELD_DIRECT(e,T,O.field));continue}}else if("indirect"===O.kind){if(i.has(O.field)){l.error(t.RELATION_IMMUTABLE_FIELD,r.RELATION_IMMUTABLE_FIELD(e,T,O.field,O.target));continue}if(!s(O.target,O.field)){l.error(t.RELATION_UNKNOWN_FIELD_INDIRECT,r.RELATION_UNKNOWN_FIELD_INDIRECT(e,T,O.field,O.target));continue}}let n=f(T,O,e,N.aliases,l);n&&(d[e]||(d[e]={}),d[e][n.name]=n)}}for(let[e,i]of Object.entries(d)){let o=E.at(e);for(let[n,f]of Object.entries(i)){if(f.target===e)continue;let i=l(e,f,d);if(!i){o.error(t.RELATION_MISSING_COUNTERPART,r.RELATION_MISSING_COUNTERPART(e,n,f.kind,f.target,"allOfType"===f.kind?void 0:f.field,f.composedOf));continue}f.composedOf&&i.relation.composedOf&&o.error(t.RELATION_COUNTERPART_COMPOSED_OF_MISMATCH,r.RELATION_COUNTERPART_COMPOSED_OF_MISMATCH(e,n,i.entityKey,i.name))}}((e,i,o)=>{let n=new Map;for(let[t,r]of Object.entries(e))for(let e of Object.values(r)){if(!e.composedOf)continue;let r=T(t,i),o=T(e.target,i);for(let e of r){let t=n.get(e);for(let r of(t||(t=new Set,n.set(e,t)),o))t.add(r)}}let f=new Set(i.rootEntityTypes),l=[...i.rootEntityTypes];for(;l.length>0;){let e=l.shift(),t=n.get(e);if(t)for(let e of t)f.has(e)||(f.add(e),l.push(e))}let O=i.rootEntityTypes.map(String);for(let e of i.entityTypes)f.has(e)||o.at(String(e)).error(t.RELATION_ENTITY_NOT_IN_COMPOSITION_TREE,r.RELATION_ENTITY_NOT_IN_COMPOSITION_TREE(String(e),O))})(d,N,E);let{components:R,expressions:c}=(e=>{let t=[],r=[];for(let i of Object.values(e))for(let e of Object.values(i))t.push(...e.components),r.push(e.expression);return{components:t,expressions:r}})(d);return e({entries:d,components:R,expressions:c})};
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as t,diagnosticMessages as r}from"../../../errors/index.js";import{IMPLICIT_ENTITY_FIELDS as i,RelationName as o,getResolvedShape as E}from"../model/index.js";import{referenceFieldType as n}from"./reference-field-type.js";import{relationFieldMismatch as f}from"./relation-field-mismatch.js";import{Relation as l}from"./relation.js";let T=(e,t,r)=>{let i=r[t.target];if(!i)return;let o="direct"===t.kind?"indirect":"indirect"===t.kind?"direct":"allOfType";for(let[r,E]of Object.entries(i))if(E.kind===o&&E.target===e&&("allOfType"===t.kind||"allOfType"===E.kind||t.field===E.field))return{entityKey:t.target,name:r,relation:E}},N=(e,t)=>{let r=t.aliases.get(e);return r||[e]},a=(e,i,o)=>{let{entityKey:E,relationName:n,field:f,fieldOwner:l,related:T,relatedEntityTypes:N,cardinality:a}=i;switch(e.kind){case"notReference":o.error(t.RELATION_FIELD_NOT_REFERENCE,r.RELATION_FIELD_NOT_REFERENCE(E,n,f,l));break;case"otherEntityTypes":o.error(t.RELATION_FIELD_REFERENCES_OTHER_TYPES,r.RELATION_FIELD_REFERENCES_OTHER_TYPES(E,n,f,l,e.referenced,T,N));break;case"cardinality":o.error(t.RELATION_FIELD_CARDINALITY_MISMATCH,r.RELATION_FIELD_CARDINALITY_MISMATCH(E,n,f,a,e.shape,e.required))}};export const Relations=(O,_,I,s)=>{let{allNames:d,resolvedShapes:R}=_,c=[...d].map(String),L=(e,t)=>E(R,e).fieldSchemas.has(t),A={};for(let[e,T]of Object.entries(O)){let O=s.at(e);if(!d.has(e)){O.error(t.RELATION_UNKNOWN_ENTITY_KEY,r.RELATION_UNKNOWN_ENTITY_KEY(e,c));continue}for(let[s,p]of Object.entries(T)){if(!o(s,O))continue;if(!d.has(p.target)){O.error(t.RELATION_UNKNOWN_TARGET,r.RELATION_UNKNOWN_TARGET(e,s,p.target,c));continue}if("direct"===p.kind){if(i.has(p.field)){O.error(t.RELATION_IMMUTABLE_FIELD,r.RELATION_IMMUTABLE_FIELD(e,s,p.field,e));continue}if(!L(e,p.field)){O.error(t.RELATION_UNKNOWN_FIELD_DIRECT,r.RELATION_UNKNOWN_FIELD_DIRECT(e,s,p.field));continue}}else if("indirect"===p.kind){if(i.has(p.field)){O.error(t.RELATION_IMMUTABLE_FIELD,r.RELATION_IMMUTABLE_FIELD(e,s,p.field,p.target));continue}if(!L(p.target,p.field)){O.error(t.RELATION_UNKNOWN_FIELD_INDIRECT,r.RELATION_UNKNOWN_FIELD_INDIRECT(e,s,p.field,p.target));continue}}if("allOfType"!==p.kind){let[t,r]="direct"===p.kind?[e,p.target]:[p.target,e],i=N(r,_).map(String),o=N(t,_).flatMap(e=>{let t=E(R,e).fieldSchemas.get(p.field);return t?[n(t,_,I)]:[]}),l=f(p,o,i);l&&a(l,{entityKey:e,relationName:s,field:p.field,fieldOwner:t,related:r,relatedEntityTypes:i,cardinality:p.cardinality},O.at(s))}let T=l(s,p,e,_.aliases,O);T&&(A[e]||(A[e]={}),A[e][T.name]=T)}}for(let[e,i]of Object.entries(A)){let o=s.at(e);for(let[E,n]of Object.entries(i)){if(n.target===e)continue;let i=T(e,n,A);if(!i){o.error(t.RELATION_MISSING_COUNTERPART,r.RELATION_MISSING_COUNTERPART(e,E,n.kind,n.target,"allOfType"===n.kind?void 0:n.field,n.composedOf));continue}n.composedOf&&i.relation.composedOf&&o.error(t.RELATION_COUNTERPART_COMPOSED_OF_MISMATCH,r.RELATION_COUNTERPART_COMPOSED_OF_MISMATCH(e,E,i.entityKey,i.name))}}((e,i,o)=>{let E=new Map;for(let[t,r]of Object.entries(e))for(let e of Object.values(r)){if(!e.composedOf)continue;let r=N(t,i),o=N(e.target,i);for(let e of r){let t=E.get(e);for(let r of(t||(t=new Set,E.set(e,t)),o))t.add(r)}}let n=new Set(i.rootEntityTypes),f=[...i.rootEntityTypes];for(;f.length>0;){let e=f.shift(),t=E.get(e);if(t)for(let e of t)n.has(e)||(n.add(e),f.push(e))}let l=i.rootEntityTypes.map(String);for(let e of i.entityTypes)n.has(e)||o.at(String(e)).error(t.RELATION_ENTITY_NOT_IN_COMPOSITION_TREE,r.RELATION_ENTITY_NOT_IN_COMPOSITION_TREE(String(e),l))})(A,_,s);let{components:p,expressions:m}=(e=>{let t=[],r=[];for(let i of Object.values(e))for(let e of Object.values(i))t.push(...e.components),r.push(e.expression);return{components:t,expressions:r}})(A);return e({entries:A,components:p,expressions:m})};

package/dist/application-spec/parse-application-files/spec/sections/actions.d.ts

@@ -0,0 +1,18 @@
+import type { Actions as ActionsData } from '#package/domain';
+import { type ParseContext, type PhoenixDefinitions } from '../../../core/index.js';
+import type { MergedActions } from '../../merge/index.js';
+import { type ModelVersion } from '../model/index.js';
+export type { ActionParam, Action } from '#package/domain';
+/** The validated `actions` section by action name; see {@link ActionsData | Actions} in `domain`. */
+export type Actions = ActionsData;
+interface ActionsContext {
+    readonly latestModel: ModelVersion;
+    readonly phxDefinitions: PhoenixDefinitions;
+}
+/**
+ * Validates the merged `actions` block against the latest model: action names follow the naming
+ * rule, every `$ref` and `references` of a param or result member resolves, and each action gets
+ * the runtime schema of its parameters. Returns `undefined` after reporting when any action is
+ * invalid, so nothing downstream builds on a partial list.
+ */
+export declare const Actions: (merged: MergedActions, context: ActionsContext, ctx: ParseContext) => Actions | undefined;

package/dist/application-spec/parse-application-files/spec/sections/actions.js

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{buildPhxDefSchemas as t,collectSchemaRefs as r,toRuntimeSchema as o}from"../../../core/index.js";import{DiagnosticCode as s,diagnosticMessages as i}from"../../../errors/index.js";import{createSchemaRefResolver as a,isNullableSchema as m,validateSchemaRefs as n}from"../common/index.js";import{ActionName as p}from"../model/index.js";let l=(e,{latestModel:t,phxDefinitions:o},a,m)=>{let p=new Set(t.commonTypes.keys());for(let[l,c]of Object.entries(e)){let{refs:e,references:d}=r(c),f=a.at(l);for(let r of(n(e,t.versionKey,p,o,f),d))[...t.allNames].some(e=>e===r.value)||f.at(...r.path).error(s.ACTION_UNKNOWN_REFERENCE_TARGET,i.ACTION_UNKNOWN_REFERENCE_TARGET(m,l,r.value))}};export const Actions=(r,s,i)=>{let{latestModel:n,phxDefinitions:c}=s,d=i.errors.length,f=a(n.commonTypes,c),u=new Map([...Object.entries(t(c)),...[...n.commonTypes].map(([e,t])=>[e,t.schema])]),j=new Map;for(let[t,a]of Object.entries(r)){let r=i.at(t),n=p(t,r);if(l(a.params,s,r.at("params"),`actions.${t}.params`),l(a.result,s,r.at("result"),`actions.${t}.result`),!n)continue;let c=Object.fromEntries(Object.entries(a.params).map(([e,t])=>[e,{schema:t,required:!m(t,f)}])),d=o({type:"object",properties:a.params,required:Object.entries(c).flatMap(([e,{required:t}])=>t?[e]:[]),additionalProperties:!1},u);j.set(n,e({name:n,...void 0===a.description?{}:{description:a.description},params:c,result:a.result,paramsSchema:d}))}return i.errors.length>d?void 0:e(j)};