@salsita-ai/sdk 0.0.0-stage → 0.49.0-develop.cbee856178

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

@@ -0,0 +1,81 @@
+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;
+}>;
+/**
+ * Builds a {@link MemoEvalPlan} from a value tree that may contain `$eval`,
+ * `$target`, and `$msg` markers. Called during spec parsing from
+ * `user-component-entry.ts` (per `ComponentEntry`) and `user-expressions.ts`
+ * (per value-kind expression).
+ *
+ * `label` is used to annotate emitted `$eval` deps in codegen output —
+ * typically `${entityOrAlias}.${instanceOrExpressionName}`.
+ */
+export declare const MemoEvalPlan: (value: MemoEvalPlanInput, label: string) => MemoEvalPlan;

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

@@ -0,0 +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})};

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

@@ -0,0 +1,21 @@
+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';
+/**
+ * Validates user-declared expressions from merged YAML.
+ *
+ * For each entity/expression pair:
+ * - Validates entity/alias keys against the model and expression naming rules.
+ * - Consumes the tagged {@link RawExpressionEntry} produced by raw parsing:
+ *   `user` → `kind: 'user'` implementation, schema taken verbatim;
+ *   `value` / `eval` / `msg` → `kind: 'value'` with the marker tree, schema either
+ *   taken from sibling schema keys or inferred via `schemaFromValue`.
+ */
+interface UserExpressionsContext {
+    readonly latestModel: ModelVersion;
+    readonly evalExpressionParser: EvalExpressionParser;
+    readonly parsingContext: ParseContext;
+}
+export declare const UserExpressions: (rawExpressions: MergedExpressions, context: UserExpressionsContext) => readonly Expression[] | undefined;
+export {};

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

@@ -0,0 +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};

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

@@ -0,0 +1,7 @@
+export * from './application/index.js';
+export * from './components/index.js';
+export * from './expressions/index.js';
+export * from './invariants/index.js';
+export * from './model/index.js';
+export * from './relations/index.js';
+export * from './sections/index.js';

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

@@ -0,0 +1 @@
+export*from"./application/index.js";export*from"./components/index.js";export*from"./expressions/index.js";export*from"./invariants/index.js";export*from"./model/index.js";export*from"./relations/index.js";export*from"./sections/index.js";

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

@@ -0,0 +1,2 @@
+export * from './invariant.js';
+export * from './invariants.js';

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

@@ -0,0 +1 @@
+export*from"./invariant.js";export*from"./invariants.js";

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

