@salsita-ai/sdk 0.50.0-develop.9ed52379e9 → 0.50.0-develop.9fe72d003e

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}from"../../../core/index.js";import{DiagnosticCode as n,diagnosticMessages as o}from"../../../errors/index.js";import{isSdkExpressionImplementation as i}from"./expression.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,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)},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,x=r(f,{latestModel:c,evalExpressionParser:u,parsingContext:g});if(void 0===x)return;let S=new Map;for(let e of x)s(S,e);for(let e of p)a(S,e);let h=((e,t)=>{let n=new Map,o=e=>{let t=n.get(e.entityKey);t||(t=new Set,n.set(e.entityKey,t)),t.add(e.name)};for(let t of e)o(t);for(let e of t)i(e.implementation)&&o(e);return n})(x,p),w=new Map;for(let e of x){let{implementation:t}=e;if("value"!==t.kind||!t.constant||t.plan.usesSelf)continue;let n=w.get(e.entityKey);n||(n=new Map,w.set(e.entityKey,n)),n.set(e.name,t.plan)}let K=new Map;for(let t of y){let i=[],r=new Map,s=e=>{let s=S.get(e);if(!s||0===s.size)return;i.push(e);let a=h.get(e);for(let[i,m]of s){if(!a?.has(i))continue;let s=r.get(i);if(s){g.at(l(m),e,i).error(n.DUPLICATE_EXPRESSION,o.DUPLICATE_EXPRESSION(t,i,s,e));continue}r.set(i,e)}};for(let[e,n]of d)n.includes(t)&&s(e);s(t),K.set(t,e({shapeGroups:i}))}return e({expressions:S,entityExpressions:K,constants:w})};
+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,5 +1,3 @@
-export type * from './expression.js';
-export { isSdkExpressionImplementation } 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/index.js

@@ -1 +1 @@
-export{isSdkExpressionImplementation}from"./expression.js";export*from"./expressions.js";export*from"./memo-eval-plan.js";export*from"./user-expressions.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{evalCodeUsesSelf as r}from"../../../core/eval-code-uses-self.js";import{isEvalMarker as t,isMsgMarker as n}from"../../../core/index.js";import{isComponentPropTarget as o}from"../components/component-prop-target.js";let l=(e,r)=>0===r.length?e:`${e}.${r.join(".")}`,i=(r,a,u,d)=>{if(void 0===r)throw Error(`MemoEvalPlan: found undefined at ${l(u,d)}, undefined cannot be generated, remove the property or use null.`);if(t(r)){let t=((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,r.$eval,u);return e({kind:"slot",depIndex:t})}if(o(r)){let t=((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,r.$target);return e({kind:"slot",depIndex:t})}if(n(r))return e({kind:"msg",marker:r});if(null===r||"object"!=typeof r)return e({kind:"literal",value:r});if(Array.isArray(r))return e({kind:"array",items:r.map((e,r)=>i(e,a,u,[...d,String(r)]))});if("object"!=typeof r||null===r)throw Error(`MemoEvalPlan: found unsupported value at ${l(u,d)}, remove it or use null.`);let f=[];for(let e in r){let t=r[e];f.push([e,i(t,a,u,[...d,e])])}return e({kind:"object",entries:f})};export const MemoEvalPlan=(t,n)=>{let o=[],l=i(t,o,n,[]),a=o.some(e=>"read"===e.kind||r(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"../../../core/index.js";import{DiagnosticCode as r,diagnosticMessages as s}from"../../../errors/index.js";import{ExpressionName as o}from"../model/index.js";import{MemoEvalPlan as a}from"./memo-eval-plan.js";let i=(e,r,s,o)=>{if("user"===e.kind)return{schema:e.schema,implementation:{kind:"user"}};let i=a(e.value,r),m={kind:"value",constant:e.constant,value:e.value,plan:i};if(Object.keys(e.schema).length>0)return{schema:e.schema,implementation:m};let n=t(e.value,s,o);if(void 0!==n)return{schema:n,implementation:m}};export const UserExpressions=(t,a)=>{let{latestModel:m,evalExpressionParser:n,parsingContext:l}=a,{allNames:c}=m,f=[...c].map(String),h=[];for(let[a,m]of Object.entries(t)){c.has(a)||l.error(r.EXPRESSION_UNKNOWN_ENTITY_KEY,s.EXPRESSION_UNKNOWN_ENTITY_KEY(a,f));let t=e(a);for(let[r,s]of Object.entries(m)){let m=l.at(a),c=o(r,m);if(!c)continue;let f=i(s,`${a}.${r}`,m.at(r),n);f&&h.push(e({entityKey:t,name:c,schema:f.schema,declaredSchema:f.schema,implementation:f.implementation}))}}if(!l.hasErrors)return h};
+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.
  *

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

@@ -1,10 +1,6 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { ActionName as ActionNameData } from '#package/domain';
 import type { ParseContext } from '../../../../core/index.js';
-/**
- * Branded action name: camelCase without a prefix (e.g. "movePartBy", "swapCabinets"). An action is
- * a named domain operation, so its name doubles as the key of its implementation and of its
- * generated types.
- */
-export type ActionName = Branded<'ActionName', string>;
+/** 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/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/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;