@salsita-ai/sdk 0.50.0-develop.f101f4c3c9 → 0.50.0-develop.f16492b14e

package/dist/domain/mocks/create-mock-domain-runtime.d.ts

@@ -83,6 +83,7 @@ export declare const createMockDomainRuntime: <ENTITIES extends DomainEntity<str
             selectElementSlots: import("@salsita-ai/common/utils").Selector<import("../index.js").SpecSelectorState, {
                 entityElements: Record<string, (props: import("../index.js").CustomPhoenixEntityElementProps) => JSX.Element>;
                 layoutElements: Record<string, (props: import("react").PropsWithChildren) => JSX.Element>;
+                assistantFormElements: Record<string, import("react").ComponentType<never>>;
                 hashes: Record<string, string>;
             }>;
             selectDataConfig: import("@salsita-ai/common/utils").Selector<import("../index.js").SpecSelectorState, import("../index.js").DataSpec | null>;
@@ -126,6 +127,7 @@ export declare const createMockDomainRuntime: <ENTITIES extends DomainEntity<str
             getElementSlots: () => {
                 entityElements: Record<string, (props: import("../index.js").CustomPhoenixEntityElementProps) => JSX.Element>;
                 layoutElements: Record<string, (props: import("react").PropsWithChildren) => JSX.Element>;
+                assistantFormElements: Record<string, import("react").ComponentType<never>>;
                 hashes: Record<string, string>;
             };
             getDataConfig: () => import("../index.js").DataSpec | null;
@@ -339,6 +341,8 @@ export declare const createMockDomainRuntime: <ENTITIES extends DomainEntity<str
         webComponent: {
             selectReadonly: import("@salsita-ai/common/utils").Selector<import("../index.js").WebComponentSelectorState, boolean>;
             getReadonly: () => boolean;
+            selectLocale: import("@salsita-ai/common/utils").Selector<import("../index.js").WebComponentSelectorState, string>;
+            getLocale: () => string;
             getWebcomponentGeneration: () => number;
         };
         domainContext: {
@@ -412,6 +416,7 @@ export declare const createMockDomainRuntime: <ENTITIES extends DomainEntity<str
                 getMigrate: () => import("../index.js").MigrateFunction<DomainEntity<string>>;
                 getActiveMode: () => import("../index.js").DomainMode;
                 getIsInitialized: () => boolean;
+                getIsViewMode: () => boolean;
                 getComponentReaderIndexes: () => import("../index.js").ComponentReaderIndexes;
                 getStoreRuntimeDependencies: () => {
                     componentReaderIndexes: import("../index.js").ComponentReaderIndexes;
@@ -521,6 +526,7 @@ export declare const createMockDomainRuntime: <ENTITIES extends DomainEntity<str
                 getMigrate: () => import("../index.js").MigrateFunction<DomainEntity<string>>;
                 getActiveMode: () => import("../index.js").DomainMode;
                 getIsInitialized: () => boolean;
+                getIsViewMode: () => boolean;
                 getComponentReaderIndexes: () => import("../index.js").ComponentReaderIndexes;
                 getStoreRuntimeDependencies: () => {
                     componentReaderIndexes: import("../index.js").ComponentReaderIndexes;
@@ -625,6 +631,9 @@ export declare const createMockDomainRuntime: <ENTITIES extends DomainEntity<str
             };
         };
     };
+    hostMirrorActions: {
+        setLocale: (locale: string) => void;
+    };
     getState: () => import("../index.js").DomainRuntimeState;
     subscribe: (callback: () => void) => () => void;
 };

package/dist/domain/spec/application/admin-pages-section.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The `$adminPages` section of an admin spec file as it is written, which the parsed admin pages
+ * keep as their `spec`. `application-spec` exports it as `RawAdminPages`, and the application
+ * config takes it as `AdminPagesSpec`.
+ */
+export interface AdminPagesSection {
+    readonly presets?: boolean | {
+        readonly categoryNavigationState?: string;
+        readonly presetNavigationState?: string;
+    };
+    readonly recipes?: ReadonlyArray<{
+        readonly name: string;
+        readonly navigationState?: string;
+    }>;
+    readonly pages?: ReadonlyArray<{
+        readonly key: string;
+        readonly title: string;
+        readonly icon?: string;
+        readonly navigationState?: string;
+        readonly entity?: string;
+        readonly component?: string;
+        readonly actionsComponent?: string;
+        readonly connectedDataEntry?: string;
+        readonly sidebar?: {
+            readonly title: string;
+            readonly component: string;
+        };
+    }>;
+}