@@ -0,0 +1,23 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { MsgMarker, 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 declare const Invariant: (rawName: string, entry: RawInvariantEntry, ctx: ParseContext) => Invariant | undefined;

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

@@ -0,0 +1 @@
+import{Branded as t}from"@salsita-ai/common/utils";import{isRawDynamicInvariant as e}from"../../raw-spec/index.js";import{InvariantName as i,ViolationTypeName as r}from"../model/index.js";export const Invariant=(o,n,s)=>{let l=i(o,s);if(!l)return;if(e(n)){let e=[];for(let t of n.types){let i=r(t,s);i&&e.push(i)}if(e.length!==n.types.length)return;return t({kind:"dynamic",name:l,violationTypes:e})}let a=r(n.type,s);if(a)return t({kind:"static",name:l,violationType:a,severity:n.severity,message:n.message,controlViolationPriority:n.controlViolationPriority})};

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

@@ -0,0 +1,26 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } 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[];
+}>;
+interface InvariantsProps {
+    readonly rawInvariants: MergedInvariants;
+    readonly rawExpressions: MergedExpressions;
+    readonly rawRelations: MergedRelations;
+    readonly rawComponents: MergedComponents;
+}
+/** 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 {};

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

@@ -0,0 +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})};

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

@@ -0,0 +1,16 @@
+import { Branded } from '@salsita-ai/common/utils';
+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[]>>;
+/** 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/aliases.js

@@ -0,0 +1 @@
+import{Branded as t}from"@salsita-ai/common/utils";import{DiagnosticCode as e,diagnosticMessages as r}from"../../../errors/index.js";import{AllNames as o}from"./all-names.js";import{AliasName as n}from"./names/alias-name.js";export const ROOT_ENTITY_ALIAS=t("RootEntity");let i=(t,e,r)=>{let o=r??new Set;if(o.has(t))return[];let n=e[t];return n?(o.add(t),n.flatMap(t=>i(t,e,o))):[t]};export const Aliases=(s,a,l)=>{let f=s.aliases??{},m=o(s),A=new Set(a);f.RootEntity||l.error(e.MISSING_ROOT_ENTITY,r.MISSING_ROOT_ENTITY());let I=new Set,S=[],p=t=>{if(S.includes(t)){let o=[...S.slice(S.indexOf(t)),t];l.error(e.CIRCULAR_ALIAS,r.CIRCULAR_ALIAS(o.join(" → ")));return}if(I.has(t))return;let o=f[t];if(o){for(let e of(S.push(t),o))p(e);S.pop(),I.add(t)}};for(let t of Object.keys(f))p(t);let E={...f,AnyDomainEntity:[...s.entityTypes??[]]},_=new Map;for(let[o]of Object.entries(f)){let s=n(o,l.at(o));if(!s)continue;let a=[...new Set(i(o,E))],f=[];for(let o of a)m.has(o)||l.at(s).error(e.UNKNOWN_ALIAS_MEMBER,r.UNKNOWN_ALIAS_MEMBER(String(s),o)),A.has(o)&&f.push(t(o));_.set(s,f)}let N=[...a];if(_.set(t("AnyDomainEntity"),N),!l.hasErrors)return t(_)};

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

@@ -0,0 +1,10 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { MergedModelVersion } from '../../merge/index.js';
+/**
+ * The universe of declared names within a model version — entity types and aliases combined.
+ * Used to validate that shape keys, alias members, and `references` targets
+ * point to something that actually exists in the domain model.
+ */
+export type AllNames = Branded<'AllNames', ReadonlySet<string>>;
+/** Builds AllNames from a merged model version by combining entityTypes and alias keys. */
+export declare const AllNames: (merged: MergedModelVersion) => AllNames;

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

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";export const AllNames=t=>{let o=new Set;for(let e of t.entityTypes??[])o.add(e);for(let e of Object.keys(t.aliases??{}))o.add(e);return e(o)};

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

@@ -0,0 +1,22 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type EnhancedJsonSchemaType, type JsonSchema, 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>>;
+/**
+ * Validates, topo-sorts, and resolves commonType entries from the merged model version.
+ *
+ * Each commonType is resolved against previously-resolved siblings (topo-sorted) + phx definitions,
+ * so each CommonType has both an enhanced schema and a runtime-ready schema.
+ */
+export declare const CommonTypes: (merged: MergedModelVersion, versionKey: string, phxDefinitions: PhoenixDefinitions, ctx: ParseContext) => CommonTypes | undefined;

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

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{COMMON_SHORT_PREFIX as t,INTERNAL_REF_PATTERN as o,buildPhxDefSchemas as r,collectSchemaRefs as s,toRuntimeSchema as n}from"../../../core/index.js";import{validateSchemaRefs as l}from"../common/index.js";let a=(t,o,r)=>e({name:t,schema:o,runtimeSchema:n(o,r)});export const CommonTypes=(n,f,i,m)=>{let c=n.commonTypes??{},d=new Set(Object.keys(c));for(let[e,t]of Object.entries(c)){let{refs:o}=s(t);l(o,f,d,i,m.at(e))}if(m.hasErrors)return;let p=new Map(Object.entries(c)),u=r(i),h=new Map;for(let e of(e=>{let r=new Set(e.keys()),n=new Map;for(let[l,a]of e){let{refs:e}=s(a),f=new Set;for(let s of e){if(s.value.startsWith(t)){let e=s.value.slice(t.length);r.has(e)&&f.add(e);continue}let e=o.exec(s.value),n=e?.[2];n&&r.has(n)&&f.add(n)}n.set(l,f)}let l=[],a=new Set,f=new Set,i=e=>{if(!(a.has(e)||f.has(e))){for(let t of(f.add(e),n.get(e)??[]))i(t);f.delete(e),a.add(e),l.push(e)}};for(let t of e.keys())i(t);return l})(p)){let t=p.get(e);if(!t)continue;let o=new Map;for(let[e,t]of h)o.set(e,t.schema);for(let[e,t]of Object.entries(u))o.set(e,t);h.set(e,a(e,t,o))}return e(h)};

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

