@salsita-ai/sdk 0.50.0-develop.b7caacb493 → 0.50.0-develop.b929a82a82

package/dist/domain/spec/components/bindings/write-binding.d.ts

@@ -0,0 +1,32 @@
+import type { Branded } from '@salsita-ai/common/utils';
+/**
+ * Runtime type assertion to emit in the write callback.
+ * Resolved from the target entity field's schema during parsing.
+ */
+export type AssertionKind = {
+    readonly kind: 'declaredType';
+    readonly typeName: string;
+} | {
+    readonly kind: 'declaredTypeId';
+    readonly referencedType: string;
+} | {
+    readonly kind: 'primitive';
+    readonly assertFn: 'assertString' | 'assertNumber' | 'assertBoolean';
+} | {
+    readonly kind: 'literal';
+    readonly value: null;
+} | {
+    readonly kind: 'anyOf';
+    readonly assertions: readonly AssertionKind[];
+} | {
+    readonly kind: 'none';
+};
+/**
+ * A validated `$write` or `$bind` mapping from a component state key to an entity field.
+ * Includes the resolved assertion kind for runtime type checking in the write callback.
+ */
+export type ComponentWriteBinding = Branded<'ComponentWriteBinding', {
+    readonly propKey: string;
+    readonly entityField: string;
+    readonly assertion: AssertionKind;
+}>;

package/dist/domain/spec/components/bindings/write-binding.js

@@ -0,0 +1 @@
+export{};

package/dist/{application-spec/parse-application-files → domain}/spec/components/component-entry.d.ts

@@ -1,9 +1,9 @@
 import type { Branded } from '@salsita-ai/common/utils';
-import type { SdkCodeRef } from '../../../core/index.js';
-import type { MemoEvalPlan, MemoEvalPlanInput } from '../expressions/memo-eval-plan.js';
+import type { MemoEvalPlan, MemoEvalPlanInput } from '../expressions/index.js';
 import type { EntityOrAliasName, InstanceName } from '../model/index.js';
 import type { ComponentReadBinding, ComponentWriteBinding } from './bindings/index.js';
-import type { ComponentFilters } from './component-filter.js';
+import type { ComponentFilters } from './component-filters.js';
+import type { SdkCodeRef } from './sdk-code-ref.js';
 /**
  * Root-level `$read` variant — the entire instance state is driven by a single
  * `$read` at the root (components.md §"Root-Level $read"). No `resolvedProps`

package/dist/domain/spec/components/component-entry.js

@@ -0,0 +1 @@
+export{};

package/dist/{application-spec/core → domain/spec}/components/component-filter.d.ts

@@ -17,7 +17,8 @@ export type FilterCriterion<T> = {
     readonly code: string;
 };
 /**
- * Parsed component filter controlling when the component is active. Two
+ * Parsed component filter controlling when the component is active, as the application spec
+ * declares it under `$filter`; `application-spec` exports it as `ComponentFilter`. Two
  * mutually-exclusive shapes:
  *
  * - `'gradual'` — zero or more per-criterion fields; compiles to one entry per
@@ -29,7 +30,7 @@ export type FilterCriterion<T> = {
  *
  * See `components.md §"Simple expression filter"` / `§"Declarative filter"`.
  */