package/dist/domain/spec/application/admin-pages.d.ts

@@ -0,0 +1,26 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { ComponentEntry } from '../components/index.js';
+import type { AdminPagesSection } from './admin-pages-section.js';
+/**
+ * The parsed admin pages of an admin spec: the `$adminPages` section as written, the components
+ * the pages attach, the items of the admin navigation and the navigation states the pages add.
+ */
+export type AdminPages = Branded<'AdminPages', {
+    readonly spec: AdminPagesSection;
+    readonly components: readonly ComponentEntry[];
+    readonly navigationItems: readonly AdminNavigationItem[];
+    readonly navigationStates: readonly string[];
+}>;
+interface AdminNavigationListItem {
+    readonly label: string;
+    readonly icon?: string;
+    readonly navigationStates: readonly string[];
+}
+interface AdminNestedNavigationListItem {
+    readonly label: string;
+    readonly icon?: string;
+    readonly items: ReadonlyArray<Omit<AdminNavigationListItem, 'icon'>>;
+}
+/** One item of the admin navigation: a list item, or a nested list of them. */
+export type AdminNavigationItem = AdminNavigationListItem | AdminNestedNavigationListItem;
+export {};

package/dist/domain/spec/application/admin-states.d.ts

@@ -0,0 +1,5 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { StateValue } from '../sections/index.js';
+export type AdminStates = Branded<'AdminStates', {
+    readonly navigationStates: readonly StateValue[];
+}>;

package/dist/domain/spec/application/configurator-states.d.ts

@@ -0,0 +1,8 @@
+import type { Branded } from '@salsita-ai/common/utils';
+import type { StateValue } from '../sections/index.js';
+export type ConfiguratorStates = Branded<'ConfiguratorStates', {
+    readonly navigationStates: readonly StateValue[];
+    readonly viewStates: readonly StateValue[];
+    readonly toolStates: readonly StateValue[];
+    readonly exportStates: readonly StateValue[];
+}>;

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

@@ -0,0 +1,5 @@
+export type * from './admin-pages.js';
+export type * from './admin-pages-section.js';
+export type * from './admin-states.js';
+export * from './application-instance.js';
+export type * from './configurator-states.js';

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

@@ -0,0 +1 @@
+export*from"./application-instance.js";

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

@@ -0,0 +1,2 @@
+export type * from './read-binding.js';
+export type * from './write-binding.js';

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

@@ -0,0 +1,13 @@
+import type { Branded } from '@salsita-ai/common/utils';
+/**
+ * A validated `$read` dependency found anywhere in the component props tree.
+ * Used for memoEval dependency tracking — the target becomes `self.target` in generated code.
+ * Field targets are validated against the entity shape; expression targets ($-prefixed)
+ * are accepted without validation (they may be inferred during Phase C).
+ */
+export type ComponentReadBinding = Branded<'ComponentReadBinding', {
+    /** The raw target string from `$read` (e.g. "height" or "$price"). */
+    readonly target: string;
+    /** Whether the target is an expression (starts with `$`) or a shape field. */
+    readonly isExpression: boolean;
+}>;

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,9 @@
+export * from './application/index.js';
+export * from './components/index.js';
+export * from './enhanced-json/index.js';
+export * from './expressions/index.js';
+export type * from './invariants/index.js';
+export type * from './json-schema.js';
+export * from './markers/index.js';
+export type * from './model/index.js';
+export * from './sections/index.js';

package/dist/domain/spec/index.js

@@ -0,0 +1 @@
+export*from"./application/index.js";export*from"./components/index.js";export*from"./enhanced-json/index.js";export*from"./expressions/index.js";export*from"./markers/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{};