@@ -0,0 +1,25 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ModelVersion } from './model-version.js';
+/**
+ * Generated AJV-ready configuration schema for server registration.
+ *
+ * - `schema` — the JSON Schema object (array of entity objects discriminated by `type`)
+ * - `serialized` — JSON string for API payload / storage
+ * - `hash` — MD5 hex digest of `serialized` for change detection
+ * - `version` — number of model versions (used as schema version in registration)
+ */
+export type ConfigurationSchema = Branded<'ConfigurationSchema', {
+    readonly schema: Readonly<Record<string, unknown>>;
+    readonly serialized: string;
+    readonly hash: string;
+    readonly version: number;
+}>;
+/**
+ * Generates the configuration schema from a validated model version.
+ * Wraps the pre-built entity schemas in an array with `anyOf` discriminator.
+ *
+ * `$defs` from individual entity schemas are hoisted to the root so that
+ * `$ref: "#/$defs/Name"` resolves correctly — JSON Schema `$ref` resolves
+ * from the document root, not from the `anyOf` item where the ref appears.
+ */
+export declare const ConfigurationSchema: (latestModel: ModelVersion, schemaVersion: number) => ConfigurationSchema;

package/dist/application-spec/parse-application-files/spec/model/configuration-schema.js

@@ -0,0 +1 @@
+import e from"spark-md5";import{Branded as t}from"@salsita-ai/common/utils";export const ConfigurationSchema=(s,o)=>{let r={},a=[];for(let e of s.entitySchemas){let t={...e.schema},s=t.$defs;s&&"object"==typeof s&&(Object.assign(r,s),delete t.$defs),a.push(t)}let i={type:"array",items:{anyOf:a}};Object.keys(r).length>0&&(i.$defs=r);let f=JSON.stringify(i),m=e.hash(f);return t({schema:i,serialized:f,hash:m,version:o})};

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

@@ -0,0 +1,38 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type EnhancedJsonObjectSchemaType, type JsonSchema, type ParseContext, type PhoenixDefinitions } from '../../../core/index.js';
+import type { MergedDataSchemas } from '../../merge/index.js';
+import type { AppMetadata, DataSpec } from '../sections/index.js';
+/**
+ * A data schema entry carrying both the enhanced schema (for type generation)
+ * and the precomputed AJV-ready runtime schema (with $refs resolved to $defs).
+ */
+export type DataSchemaEntry = Branded<'DataSchemaEntry', {
+    readonly enhanced: EnhancedJsonObjectSchemaType;
+    readonly runtimeSchema: JsonSchema;
+}>;
+/**
+ * Validated data schemas on parsed application specs with precomputed runtime schemas.
+ * Each field carries both the enhanced schema (phoenix refs) and the
+ * AJV-ready runtime schema ($refs resolved to local $defs).
+ */
+export type DataSchemas = Branded<'DataSchemas', {
+    readonly publishedData: DataSchemaEntry;
+    readonly publishedDataHash: string;
+    readonly sessionData: DataSchemaEntry;
+    readonly frontendData: DataSchemaEntry;
+    readonly backendData: DataSchemaEntry | undefined;
+    readonly finalizeData: DataSchemaEntry;
+    readonly prefetchedFinalizeData: DataSchemaEntry;
+    readonly finalizeResult: DataSchemaEntry;
+    readonly callbackData: DataSchemaEntry;
+}>;
+interface DataSchemasProps {
+    readonly merged: MergedDataSchemas;
+    readonly dataSpec: DataSpec;
+    readonly appMetadata: AppMetadata;
+    readonly phxDefinitions: PhoenixDefinitions;
+    readonly parsingContext: ParseContext;
+}
+/** Builds DataSchemas from MergedDataSchemas by precomputing runtime schemas for each field. */
+export declare const DataSchemas: (props: DataSchemasProps) => DataSchemas | undefined;
+export {};