-export type ComponentFilter = {
+export type SpecComponentFilter = {
     readonly kind: 'gradual';
     readonly navigationStates?: FilterCriterion<readonly string[]>;
     readonly viewStates?: FilterCriterion<readonly string[]>;

package/dist/domain/spec/components/component-filters.d.ts

@@ -0,0 +1,10 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { SpecComponentFilter } from './component-filter.js';
+/**
+ * Validated set of `$filter` entries on a user-bound component instance. Each
+ * {@link SpecComponentFilter} represents one alternative filter condition; multiple
+ * entries arise from `$or`. Empty `items` means no filter is applied.
+ */
+export type ComponentFilters = Branded<'ComponentFilters', {
+    readonly items: readonly SpecComponentFilter[];
+}>;

package/dist/domain/spec/components/component-filters.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,4 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { ComponentEntry } from './component-entry.js';
+/** Final merged components for a domain, including SDK/spec-derived entries. */
+export type Components = Branded<'Components', readonly ComponentEntry[]>;

package/dist/domain/spec/components/components.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,6 @@
+export type * from './bindings/index.js';
+export type * from './component-entry.js';
+export * from './component-filter.js';
+export type * from './component-filters.js';
+export type * from './components.js';
+export * from './sdk-code-ref.js';

package/dist/domain/spec/enhanced-json/enhanced-json-value.d.ts

@@ -0,0 +1,30 @@
+import type { EvalMarker, MsgMarker } from '../markers/index.js';
+/**
+ * A JSON-serialisable value augmented with Phoenix structural markers:
+ * `$msg` (i18n) and `$eval` (self-scoped code).
+ *
+ * Single shared shape across components, expressions, and defaults — lowered
+ * either to TypeScript source via `stringifyEnhancedJsonValue` or to a
+ * runtime value via `resolveEnhancedJsonValue`, both of `application-spec`.
+ *
+ * Which markers are allowed at a given slot is controlled by
+ * `EnhancedJsonValueCaps` of `application-spec`, not by the type — all markers parse
+ * identically, capability checks kick in at lowering time.
+ */
+export type EnhancedJsonValue = string | number | boolean | null | MsgMarker | EvalMarker | EnhancedJsonArray | EnhancedJsonObject;
+/** Array form of {@link EnhancedJsonValue} — extracted as a named interface so `z.lazy` can close the recursion. */
+export interface EnhancedJsonArray extends ReadonlyArray<EnhancedJsonValue> {
+}
+/** Object form of {@link EnhancedJsonValue} — extracted for the same reason as {@link EnhancedJsonArray}. */
+export interface EnhancedJsonObject {
+    readonly [key: string]: EnhancedJsonValue;
+}
+/** Runtime `self` accessor — shape-agnostic entity state. */
+export type SelfAccessor = object;
+/**
+ * Deterministic string key for a value — sorted object keys, JSON-encoded.
+ * Used by the expression runtime's reference store to preserve an evaluator when the
+ * underlying value is structurally unchanged (mirrors the content-hash pattern
+ * used for components).
+ */
+export declare const canonicalEnhancedJsonValueKey: (value: EnhancedJsonValue) => string;

package/dist/domain/spec/enhanced-json/enhanced-json-value.js

@@ -0,0 +1 @@
+export const canonicalEnhancedJsonValueKey=r=>{let e=r=>{if(null===r||"object"!=typeof r)return r;if(Array.isArray(r))return r.map(e);let t={};for(let n of Object.keys(r).sort())t[n]=e(r[n]);return t};return JSON.stringify(e(r))};

package/dist/domain/spec/enhanced-json/index.d.ts

@@ -0,0 +1 @@
+export * from './enhanced-json-value.js';

package/dist/domain/spec/enhanced-json/index.js

@@ -0,0 +1 @@
+export*from"./enhanced-json-value.js";

package/dist/{application-spec/parse-application-files → domain}/spec/expressions/expression.d.ts

@@ -1,7 +1,9 @@
 import type { Branded } from '@salsita-ai/common/utils';
-import type { EnhancedJsonSchemaType, EnhancedJsonValue, SdkExpressionImplementation } from '../../../core/index.js';
+import type { EnhancedJsonSchemaType } from '../../core/index.js';
+import type { EnhancedJsonValue } from '../enhanced-json/index.js';
 import type { EntityOrAliasName, ExpressionName } from '../model/index.js';
 import type { MemoEvalPlan } from './memo-eval-plan.js';
+import type { SdkExpressionImplementation } from './sdk-expression-implementation.js';
 /**
  * How an expression's runtime implementation is provided.
  * - `user`: implementation from `src/expressions/*.ts` (dynamic import)
@@ -22,8 +24,12 @@ export type ExpressionImplementation = {
     readonly value: EnhancedJsonValue;
     readonly plan: MemoEvalPlan;
 };
-/** A single parsed expression declaration. */
-export type Expression = Branded<'Expression', {
+/**
+ * A single parsed expression declaration of the application spec: the entity or alias it belongs
+ * to, its name, its schemas and how its implementation is provided. `application-spec` exports it
+ * as `Expression`.
+ */
+export type SpecExpression = Branded<'Expression', {
     readonly entityKey: EntityOrAliasName;
     readonly name: ExpressionName;
     /**

package/dist/domain/spec/expressions/expression.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,27 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { EntityOrAliasName, EntityTypeName, ExpressionName } from '../model/index.js';
+import type { SpecExpression } from './expression.js';
+import type { MemoEvalPlan } from './memo-eval-plan.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, SpecExpression>>;
+    readonly entityExpressions: ReadonlyMap<EntityTypeName, EntityExpressions>;
+    readonly constants: ReadonlyMap<EntityOrAliasName, ReadonlyMap<ExpressionName, MemoEvalPlan>>;
+}>;

package/dist/domain/spec/expressions/expressions.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,5 @@
+export type * from './expression.js';
+export type * from './expressions.js';
+export type * from './memo-eval-plan.js';
+export type * from './relation-expression-params.js';
+export * from './sdk-expression-implementation.js';

package/dist/domain/spec/expressions/memo-eval-plan.d.ts

@@ -0,0 +1,70 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { ComponentPropTarget, EvalMarker, MsgMarker } from '../markers/index.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;
+}>;

package/dist/domain/spec/expressions/memo-eval-plan.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/expressions/relation-expression-params.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,4 @@
+export type { AdminPagesSection } from './application/index.js';
+export * from './errors/index.js';
+export * from './modules/index.js';
+export * from './sections/index.js';

package/dist/domain/spec/index.js

@@ -0,0 +1 @@
+export*from"./errors/index.js";export*from"./modules/index.js";export*from"./sections/index.js";

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

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

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

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/invariants/invariant.d.ts

@@ -0,0 +1,24 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { MsgMarker } from '../markers/index.js';
+import type { 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 of the application spec. `application-spec`
+ * exports it as `Invariant`.
+ */
+export type SpecInvariant = StaticInvariant | DynamicInvariant;

package/dist/domain/spec/invariants/invariant.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,14 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { ComponentEntry } from '../components/index.js';
+import type { SpecExpression } from '../expressions/index.js';
+import type { EntityOrAliasName, InvariantName } from '../model/index.js';
+import type { SpecInvariant } 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, SpecInvariant>>>>;
+    readonly expressions: readonly SpecExpression[];
+    readonly components: readonly ComponentEntry[];
+}>;

package/dist/domain/spec/invariants/invariants.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/json-schema.d.ts

@@ -0,0 +1,52 @@
+import type { JsonSchemaType } from '../core/index.js';
+/**
+ * Plain AJV-ready JSON Schema — the output of `toRuntimeSchema` in `application-spec`.
+ *
+ * Identical in structure to `EnhancedJsonSchemaType` except the Phoenix-only
+ * extensions (`tsType`, `import`, `references`) are gone; those are
+ * stripped by `stripCustomKeywords` before this type is produced. All `$ref`
+ * targets are local (`#/$defs/{name}`) — no external references remain. Shapes
+ * stored under `$defs` are themselves `JsonSchema`s.
+ *
+ * Use this type anywhere the runtime AJV shape is required (validators,
+ * serializers, migration tools). Schema producers (`Shapes`, `CommonTypes`,
+ * relation inference) keep using `EnhancedJsonSchemaType`.
+ */
+export interface JsonSchema {
+    readonly id?: string;
+    readonly $ref?: string;
+    readonly $schema?: string;
+    readonly $defs?: Readonly<Record<string, JsonSchema>>;
+    readonly title?: string;
+    readonly description?: string;
+    readonly default?: unknown;
+    readonly format?: string;
+    readonly multipleOf?: number;
+    readonly maximum?: number;
+    readonly exclusiveMaximum?: boolean;
+    readonly minimum?: number;
+    readonly exclusiveMinimum?: boolean;
+    readonly maxLength?: number;
+    readonly minLength?: number;
+    readonly pattern?: string;
+    readonly additionalItems?: boolean | JsonSchema;
+    readonly items?: JsonSchema | readonly JsonSchema[];
+    readonly maxItems?: number;
+    readonly minItems?: number;
+    readonly uniqueItems?: boolean;
+    readonly maxProperties?: number;
+    readonly minProperties?: number;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean | JsonSchema;
+    readonly definitions?: Readonly<Record<string, JsonSchema>>;
+    readonly properties?: Readonly<Record<string, JsonSchema>>;
+    readonly patternProperties?: Readonly<Record<string, JsonSchema>>;
+    readonly dependencies?: Readonly<Record<string, JsonSchema | readonly string[]>>;
+    readonly enum?: readonly unknown[];
+    readonly type?: JsonSchemaType | readonly JsonSchemaType[];
+    readonly allOf?: readonly JsonSchema[];
+    readonly anyOf?: readonly JsonSchema[];
+    readonly oneOf?: readonly JsonSchema[];
+    readonly not?: JsonSchema;
+    readonly [k: string]: unknown;
+}

package/dist/domain/spec/json-schema.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,3 @@
+export * from './component-prop-target.js';
+export * from './eval-marker.js';
+export * from './msg-marker.js';

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

@@ -0,0 +1 @@
+export*from"./component-prop-target.js";export*from"./eval-marker.js";export*from"./msg-marker.js";

package/dist/domain/spec/markers/msg-marker.d.ts

@@ -0,0 +1,28 @@
+import type { MessageDescriptor } from '@lingui/core';
+import { z } from 'zod';
+/** Key literal for the `$msg` marker in raw YAML. */
+export declare const MSG_MARKER_KEY: '$msg';
+/** Key literal for the optional `$msgId` qualifier on `$msg`. */
+export declare const MSG_ID_MARKER_KEY: '$msgId';
+/**
+ * YAML marker produced by `$msg: 'text'` / `$msg: 'text', $msgId: 'id'` entries.
+ * `$msgId` is a qualifier on `$msg`, not a standalone marker.
+ */
+export interface MsgMarker {
+    readonly $msg: string;
+    readonly $msgId?: string;
+}
+/** Zod decoder for {@link MsgMarker}. Strict — rejects extra keys. */
+export declare const msgMarkerSchema: z.ZodObject<{
+    $msg: z.ZodString;
+    $msgId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    $msg: string;
+    $msgId?: string | undefined;
+}, {
+    $msg: string;
+    $msgId?: string | undefined;
+}>;
+/** Structural type guard for {@link MsgMarker}. */
+export declare const isMsgMarker: (value: unknown) => value is MsgMarker;
+export declare const createMessageDescriptor: (marker: MsgMarker) => MessageDescriptor;

package/dist/domain/spec/markers/msg-marker.js

@@ -0,0 +1 @@
+import{generateMessageId as s}from"@lingui/message-utils/generateMessageId";import{z as e}from"zod";export const MSG_MARKER_KEY="$msg";export const MSG_ID_MARKER_KEY="$msgId";export const msgMarkerSchema=e.object({$msg:e.string(),$msgId:e.string().optional()}).strict();export const isMsgMarker=s=>msgMarkerSchema.safeParse(s).success;export const createMessageDescriptor=e=>({id:e.$msgId??s(e.$msg),message:e.$msg});

package/dist/domain/spec/model/aliases.d.ts

@@ -0,0 +1,9 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { AliasName, EntityTypeName } from './names/index.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. `application-spec` exports it as `Aliases`.
+ */
+export type SpecAliases = Branded<'Aliases', ReadonlyMap<AliasName, readonly EntityTypeName[]>>;

package/dist/domain/spec/model/aliases.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/model/common-types.d.ts

@@ -0,0 +1,15 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { EnhancedJsonSchemaType } from '../../core/index.js';
+import type { JsonSchema } from '../json-schema.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>>;

package/dist/domain/spec/model/common-types.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/model/defaults.d.ts

@@ -0,0 +1,33 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { EnhancedJsonValue } from '../enhanced-json/index.js';
+import type { EntityTypeName, ShapePropertyName } from './names/index.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`; at run time
+ * `createRecipeFactory` makes the generated `createRecipe` factory from them.
+ */
+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.
+ *
+ * A source key may state part of a shape, but the flattened entry of a concrete
+ * entity type states every property of its shape: `createRecipeFactory` validates
+ * each entry as a whole entity when the generated module loads. An entity type
+ * with no entry has no defaults and is not checked.
+ *
+ * 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>>;
+}>;

package/dist/domain/spec/model/defaults.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/model/entity-types.d.ts

@@ -0,0 +1,8 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { EntityTypeName } from './names/index.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[]>;

package/dist/domain/spec/model/entity-types.js

@@ -0,0 +1 @@
+export{};

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

@@ -0,0 +1,7 @@
+export type * from './aliases.js';
+export type * from './common-types.js';
+export type * from './defaults.js';
+export type * from './entity-types.js';
+export type * from './model-version-key.js';
+export type * from './names/index.js';
+export type * from './presets.js';

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

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/model/model-version-key.d.ts

@@ -0,0 +1,3 @@
+import type { Branded } from '@salsita-ai/common/utils';
+/** Branded string for a model version key ("latest", "v1", "v2", etc.). */
+export type ModelVersionKey = Branded<'ModelVersionKey', string>;

package/dist/domain/spec/model/model-version-key.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/model/names/action-name.d.ts

@@ -0,0 +1,7 @@
+import type { Branded } from '@salsita-ai/common/utils';
+/**
+ * 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>;

package/dist/domain/spec/model/names/action-name.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/model/names/alias-name.d.ts

@@ -0,0 +1,7 @@
+import type { Branded } from '@salsita-ai/common/utils';
+/**
+ * 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>;

package/dist/domain/spec/model/names/alias-name.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/model/names/entity-or-alias-name.d.ts

@@ -0,0 +1,8 @@
+import type { AliasName } from './alias-name.js';
+import type { 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;

package/dist/domain/spec/model/names/entity-or-alias-name.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/model/names/entity-type-name.d.ts

@@ -0,0 +1,8 @@
+import type { Branded } from '@salsita-ai/common/utils';
+/**
+ * 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>;

package/dist/domain/spec/model/names/entity-type-name.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/spec/model/names/expression-name.d.ts

@@ -0,0 +1,6 @@
+import type { Branded } from '@salsita-ai/common/utils';
+/**
+ * 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>;

package/dist/domain/spec/model/names/expression-name.js

@@ -0,0 +1 @@
+export{};