package/dist/application-spec/parse-application-files/spec/model/data-schemas.js

@@ -0,0 +1 @@
+import{Branded as a}from"@salsita-ai/common/utils";import{buildPhxDefSchemas as e,toRuntimeSchema as t}from"../../../core/index.js";import{PublishedDataSchema as i}from"./published-data-schema.js";import{SessionDataSchema as s}from"./session-data-schema.js";let n=(e,i)=>a({enhanced:e,runtimeSchema:t(e,i)});export const DataSchemas=t=>{let{merged:o,dataSpec:r,appMetadata:l,phxDefinitions:c,parsingContext:D}=t,d=new Map(Object.entries(e(c))),h=i({publishedData:o.publishedData,dataSpec:r,parsingContext:D});if(!h)return;let m=s({sessionData:o.sessionData,appMetadata:l,parsingContext:D});if(m)return a({publishedData:n(h.schema,d),publishedDataHash:h.hash,sessionData:n(m,d),frontendData:n(o.frontendData,d),backendData:o.backendData?n(o.backendData,d):void 0,finalizeData:n(o.finalizeData,d),prefetchedFinalizeData:n(o.prefetchedFinalizeData,d),finalizeResult:n(o.finalizeResult,d),callbackData:n(o.callbackData,d)})};

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

@@ -0,0 +1,32 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type EnhancedJsonValue, 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';
+/**
+ * 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.
+ *
+ * **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.
+ */
+export type Defaults = Branded<'Defaults', {
+    readonly entries: Readonly<Record<EntityTypeName, DefaultEntries>>;
+}>;
+export declare const Defaults: (merged: MergedDefaults, latestModel: ModelVersion, ctx: ParseContext) => Defaults | undefined;

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

@@ -0,0 +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:_})};

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

@@ -0,0 +1,55 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type EnhancedJsonSchemaType, type JsonSchema, type ParseContext, type PhoenixDefinitions } from '../../../core/index.js';
+import type { CommonTypes } from './common-types.js';
+import type { AliasName } from './names/alias-name.js';
+import type { EntityOrAliasName } from './names/entity-or-alias-name.js';
+import type { EntityTypeName } from './names/entity-type-name.js';
+import type { ShapePropertyName } from './names/shape-property-name.js';
+import { type ResolvedShape } from './resolved-shapes.js';
+/**
+ * Unified map of all available definitions for $ref resolution.
+ * Merges commonTypes and phoenix definition schemas into a single lookup.
+ */
+export type ModelSchemaContext = Branded<'ModelSchemaContext', ReadonlyMap<string, EnhancedJsonSchemaType>>;
+/** Builds a ModelSchemaContext by merging commonTypes and phoenix definition schemas. */
+export declare const ModelSchemaContext: (commonTypes: CommonTypes, phxDefinitions: PhoenixDefinitions) => ModelSchemaContext;
+/** A single AJV validation error flattened to just what downstream diagnostics need. */
+export interface SchemaValidationError {
+    readonly instancePath: string;
+    readonly message: string;
+}
+/** Result of validating a value against an entity shape schema. */
+export interface SchemaValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly SchemaValidationError[];
+}
+/** Validates a value against a pre-compiled AJV schema and returns a flat result. */
+export type ValidateShape = (value: unknown) => SchemaValidationResult;
+/**
+ * Schema for a single entity type — both raw (for TS type generation) and
+ * AJV-ready (for runtime validation / server registration).
+ *
+ * - `entityType` — concrete entity type name
+ * - `shapeProperties` — merged alias + direct properties with phoenix extensions intact
+ * - `schema` — AJV-ready schema with custom keywords stripped and $refs in `$defs`
+ * - `contributingAliases` — alias names whose shapes contributed properties
+ * - `contributingShapes` — all shape keys (alias + direct) that contributed properties
+ * - `hasDirectShape` — whether this entity has its own direct shape entry
+ * - `validateShape` / `validatePartialShape` — pre-compiled AJV validators for the
+ *   shape schema (full vs. all-top-level-properties-optional). Shared instance,
+ *   lazily compiled on first call.
+ */
+export type EntitySchema = Branded<'EntitySchema', {
+    readonly entityType: EntityTypeName;
+    readonly shapeProperties: Readonly<Record<ShapePropertyName, EnhancedJsonSchemaType>>;
+    /** Full schema with id + type — used for deployment registration (ConfigurationSchema). */
+    readonly schema: JsonSchema;
+    /** Shape-only schema without id/type — used for DomainEntityReflection in generated code. */
+    readonly shapeSchema: JsonSchema;
+    readonly contributingAliases: readonly AliasName[];
+    readonly contributingShapes: readonly EntityOrAliasName[];
+    readonly hasDirectShape: boolean;
+    readonly validateShape: ValidateShape;
+    readonly validatePartialShape: ValidateShape;
+}>;
+export declare const EntitySchema: (entityType: EntityTypeName, resolvedShape: ResolvedShape, runtimeCtx: ModelSchemaContext, ctx: ParseContext) => EntitySchema;

package/dist/application-spec/parse-application-files/spec/model/entity-schema.js

@@ -0,0 +1 @@
+import{Ajv as e}from"ajv";import{Branded as t}from"@salsita-ai/common/utils";import{buildPhxDefSchemas as r,toPartialShapeSchema as i,toRuntimeSchema as s}from"../../../core/index.js";import{DiagnosticCode as o,diagnosticMessages as a}from"../../../errors/index.js";import{IMPLICIT_ENTITY_FIELDS as n}from"./resolved-shapes.js";export const ModelSchemaContext=(e,i)=>{let s=new Map;for(let[t,r]of e)s.set(t,r.schema);for(let[e,t]of Object.entries(r(i)))s.set(e,t);return t(s)};let p=new e({allowUnionTypes:!0,useDefaults:!1,strict:!1}),l=(e,t,r)=>{let i=null,s=()=>[];return o=>{if(!i)try{let e=p.compile(r());i=e,s=()=>(e.errors??[]).map(e=>({instancePath:e.instancePath,message:e.message??""}))}catch(i){let r=i instanceof Error?i.message:String(i);throw Error(`Failed to compile ${t} shape validator for entity "${String(e)}": ${r}. The entity shape schema is malformed — this is a pipeline bug, not a user input issue. Inspect the resolved shapeSchema and fix the schema-generation step.`,i instanceof Error?{cause:i}:void 0)}let a=i(o);return{valid:a,errors:a?[]:s()}}};export const EntitySchema=(e,r,p,c)=>{let h=r.properties;for(let t of Object.keys(h))n.has(t)&&c.error(o.RESERVED_PROPERTY,a.RESERVED_PROPERTY(t,String(e)));let m=Object.keys(h),u={type:"object",properties:{id:{type:"string"},type:{type:"string",enum:[String(e)]},...h},required:["id","type",...m],additionalProperties:!1},d={type:"object",properties:{...h},required:m,additionalProperties:!1},f=s(u,p),g=s(d,p);return t({entityType:e,shapeProperties:h,schema:f,shapeSchema:g,contributingAliases:r.contributingAliases,contributingShapes:r.contributingShapes,hasDirectShape:r.hasOwnShape,validateShape:l(e,"full",()=>g),validatePartialShape:l(e,"partial",()=>i(g))})};

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

@@ -0,0 +1,15 @@
+import { Branded } from '@salsita-ai/common/utils';
+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[]>;
+/**
+ * Validates and brands entity type names from a merged model version.
+ * Checks PascalCase naming and rejects duplicates.
+ */
+export declare const EntityTypes: (merged: MergedModelVersion, ctx: ParseContext) => EntityTypes | undefined;

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

@@ -0,0 +1 @@
+import{Branded as r}from"@salsita-ai/common/utils";import{DiagnosticCode as t,diagnosticMessages as e}from"../../../errors/index.js";import{EntityTypeName as o}from"./names/entity-type-name.js";export const EntityTypes=(s,i)=>{let m=new Set,n=[];for(let r of s.entityTypes??[]){let s=o(r,i);s&&n.push(s),m.has(r)&&i.error(t.DUPLICATE_ENTITY_TYPE,e.DUPLICATE_ENTITY_TYPE(r)),m.add(r)}if(!i.hasErrors)return r(n)};

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

@@ -0,0 +1,15 @@
+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';

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

@@ -0,0 +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";

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

@@ -0,0 +1,6 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../core/index.js';
+/** Branded string for a model version key ("latest", "v1", "v2", etc.). */
+export type ModelVersionKey = Branded<'ModelVersionKey', string>;
+/** 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/model-version-key.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 e=/^(latest|v\d+)$/;export const ModelVersionKey=(s,i)=>e.test(s)?o(s):void i.error(r.INVALID_VERSION_KEY,t.INVALID_VERSION_KEY(s));

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

@@ -0,0 +1,46 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type ParseContext, type PhoenixDefinitions } from '../../../core/index.js';
+import type { MergedModelVersion } from '../../merge/index.js';
+import { Aliases } from './aliases.js';
+import { CommonTypes } from './common-types.js';
+import { EntitySchema } from './entity-schema.js';
+import { EntityTypes } from './entity-types.js';
+import { ModelVersionKey } from './model-version-key.js';
+import type { EntityOrAliasName } from './names/entity-or-alias-name.js';
+import type { EntityTypeName } from './names/entity-type-name.js';
+import { ResolvedShapes } from './resolved-shapes.js';
+import { Shapes } from './shapes/shapes.js';
+/**
+ * A fully resolved and validated model version with branded types.
+ * Contains entity types, aliases, shapes (property schemas), and commonTypes.
+ * Constructed by the `ModelVersion()` factory which orchestrates parsing of all sub-sections
+ * and validates cross-section name uniqueness.
+ */
+export type ModelVersion = Branded<'ModelVersion', {
+    readonly versionKey: ModelVersionKey;
+    readonly entityTypes: EntityTypes;
+    /** Entity types allowed as preset root — members of the RootEntity alias, or all entity types if no RootEntity alias. */
+    readonly rootEntityTypes: readonly EntityTypeName[];
+    readonly aliases: Aliases;
+    readonly shapes: Shapes;
+    readonly resolvedShapes: ResolvedShapes;
+    readonly commonTypes: CommonTypes;
+    readonly entitySchemas: readonly EntitySchema[];
+    /**
+     * Precomputed union of entity type names and alias names — used by downstream validators
+     * (relations, expressions) to check whether a string refers to any declared name in the model.
+     * Populated from the name-clash check sets already built during construction.
+     */
+    readonly allNames: ReadonlySet<EntityOrAliasName>;
+}>;
+/**
+ * Parses and validates a merged model version into a fully branded `ModelVersion`.
+ *
+ * Orchestrates parsing of all sub-sections (entityTypes, commonTypes, shapes, aliases)
+ * and then validates cross-section name uniqueness:
+ * - commonType names must not clash with entity type or alias names
+ * - alias names must not clash with entity type names
+ *
+ * Returns `undefined` if any sub-section fails or name clashes are detected.
+ */
+export declare const ModelVersion: (key: string, merged: MergedModelVersion, phxDefinitions: PhoenixDefinitions, ctx: ParseContext) => ModelVersion | undefined;

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

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as t,diagnosticMessages as r}from"../../../errors/index.js";import{Aliases as s,ROOT_ENTITY_ALIAS as o}from"./aliases.js";import{CommonTypes as a}from"./common-types.js";import{EntitySchema as i,ModelSchemaContext as n}from"./entity-schema.js";import{EntityTypes as p}from"./entity-types.js";import{ModelVersionKey as m}from"./model-version-key.js";import{ResolvedShapes as l,getResolvedShape as y}from"./resolved-shapes.js";import{Shapes as S}from"./shapes/shapes.js";export const ModelVersion=(f,h,E,A)=>{let M=m(f,A),T=A.startSpan("EntityTypes","ModelVersion","entity-types.ts"),N=p(h,A.at("entityTypes"));T();let _=A.startSpan("CommonTypes","ModelVersion","common-types.ts"),d=a(h,f,E,A.at("commonTypes"));if(_(),!M||!N||!d||A.hasErrors)return;let c=A.startSpan("Shapes","ModelVersion","shapes.ts"),j=S(h,f,E,d,A.at("shapes"));if(c(),!j||A.hasErrors)return;let u=A.startSpan("Aliases","ModelVersion","aliases.ts"),C=s(h,N,A.at("aliases"));if(u(),!C||A.hasErrors)return;let H=new Set(N.map(String)),I=new Set([...C.keys()].map(String));for(let e of new Set([...d.keys()]))H.has(e)&&A.error(t.NAME_CLASH,r.NAME_CLASH("commonType",e,"entity type")),I.has(e)&&A.error(t.NAME_CLASH,r.NAME_CLASH("commonType",e,"alias"));for(let e of I)H.has(String(e))&&A.error(t.NAME_CLASH,r.NAME_CLASH("alias",e,"entity type"));if(A.hasErrors)return;let L=C.get(o);if(!L)return void A.error(t.MISSING_ROOT_ENTITY,r.MISSING_ROOT_ENTITY());let g=n(d,E),V=l(N,C,j),k=[];for(let e of N)k.push(i(e,y(V,e),g,A.at("shapes",String(e))));let w=new Set([...N,...C.keys()]);return e({versionKey:M,entityTypes:N,rootEntityTypes:L,aliases:C,shapes:j,resolvedShapes:V,commonTypes:d,entitySchemas:k,allNames:w})};

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

@@ -0,0 +1,11 @@
+import { Branded } from '@salsita-ai/common/utils';
+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>;
+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/alias-name.js

@@ -0,0 +1 @@
+import{Branded as A}from"@salsita-ai/common/utils";import{DiagnosticCode as E,diagnosticMessages as o}from"../../../../errors/index.js";let r=/^[A-Z]\w*$/;export const RESERVED_ALIAS_NAMES=["AnyDomainEntity"];export const AliasName=(t,i)=>r.test(t)?RESERVED_ALIAS_NAMES.includes(t)?void i.error(E.RESERVED_ALIAS_NAME,o.RESERVED_ALIAS_NAME(t)):A(t):void i.error(E.INVALID_ALIAS_NAME,o.INVALID_ALIAS_NAME(t));

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

@@ -0,0 +1,11 @@
+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;
+/** 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-or-alias-name.js

@@ -0,0 +1 @@
+import{Branded as t}from"@salsita-ai/common/utils";import{AliasName as i}from"./alias-name.js";import{EntityTypeName as m}from"./entity-type-name.js";export const EntityOrAliasName=(o,r)=>{if(m(o,r)||i(o,r))return t(o)};

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

@@ -0,0 +1,11 @@
+import { Branded } from '@salsita-ai/common/utils';
+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>;
+/** 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/entity-type-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 e=/^[A-Z]\w*$/;export const EntityTypeName=(i,m)=>e.test(i)?o(i):void m.error(r.INVALID_ENTITY_TYPE_NAME,t.INVALID_ENTITY_TYPE_NAME(i));

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

@@ -0,0 +1,9 @@
+import { Branded } from '@salsita-ai/common/utils';
+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>;
+/** Validates that a name follows the expression naming convention ($camelCase). */
+export declare const ExpressionName: (name: string, ctx: ParseContext) => ExpressionName | undefined;