@salsita-ai/sdk 0.50.0-develop.a49722158a → 0.50.0-develop.a8cf9ffd01

package/dist/application-spec/parse-application-files/spec/common/value-type/value-type-at.d.ts

@@ -0,0 +1,10 @@
+import type { SchemaPathSegment } from '../../../../core/index.js';
+import type { ValueType } from './value-type.js';
+/**
+ * The type expected at a path inside a value of `type`: a number segment indexes an array, a string
+ * segment names an object property. Through a union, the path is followed into every member that
+ * has it, and the result is the union of what they expect. A value written there must fit one of
+ * them; which member the rest of the value selects is not considered, so the answer is never
+ * narrower than what TypeScript expects. A path that no member has yields `unknown`.
+ */
+export declare const valueTypeAt: (type: ValueType, path: readonly SchemaPathSegment[]) => ValueType;

package/dist/application-spec/parse-application-files/spec/common/value-type/value-type-at.js

@@ -0,0 +1 @@
+let e=[{kind:"unknown"}],n=(n,t)=>"unknown"===n.kind?e:"number"==typeof t?"array"===n.kind?n.element:[]:"object"!==n.kind?[]:n.index?n.index:n.properties?n.properties.get(t)?.type??[]:e;export const valueTypeAt=(t,r)=>{let o=t;for(let t of r){let r=o.flatMap(e=>n(e,t));if(0===r.length)return e;o=r}return o};

package/dist/application-spec/parse-application-files/spec/common/value-type/value-type.d.ts

@@ -0,0 +1,98 @@
+import type { EnhancedJsonSchemaType } from '../../../../core/index.js';
+import { type SchemaRefResolver } from '../schema-ref-resolver.js';
+/**
+ * A string type that TypeScript names and that a plain `string` does not satisfy: an entity id
+ * (`DomainEntityId`, a branded template literal) or a template literal such as `HexColor`.
+ *
+ * - `entityTypes`: for an entity id, the entity types whose ids it holds; `undefined` for the id of
+ *   any entity (`DomainEntityId<string>`).
+ * - `acceptsLiteral`: which string literals satisfy it; absent for a brand, which no literal does.
+ */
+export interface NamedString {
+    readonly name: string;
+    readonly entityTypes?: ReadonlySet<string>;
+    readonly acceptsLiteral?: (literal: string) => boolean;
+}
+/** A property of an object type. */
+export interface ObjectProperty {
+    readonly type: ValueType;
+    readonly required: boolean;
+}
+/**
+ * One member of the union a {@link ValueType} stands for.
+ *
+ * - `unknown`: a value the schema does not describe, such as a type given as TypeScript text
+ *   (`tsType`) or a ref that resolves to nothing. It is assignable to and from every type.
+ * - `string`, `number`, `boolean`: a primitive, or one literal of it (`literal`). A string can be a
+ *   {@link NamedString}.
+ * - `array`: a read-only array of `element`.
+ * - `object`: `properties` lists the known properties; `index` is the type of every other property
+ *   (`Record<string, T>`). With neither, it is any object (`Record<string, unknown>`). `open` marks
+ *   an SDK type, whose TypeScript type may have properties its schema does not list.
+ */
+export type ValueTypeMember = {
+    readonly kind: 'unknown';
+} | {
+    readonly kind: 'string';
+    readonly literal?: string;
+    readonly named?: NamedString;
+} | {
+    readonly kind: 'number';
+    readonly literal?: number;
+} | {
+    readonly kind: 'boolean';
+    readonly literal?: boolean;
+} | {
+    readonly kind: 'null';
+} | {
+    readonly kind: 'array';
+    readonly element: ValueType;
+} | {
+    readonly kind: 'object';
+    readonly properties?: ReadonlyMap<string, ObjectProperty>;
+    readonly index?: ValueType;
+    readonly open?: boolean;
+};
+/**
+ * The type a schema stands for in generated TypeScript, as the union of its members. An empty union
+ * is `never`.
+ */
+export type ValueType = readonly ValueTypeMember[];
+/** Who wrote a schema, which decides what its `tsType` means. */
+export type SchemaAuthor = 
+/** A project: a `tsType` is TypeScript text the parser cannot read, so the type is `unknown`. */
+'project'
+/**
+ * The SDK: a component or phoenix definition schema states its type in JSON next to the `tsType`
+ * that names it, so the JSON describes the type, except for the named strings in
+ * {@link NAMED_STRINGS}.
+ */
+ | 'sdk';
+/** What a {@link ValueType} needs to read a schema. */
+export interface ValueTypeResolution {
+    readonly author: SchemaAuthor;
+    /** Resolves phoenix definition refs and common type refs. */
+    readonly resolveRef: SchemaRefResolver;
+    /** The entity types an entity type or alias name stands for. */
+    readonly entityTypes: (typeOrAlias: string) => readonly string[];
+    /** The `definitions` of the root schema, for its `#/definitions/X` refs. */
+    readonly definitions?: Readonly<Record<string, EnhancedJsonSchemaType>>;
+}
+/**
+ * The SDK's named string types, by the `tsType` an SDK schema gives them, with the literals that
+ * satisfy each (none for a brand). A `type: string` schema of the SDK whose `tsType` is not listed
+ * here describes a plain string.
+ */
+export declare const NAMED_STRINGS: Readonly<Record<string, Pick<NamedString, 'acceptsLiteral'>>>;
+/** The type of an entity id: of the entity types `typeOrAlias` stands for, or of any entity. */
+export declare const entityIdValueType: (typeOrAlias: string | undefined, resolution: Pick<ValueTypeResolution, 'entityTypes'>) => ValueType;
+/**
+ * The type TypeScript gives a literal value written in a spec where a type is expected: a string,
+ * number or boolean is its literal type, an array is an array of the union of its items, and an
+ * object has exactly its properties, each required.
+ */
+export declare const literalValueType: (value: unknown) => ValueType;
+/** The type a schema stands for in generated TypeScript. */
+export declare const ValueType: (schema: EnhancedJsonSchemaType, resolution: ValueTypeResolution) => ValueType;
+/** Whether a type has a member the schema does not describe. */
+export declare const hasUnknownMember: (type: ValueType) => boolean;

package/dist/application-spec/parse-application-files/spec/common/value-type/value-type.js

@@ -0,0 +1 @@
+import{isArray as e}from"@salsita-ai/common/utils";import{phxDefinitionRefName as t}from"../schema-ref-resolver.js";let r=new Set(["white","black","red","green","blue","yellow","cyan","magenta"]),n=e=>e.startsWith("#");export const NAMED_STRINGS={DomainEntityId:{},HexColor:{acceptsLiteral:n},Color:{acceptsLiteral:e=>{let t;return n(e)||r.has(e)||e.startsWith("ral-")&&(t=e.slice(4)).trim()===t&&""!==t&&!Number.isNaN(Number(t))}}};let i={EnhancedLocalizable:"Localizable",EnhancedMessageDescriptor:"MessageDescriptor"},o=new Set(["PhoenixEntityElement","PhoenixLayoutElement"]),a=[{kind:"unknown"}],l="DomainEntityId";export const entityIdValueType=(e,t)=>[{kind:"string",named:{name:l,...void 0===e?{}:{entityTypes:new Set(t.entityTypes(e))}}}];export const literalValueType=e=>null===e?[{kind:"null"}]:"string"==typeof e?[{kind:"string",literal:e}]:"number"==typeof e?[{kind:"number",literal:e}]:"boolean"==typeof e?[{kind:"boolean",literal:e}]:Array.isArray(e)?[{kind:"array",element:e.flatMap(literalValueType)}]:"object"==typeof e?[{kind:"object",properties:new Map(Object.entries(e).map(([e,t])=>[e,{type:literalValueType(t),required:!0}]))}]:[{kind:"unknown"}];let s=(e,r)=>{let{$ref:n}=e;if(r.openRefs.has(n))return a;let i=new Set([...r.openRefs,n]),o=/^#\/definitions\/([^/]+)$/.exec(n)?.[1],s=void 0===o?void 0:r.resolution.definitions?.[o];if(s)return y(s,{...r,openRefs:i});let p=t(n);if(p===l)return entityIdValueType(e.references,r.resolution);let u=r.resolution.resolveRef(n);if(!u)return a;let d=void 0===p?r.resolution:{...r.resolution,author:"sdk",definitions:void 0};return void 0!==p&&void 0!==u.tsType&&/^\$?DomainEntity$/.test(u.tsType)?a:y(u,{resolution:d,openRefs:i})},p=(t,r,n)=>{switch(t){case"string":return[{kind:"string"}];case"number":case"integer":return[{kind:"number"}];case"boolean":return[{kind:"boolean"}];case"null":return[{kind:"null"}];case"array":return((t,r)=>{let{items:n}=t;return n?e(n)?a:[{kind:"array",element:y(n,r)}]:[{kind:"array",element:a}]})(r,n);case"object":let i="sdk"===n.resolution.author;if(i&&(!r.properties&&(void 0===r.additionalProperties||"object"==typeof r.additionalProperties&&0===Object.keys(r.additionalProperties).length)||r.properties&&0===Object.keys(r.properties).length))return a;if("object"==typeof r.additionalProperties)return[{kind:"object",index:y(r.additionalProperties,n)}];if(!r.properties)return[{kind:"object"}];let o=new Set(r.required??[]),l=new Map;for(let[e,t]of Object.entries(r.properties))l.set(e,{type:y(t,n),required:o.has(e)});return[{kind:"object",properties:l,...i?{open:!0}:{}}];default:return a}},u=["type","enum","const","$ref","anyOf","oneOf","allOf","properties","items","additionalProperties","tsType"],d=e=>u.some(t=>t in e),y=(t,r)=>{if(void 0!==t.tsType){if("project"===r.resolution.author||o.has(t.tsType))return a;let e=i[t.tsType];if(void 0!==e)return s({$ref:`phx:${e}`},r);let n=NAMED_STRINGS[t.tsType];if(n)return t.tsType===l?entityIdValueType(t.references,r.resolution):[{kind:"string",named:{name:t.tsType,...n}}]}if(void 0!==t.$ref)return s({...t,$ref:t.$ref},r);if(t.enum)return t.enum.flatMap(literalValueType);let n=t.const;if(void 0!==n)return literalValueType(n);let u=t.anyOf??t.oneOf;return u?u.flatMap(e=>y(e,r)):t.allOf?((e,t)=>{let[r,...n]=e.filter(d);return r&&0===n.length?y(r,t):a})(t.allOf,r):"string"==typeof t.type?p(t.type,t,r):e(t.type)?t.type.flatMap(e=>p(e,t,r)):a};export const ValueType=(e,t)=>y(e,{resolution:t,openRefs:new Set});export const hasUnknownMember=e=>e.some(e=>"unknown"===e.kind);

package/dist/application-spec/parse-application-files/spec/components/bindings/component-path.d.ts

@@ -0,0 +1,13 @@
+import type { ParseContext, SchemaPathSegment } from '../../../../core/index.js';
+import type { ComponentReadBindingContext } from './read-binding.js';
+type ComponentInstance = Pick<ComponentReadBindingContext, 'entityKey' | 'componentName' | 'instanceName'>;
+/** Writes a path inside a component instance's props, such as `options[0].label`. */
+export declare const formatComponentPropPath: (path: readonly SchemaPathSegment[]) => string;
+/**
+ * Names a place in a component instance for a diagnostic: `Entity.component.instance`, followed by
+ * the path inside the instance (a prop path or a filter criterion) when there is one.
+ */
+export declare const componentPath: (instance: ComponentInstance, path: readonly SchemaPathSegment[]) => string;
+/** The parse context at a place in a component instance, so a diagnostic carries its spec path. */
+export declare const componentParseContext: (parsingContext: ParseContext, instance: ComponentInstance, path: readonly SchemaPathSegment[]) => ParseContext;
+export {};

package/dist/application-spec/parse-application-files/spec/components/bindings/component-path.js

@@ -0,0 +1 @@
+export const formatComponentPropPath=t=>t.reduce((t,n)=>"number"==typeof n?`${t}[${n}]`:0===t.length?n:`${t}.${n}`,"");export const componentPath=(t,n)=>{let e=`${String(t.entityKey)}.${t.componentName}.${String(t.instanceName)}`;return 0===n.length?e:`${e}.${formatComponentPropPath(n)}`};export const componentParseContext=(t,n,e)=>t.at(String(n.entityKey),n.componentName,String(n.instanceName),...e.map(String));

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

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

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

@@ -1 +1 @@
-export*from"./read-binding.js";export*from"./write-binding.js";
+export*from"./component-path.js";export*from"./read-binding.js";export*from"./read-binding-type.js";export*from"./write-binding.js";

package/dist/application-spec/parse-application-files/spec/components/bindings/read-binding-type.d.ts

@@ -0,0 +1,24 @@
+import type { SchemaPathSegment } from '../../../../core/index.js';
+import { type ValueType, type ValueTypeResolution } from '../../common/index.js';
+import { type ComponentReadBindingContext } from './read-binding.js';
+/** What the type check of a read binding needs besides the binding's own context. */
+export interface ReadBindingTypeContext extends ComponentReadBindingContext {
+    /** Resolves the refs of the entity's field schemas; the schemas are the project's. */
+    readonly typeResolution: Omit<ValueTypeResolution, 'author' | 'definitions'>;
+}
+/** A `$read` or `$bind` of a shape field and the place in the component where it is read. */
+export interface ReadBindingTypeCheck {
+    readonly marker: '$read' | '$bind';
+    readonly target: string;
+    /** Where in the component the value goes: a prop path or a filter criterion, or empty for the whole state. */
+    readonly path: readonly SchemaPathSegment[];
+    /** The type the component expects there. */
+    readonly expected: ValueType;
+}
+/**
+ * Reports a `$read` or `$bind` of a shape field whose type does not fit the type the component
+ * expects where the value goes, which the type check of generated code rejects. An expression
+ * target is checked where the expression's type is settled; an unknown field is reported by
+ * {@link ComponentReadBinding}.
+ */
+export declare const checkReadBindingType: (check: ReadBindingTypeCheck, context: ReadBindingTypeContext) => void;

package/dist/application-spec/parse-application-files/spec/components/bindings/read-binding-type.js

@@ -0,0 +1 @@
+import{DiagnosticCode as e,diagnosticMessages as t}from"../../../../errors/index.js";import{entityIdValueType as r,formatValueType as o,isAssignableValueType as i,ValueType as n}from"../../common/index.js";import{componentParseContext as p,componentPath as a}from"./component-path.js";import{isExpressionReadTarget as m}from"./read-binding.js";export const checkReadBindingType=(s,d)=>{if(m(s.target))return;let c=((e,t)=>{if("id"===e)return r(String(t.entityKey),t.typeResolution);let o=t.resolvedShape.fieldSchemas.get(e);return o&&n(o,{...t.typeResolution,author:"project"})})(s.target,d);!c||i(c,s.expected)||p(d.parsingContext,d,s.path).error(e.COMPONENT_BINDING_TYPE_MISMATCH,t.COMPONENT_BINDING_TYPE_MISMATCH(a(d,s.path),`${s.marker}: ${s.target}`,o(c),o(s.expected)))};

package/dist/application-spec/parse-application-files/spec/components/bindings/read-binding.d.ts

@@ -1,18 +1,8 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { ComponentReadBinding as ComponentReadBindingData } from '#package/domain';
 import type { ParseContext } from '../../../../core/index.js';
 import type { EntityOrAliasName, InstanceName, ResolvedShape } from '../../model/index.js';
-/**
- * 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;
-}>;
+/** A validated `$read` dependency of a component; see {@link ComponentReadBindingData | ComponentReadBinding} in `domain`. */
+export type ComponentReadBinding = ComponentReadBindingData;
 export interface ComponentReadBindingContext {
     readonly entityKey: EntityOrAliasName;
     readonly componentName: string;

package/dist/application-spec/parse-application-files/spec/components/bindings/write-binding.d.ts

@@ -1,42 +1,14 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { AssertionKind, ComponentWriteBinding as ComponentWriteBindingData } from '#package/domain';
 import { type EnhancedJsonSchemaType, type ParseContext } from '../../../../core/index.js';
 import { type EntityOrAliasName, type InstanceName, type ResolvedShape } from '../../model/index.js';
-/**
- * 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';
-};
+export type { AssertionKind } from '#package/domain';
 /**
  * Resolves the assertion kind from a field's schema.
  * Ported from domain-spec/spec/resolve-assertions.ts.
  */
 export declare const resolveAssertionKind: (fieldSchema: EnhancedJsonSchemaType) => AssertionKind;
-/**
- * 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;
-}>;
+/** A validated `$write` or `$bind` mapping of a component; see {@link ComponentWriteBindingData | ComponentWriteBinding} in `domain`. */
+export type ComponentWriteBinding = ComponentWriteBindingData;
 export interface ComponentWriteBindingContext {
     readonly entityKey: EntityOrAliasName;
     readonly componentName: string;

package/dist/application-spec/parse-application-files/spec/components/component-filter.d.ts

@@ -1,5 +1,5 @@
-import { Branded } from '@salsita-ai/common/utils';
-import { type ComponentFilter, type EnhancedJsonSchemaType, type EnhancedJsonValue } from '../../../core/index.js';
+import type { ComponentFilters as ComponentFiltersData } from '#package/domain';
+import { type EnhancedJsonSchemaType, type EnhancedJsonValue } from '../../../core/index.js';
 /**
  * Schema types for each filter criterion, used for expression inference.
  * When `$read: '$expr'` appears in a filter criterion, the expression is
@@ -7,14 +7,8 @@ import { type ComponentFilter, type EnhancedJsonSchemaType, type EnhancedJsonVal
  * infers `$x` as `boolean`).
  */
 export declare const FILTER_CRITERION_SCHEMAS: Readonly<Record<string, EnhancedJsonSchemaType>>;
-/**
- * Validated set of `$filter` entries on a user-bound component instance. Each
- * `ComponentFilter` 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 ComponentFilter[];
-}>;
+/** The validated `$filter` entries of a component instance; see {@link ComponentFiltersData | ComponentFilters} in `domain`. */
+export type ComponentFilters = ComponentFiltersData;
 /**
  * Parses a raw `$filter` value into a {@link ComponentFilters}. The shape is
  * guaranteed by upstream AJV validation against `ComponentSystemFilter` — this

package/dist/application-spec/parse-application-files/spec/components/component-state-type.d.ts

@@ -0,0 +1,8 @@
+import type { EnhancedJsonSchemaType } from '../../../core/index.js';
+import { ValueType, type ValueTypeResolution } from '../common/index.js';
+/**
+ * The type of a system component's state, read from its JSON schema. The schemas state the same
+ * types as the components' TypeScript state types, except that a brand or template literal is known
+ * only by the `tsType` that names it. Read once per component schema.
+ */
+export declare const componentStateType: (componentSchema: EnhancedJsonSchemaType, resolution: Omit<ValueTypeResolution, 'author' | 'definitions'>) => ValueType;

package/dist/application-spec/parse-application-files/spec/components/component-state-type.js

@@ -0,0 +1 @@
+import{ValueType as e}from"../common/index.js";let t=new WeakMap;export const componentStateType=(n,o)=>{let i=t.get(n);if(i)return i;let r=e(n,{...o,author:"sdk",definitions:n.definitions});return t.set(n,r),r};

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

@@ -1,10 +1,9 @@
-import { Branded } from '@salsita-ai/common/utils';
+import type { ComponentEntry, Components as ComponentsData } from '#package/domain';
 import type { ParseContext } from '../../../core/index.js';
 import type { Aliases } from '../model/index.js';
-import type { ComponentEntry } from './component-entry.js';
 import type { UserComponents } from './user-components.js';
-/** Final merged components for a domain, including SDK/spec-derived entries. */
-export type Components = Branded<'Components', readonly ComponentEntry[]>;
+/** The merged components of a domain; see {@link ComponentsData | Components} in `domain`. */
+export type Components = ComponentsData;
 interface ComponentsProps {
     readonly userComponents: UserComponents;
     readonly generatedComponents: readonly ComponentEntry[];

package/dist/application-spec/parse-application-files/spec/components/filter-criterion-types.d.ts

@@ -0,0 +1,13 @@
+import type { EnhancedJsonSchemaType, FILTER_CRITERION_KEYS } from '../../../core/index.js';
+/**
+ * The type each filter criterion takes, as an SDK schema that states exactly the TypeScript type of
+ * `ComponentSystemFilterProps`: the modes, roles and viewports are their literal unions and the
+ * entity ids are `DomainEntityId`s. `FILTER_CRITERION_SCHEMAS`, which infers the type of an
+ * expression read in a criterion, is wider where the JSON schema of the filter is.
+ */
+export declare const FILTER_CRITERION_TYPE_SCHEMAS: Readonly<Record<(typeof FILTER_CRITERION_KEYS)[number], EnhancedJsonSchemaType>>;
+/**
+ * The type a root filter (`$filter: { $read: x }`) takes, `ComponentSystemFilter`: a boolean, or an
+ * object of the criteria other than the export ones.
+ */
+export declare const ROOT_FILTER_TYPE_SCHEMA: EnhancedJsonSchemaType;

package/dist/application-spec/parse-application-files/spec/components/filter-criterion-types.js

@@ -0,0 +1 @@
+import{SessionRole as e}from"@salsita-ai/contracts/api";import{VIEWPORTS as t}from"#package/domain";let r={type:"string",tsType:"DomainEntityId"},a={anyOf:[r,{type:"object",properties:{id:r},required:["id"]}]},i={anyOf:[{type:"array",items:a},a]},s={type:"array",items:{type:"string"}},o={type:"boolean"};export const FILTER_CRITERION_TYPE_SCHEMAS={navigationStates:s,viewStates:s,toolStates:s,exportStates:s,modes:{type:"array",items:{enum:["owner","read","finalize"]}},roles:{type:"array",items:{enum:Object.values(e)}},selectedEntityIds:i,hoveredEntityIds:i,draggedEntityIds:i,exportedEntityIds:i,active:o,fullscreen:o,debug:o,viewports:{type:"array",items:{enum:[...t]}}};let n=new Set(["exportedEntityIds","exportStates"]),p=Object.fromEntries(Object.entries(FILTER_CRITERION_TYPE_SCHEMAS).filter(([e])=>!n.has(e)));export const ROOT_FILTER_TYPE_SCHEMA={anyOf:[o,{type:"object",properties:p}]};

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

@@ -1,7 +1,6 @@
+export { type ComponentEntry, type ComponentImplementation, type ComponentPropTarget, type CompositeImplementation, type RootReadImplementation, type SdkFactory, type SdkFactoryParam, isComponentPropTarget, } from '#package/domain';
 export * from './bindings/index.js';
-export type * from './component-entry.js';
 export * from './component-filter.js';
-export * from './component-prop-target.js';
 export * from './components.js';
 export * from './sdk-component-entry.js';
 export * from './user-component-entry.js';

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

@@ -1 +1 @@
-export*from"./bindings/index.js";export*from"./component-filter.js";export*from"./component-prop-target.js";export*from"./components.js";export*from"./sdk-component-entry.js";export*from"./user-component-entry.js";export*from"./user-components.js";
+export{isComponentPropTarget}from"#package/domain";export*from"./bindings/index.js";export*from"./component-filter.js";export*from"./components.js";export*from"./sdk-component-entry.js";export*from"./user-component-entry.js";export*from"./user-components.js";

package/dist/application-spec/parse-application-files/spec/components/sdk-component-entry.d.ts

@@ -1,5 +1,5 @@
+import type { ComponentEntry, SdkFactory } from '#package/domain';
 import type { Aliases, EntityOrAliasName, InstanceName } from '../model/index.js';
-import type { ComponentEntry, SdkFactory } from './component-entry.js';
 import type { ComponentFilters } from './component-filter.js';
 interface SdkComponentImplementation {
     readonly kind: 'sdk';

package/dist/application-spec/parse-application-files/spec/components/static-entity-id.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaPathSegment } from '../../../core/index.js';
+import { type ValueType } from '../common/index.js';
+import { type ComponentReadBindingContext } from './bindings/index.js';
+/**
+ * Reports a value written in a component prop or filter where the component expects an entity id
+ * (`DomainEntityId`). The schema checks the id's form, but the id's type is branded, so the type
+ * check of generated code rejects any string written in YAML: the id has to be read from the
+ * domain state with `$read` or `$bind`.
+ *
+ * @param value - A primitive value written in the spec
+ * @param path - The prop path or filter criterion the value is written at
+ * @param expected - The type the component expects there
+ */
+export declare const checkStaticEntityId: (value: string | number | boolean | null, path: readonly SchemaPathSegment[], expected: ValueType, context: Omit<ComponentReadBindingContext, 'resolvedShape'>) => void;

package/dist/application-spec/parse-application-files/spec/components/static-entity-id.js

@@ -0,0 +1 @@
+import{DiagnosticCode as i,diagnosticMessages as r}from"../../../errors/index.js";import{formatValueType as o,isAssignableValueType as n,literalValueType as t}from"../common/index.js";import{componentParseContext as e,componentPath as m}from"./bindings/index.js";export const checkStaticEntityId=(s,d,T,c)=>{!T.some(i=>"string"===i.kind&&void 0!==i.named&&void 0===i.named.acceptsLiteral)||n(t(s),T)||e(c.parsingContext,c,d).error(i.COMPONENT_STATIC_ENTITY_ID,r.COMPONENT_STATIC_ENTITY_ID(m(c,d),JSON.stringify(s),o(T)))};

package/dist/application-spec/parse-application-files/spec/components/user-component-entry.d.ts

@@ -1,7 +1,8 @@
+import type { ComponentEntry, SpecExpression } from '#package/domain';
 import { type EnhancedJsonObject, type ParseContext } from '../../../core/index.js';
-import type { Expression } from '../expressions/expression.js';
+import { type ValueTypeResolution } from '../common/index.js';
+import type { ExpressionRead } from '../expressions/expression-read.js';
 import type { EntityOrAliasName, InstanceName, ResolvedShape } from '../model/index.js';
-import type { ComponentEntry } from './component-entry.js';
 interface UserComponentProps {
     readonly typeOrAlias: EntityOrAliasName;
     readonly instanceName: InstanceName;
@@ -11,10 +12,14 @@ interface UserComponentProps {
 interface UserComponentContext {
     readonly resolvedShape: ResolvedShape;
     readonly parsingContext: ParseContext;
+    /** Resolves the refs of field schemas and the entity types of a name, for the type checks. */
+    readonly typeResolution: Omit<ValueTypeResolution, 'author' | 'definitions'>;
 }
 export interface UserComponentResult {
     readonly entry: ComponentEntry;
-    readonly inferredExpressions: readonly Expression[];
+    readonly inferredExpressions: readonly SpecExpression[];
+    /** Every `$read` of an expression in the instance, with the type expected where it is read. */
+    readonly expressionReads: readonly ExpressionRead[];
 }
 /**
  * Creates a user-declared ComponentEntry from raw YAML props.

package/dist/application-spec/parse-application-files/spec/components/user-component-entry.js

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{componentsByName as t}from"#package/domain";import{FILTER_KEY as n,READ_MARKER_KEY as r,isEvalMarker as i,isImportRefShaped as a,isRawBindMarker as o,isRawDataRefMarker as m,isRawEvalWriteMarker as p,isRawReadMarker as s,isRawReadWriteMarker as l,navigateSchema as d}from"../../../core/index.js";import{DiagnosticCode as f,diagnosticMessages as c}from"../../../errors/index.js";import{MemoEvalPlan as y}from"../expressions/memo-eval-plan.js";import{ComponentReadBinding as g,ComponentWriteBinding as u,isExpressionReadTarget as N}from"./bindings/index.js";import{ComponentFilters as $,FILTER_CRITERION_SCHEMAS as O}from"./component-filter.js";let S=e=>e.reduce((e,t)=>"number"==typeof t?`${e}[${t}]`:0===e.length?t:`${e}.${t}`,""),T=(e,t,n,r)=>{if(null==e||"object"!=typeof e)return e;if(s(e))return n.addReadBinding(e.$read,t),{$target:e.$read};if(m(e))return void r.parsingContext.at(String(r.entityKey),r.componentName,String(r.instanceName),...t.map(String)).error(f.COMPONENT_DATA_REF_UNSUPPORTED,c.COMPONENT_DATA_REF_UNSUPPORTED(String(r.entityKey),r.componentName,String(r.instanceName),S(t),e.$read,e.$data));if(o(e))return n.addReadBinding(e.$bind,t),{$target:e.$bind};if(i(e))return e;if(a(e))return void r.parsingContext.at(String(r.entityKey),r.componentName,String(r.instanceName),...t.map(String)).error(f.COMPONENT_IMPORT_REF_UNSUPPORTED,c.COMPONENT_IMPORT_REF_UNSUPPORTED(String(r.entityKey),r.componentName,String(r.instanceName),S(t),e.$importRef.module,e.$importRef.member));if(Array.isArray(e))return e.map((e,i)=>T(e,[...t,i],n,r)).filter(e=>void 0!==e);let p={};for(let[i,a]of Object.entries(e)){let e=T(a,[...t,i],n,r);void 0!==e&&(p[i]=e)}return p},A=(t,n,r)=>{for(let i of t.items)if("gradual"===i.kind){for(let[t,a]of Object.entries(i))if("kind"!==t&&a?.kind==="dynamic"&&a.target&&N(a.target)){let i=O[t];i&&r.push(e({entityKey:n,name:a.target,schema:i,implementation:{kind:"user"}}))}}};export const UserComponentEntry=(i,a)=>{let{implementation:m,inferredExpressions:s}=((i,a)=>{let m=t.get(i.componentName),s=m?.schema,O=new Set,S=[],P=[],E=[],R={entityKey:i.typeOrAlias,componentName:i.componentName,instanceName:i.instanceName,resolvedShape:a.resolvedShape,parsingContext:a.parsingContext},_={entityKey:i.typeOrAlias,componentName:i.componentName,instanceName:i.instanceName,resolvedShape:a.resolvedShape,parsingContext:a.parsingContext},h=(t,n)=>{if(!O.has(t)&&(O.add(t),S.push(g(t,R)),N(t)&&s)){let r=((t,n,r,i)=>{let{schema:a,lastDeclaredType:o,pathSinceDeclaredType:m}=d(r,n),p=n=>e({entityKey:i,name:t,schema:n,implementation:{kind:"user"}});if(void 0!==o){let e=m.map(e=>"number"==typeof e?"[number]":`['${e}']`).join("");return p({...a,tsType:`${o.tsType}${e}`,import:o.import})}if(Object.keys(a).length>0)return p(a)})(t,n,s,i.typeOrAlias);r&&E.push(r)}},b={addReadBinding:h},v=$(i.rawProps[n]),C=`${String(i.typeOrAlias)}.${String(i.instanceName)}`;if((e=>{if(!(r in e)||"string"!=typeof e[r])return!1;for(let t of Object.keys(e))if(t!==r&&t!==n)return!1;return!0})(i.rawProps)){let e=i.rawProps[r];return h(e,[]),A(v,i.typeOrAlias,E),{implementation:{kind:"userBound",filters:v,plan:y({$target:e},C),implementation:{kind:"rootRead",readBinding:S[0]}},inferredExpressions:E}}let k={};for(let[e,t]of Object.entries(i.rawProps)){if(e===n)continue;if(o(t)){P.push(u(e,t.$bind,_)),h(t.$bind,[e]),k[e]={$target:t.$bind};continue}if(l(t)){h(t.$read,[e]),P.push(u(e,t.$write,_)),k[e]={$target:t.$read};continue}if(p(t)){P.push(u(e,t.$write,_)),k[e]={$eval:t.$eval};continue}let r=T(t,[e],b,R);void 0!==r&&(k[e]=r)}let j=new Map;for(let e of P){let t=j.get(e.entityField);t?a.parsingContext.error(f.WRITE_BINDING_DUPLICATE_TARGET,c.WRITE_BINDING_DUPLICATE_TARGET(String(i.typeOrAlias),i.componentName,String(i.instanceName),e.entityField,t,e.propKey)):j.set(e.entityField,e.propKey)}return A(v,i.typeOrAlias,E),{implementation:{kind:"userBound",filters:v,plan:y(k,C),implementation:{kind:"composite",resolvedProps:k,readBindings:S,writeBindings:P}},inferredExpressions:E}})(i,a);return{entry:e({typeOrAlias:i.typeOrAlias,instanceName:i.instanceName,isAlias:"alias"===a.resolvedShape.kind,componentName:i.componentName,implementation:m}),inferredExpressions:s}};
+import{Branded as e}from"@salsita-ai/common/utils";import{componentsByName as t}from"#package/domain";import{FILTER_CRITERION_KEYS as n,FILTER_KEY as r,FILTER_OR_KEY as i,READ_MARKER_KEY as o,isEnhancedJsonObject as a,isEvalMarker as p,isImportRefShaped as m,isRawBindMarker as s,isRawDataRefMarker as d,isRawEvalWriteMarker as l,isRawReadMarker as c,isRawReadWriteMarker as f,navigateSchema as y}from"../../../core/index.js";import{DiagnosticCode as u,diagnosticMessages as g}from"../../../errors/index.js";import{ValueType as N,valueTypeAt as $}from"../common/index.js";import{MemoEvalPlan as O}from"../expressions/index.js";import{ComponentReadBinding as S,ComponentWriteBinding as A,checkReadBindingType as k,componentPath as R,formatComponentPropPath as T,isExpressionReadTarget as b}from"./bindings/index.js";import{ComponentFilters as h,FILTER_CRITERION_SCHEMAS as P}from"./component-filter.js";import{componentStateType as E}from"./component-state-type.js";import{FILTER_CRITERION_TYPE_SCHEMAS as j,ROOT_FILTER_TYPE_SCHEMA as x}from"./filter-criterion-types.js";import{checkStaticEntityId as _}from"./static-entity-id.js";let v=(e,t,n,r)=>{if(null==e||"object"!=typeof e)return void 0!==e&&n.checkStaticValue(e,t),e;if(c(e))return n.addReadBinding(e.$read,t,"$read"),{$target:e.$read};if(d(e))return void r.parsingContext.at(String(r.entityKey),r.componentName,String(r.instanceName),...t.map(String)).error(u.COMPONENT_DATA_REF_UNSUPPORTED,g.COMPONENT_DATA_REF_UNSUPPORTED(String(r.entityKey),r.componentName,String(r.instanceName),T(t),e.$read,e.$data));if(s(e))return n.addReadBinding(e.$bind,t,"$bind"),{$target:e.$bind};if(p(e))return e;if(m(e))return void r.parsingContext.at(String(r.entityKey),r.componentName,String(r.instanceName),...t.map(String)).error(u.COMPONENT_IMPORT_REF_UNSUPPORTED,g.COMPONENT_IMPORT_REF_UNSUPPORTED(String(r.entityKey),r.componentName,String(r.instanceName),T(t),e.$importRef.module,e.$importRef.member));if(Array.isArray(e))return e.map((e,i)=>v(e,[...t,i],n,r)).filter(e=>void 0!==e);let i={};for(let[o,a]of Object.entries(e)){let e=v(a,[...t,o],n,r);void 0!==e&&(i[o]=e)}return i},C=(t,n,r)=>{for(let i of t.items)if("gradual"===i.kind){for(let[t,o]of Object.entries(i))if("kind"!==t&&o?.kind==="dynamic"&&o.target&&b(o.target)){let i=P[t];i&&r.push(e({entityKey:n,name:o.target,schema:i,implementation:{kind:"user"}}))}}},U=(e,t,n,r)=>{if("string"==typeof e||"number"==typeof e||"boolean"==typeof e||null===e)return void _(e,t,n,r);if("object"==typeof e)for(let[i,o]of Object.entries(e)){let a=Array.isArray(e)?Number(i):i;U(o,[...t,a],$(n,[a]),r)}};export const UserComponentEntry=(p,m)=>{let{implementation:d,inferredExpressions:c,expressionReads:T}=((p,m)=>{let d,c=t.get(p.componentName),T=c?.schema,P=new Set,w=[],D=[],I=[],K={entityKey:p.typeOrAlias,componentName:p.componentName,instanceName:p.instanceName,resolvedShape:m.resolvedShape,parsingContext:m.parsingContext},B={entityKey:p.typeOrAlias,componentName:p.componentName,instanceName:p.instanceName,resolvedShape:m.resolvedShape,parsingContext:m.parsingContext},F={...K,typeResolution:m.typeResolution},M=e=>T?$(d??=E(T,m.typeResolution),e):[{kind:"unknown"}],G=[],V=e=>{b(e.target)?G.push({entityKey:p.typeOrAlias,name:e.target,expected:e.expected,location:R(K,e.path)}):k(e,F)},L=(t,n,r)=>{if(V({marker:r,target:t,path:n,expected:M(n)}),!P.has(t)&&(P.add(t),w.push(S(t,K)),b(t)&&T)){let r=((t,n,r,i)=>{let{schema:o,lastDeclaredType:a,pathSinceDeclaredType:p}=y(r,n),m=n=>e({entityKey:i,name:t,schema:n,implementation:{kind:"user"}});if(void 0!==a){let e=p.map(e=>"number"==typeof e?"[number]":`['${e}']`).join("");return m({...o,tsType:`${a.tsType}${e}`,import:a.import})}if(Object.keys(o).length>0)return m(o)})(t,n,T,p.typeOrAlias);r&&I.push(r)}},W={addReadBinding:L,checkStaticValue:(e,t)=>_(e,t,M(t),K)},q=h(p.rawProps[r]);((e,t,o,p)=>{let m=e=>N(e,{...o.typeResolution,author:"sdk"}),s=void 0!==e&&a(e)&&Array.isArray(e[i]);for(let[e,a]of t.items.entries()){let t=s?[r,i,e]:[r];if("root"===a.kind){p({marker:"$read",target:a.target,path:t,expected:m(x)});continue}for(let e of n){let n=a[e],r=[...t,e],i=m(j[e]);n?.kind==="dynamic"?p({marker:"$read",target:n.target,path:r,expected:i}):n?.kind==="static"&&U(n.value,r,i,o)}}})(p.rawProps[r],q,F,V);let z=`${String(p.typeOrAlias)}.${String(p.instanceName)}`;if((e=>{if(!(o in e)||"string"!=typeof e[o])return!1;for(let t of Object.keys(e))if(t!==o&&t!==r)return!1;return!0})(p.rawProps)){let e=p.rawProps[o];return L(e,[],"$read"),C(q,p.typeOrAlias,I),{implementation:{kind:"userBound",filters:q,plan:O({$target:e},z),implementation:{kind:"rootRead",readBinding:w[0]}},inferredExpressions:I,expressionReads:G}}let H={};for(let[e,t]of Object.entries(p.rawProps)){if(e===r)continue;if(s(t)){D.push(A(e,t.$bind,B)),L(t.$bind,[e],"$bind"),H[e]={$target:t.$bind};continue}if(f(t)){L(t.$read,[e],"$read"),D.push(A(e,t.$write,B)),H[e]={$target:t.$read};continue}if(l(t)){D.push(A(e,t.$write,B)),H[e]={$eval:t.$eval};continue}let n=v(t,[e],W,K);void 0!==n&&(H[e]=n)}let J=new Map;for(let e of D){let t=J.get(e.entityField);t?m.parsingContext.error(u.WRITE_BINDING_DUPLICATE_TARGET,g.WRITE_BINDING_DUPLICATE_TARGET(String(p.typeOrAlias),p.componentName,String(p.instanceName),e.entityField,t,e.propKey)):J.set(e.entityField,e.propKey)}return C(q,p.typeOrAlias,I),{implementation:{kind:"userBound",filters:q,plan:O(H,z),implementation:{kind:"composite",resolvedProps:H,readBindings:w,writeBindings:D}},inferredExpressions:I,expressionReads:G}})(p,m);return{entry:e({typeOrAlias:p.typeOrAlias,instanceName:p.instanceName,isAlias:"alias"===m.resolvedShape.kind,componentName:p.componentName,implementation:d}),inferredExpressions:c,expressionReads:T}};

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

@@ -1,19 +1,21 @@
 import { Branded } from '@salsita-ai/common/utils';
-import type { ParseContext } from '../../../core/index.js';
+import type { ComponentEntry, SpecExpression } from '#package/domain';
+import type { ParseContext, PhoenixDefinitions } from '../../../core/index.js';
 import type { MergedComponents } from '../../merge/index.js';
-import type { Expression } from '../expressions/expression.js';
-import type { ResolvedShapes } from '../model/index.js';
-import type { ComponentEntry } from './component-entry.js';
+import type { ExpressionRead } from '../expressions/expression-read.js';
+import type { ModelVersion } from '../model/index.js';
 /** User-declared component entries, flattened from the nested merge map. */
 export type UserComponents = Branded<'UserComponents', readonly ComponentEntry[]>;
 interface UserComponentsContext {
-    readonly allNames: ReadonlySet<string>;
-    readonly resolvedShapes: ResolvedShapes;
+    readonly latestModel: ModelVersion;
+    readonly phxDefinitions: PhoenixDefinitions;
     readonly parsingContext: ParseContext;
 }
 interface UserComponentsResult {
     readonly components: UserComponents;
-    readonly expressions: readonly Expression[];
+    readonly expressions: readonly SpecExpression[];
+    /** Every `$read` of an expression in a component, with the type expected where it is read. */
+    readonly expressionReads: readonly ExpressionRead[];
 }
 /**
  * Flattens the nested merge map into a flat list of ComponentEntry objects.

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

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as r,diagnosticMessages as t}from"../../../errors/index.js";import{InstanceName as o,getResolvedShape as n}from"../model/index.js";import{UserComponentEntry as s}from"./user-component-entry.js";export const UserComponents=(i,p)=>{let{allNames:m,parsingContext:f}=p,l=[],N=[],O=[...m];for(let[e,c]of Object.entries(i)){if(!m.has(e)){f.error(r.COMPONENT_UNKNOWN_ENTITY_KEY,t.COMPONENT_UNKNOWN_ENTITY_KEY(e,O));continue}let i=n(p.resolvedShapes,e);for(let[r,t]of Object.entries(c))for(let[n,p]of Object.entries(t)){let t=o(n,e,r,f);if(!t)continue;let m=s({typeOrAlias:e,instanceName:t,componentName:r,rawProps:p},{resolvedShape:i,parsingContext:f});l.push(m.entry),N.push(...m.inferredExpressions)}}return{components:e(l),expressions:N}};
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as o,diagnosticMessages as r}from"../../../errors/index.js";import{InstanceName as t,ModelTypeResolution as s,getResolvedShape as n}from"../model/index.js";import{UserComponentEntry as i}from"./user-component-entry.js";export const UserComponents=(p,m)=>{let{latestModel:f,parsingContext:l}=m,N=f.allNames,a=s(f,m.phxDefinitions),O=[],c=[],u=[],x=[...N];for(let[e,s]of Object.entries(p)){if(!N.has(e)){l.error(o.COMPONENT_UNKNOWN_ENTITY_KEY,r.COMPONENT_UNKNOWN_ENTITY_KEY(e,x));continue}let p=n(f.resolvedShapes,e);for(let[o,r]of Object.entries(s))for(let[s,n]of Object.entries(r)){let r=t(s,e,o,l);if(!r)continue;let m=i({typeOrAlias:e,instanceName:r,componentName:o,rawProps:n},{resolvedShape:p,parsingContext:l,typeResolution:a});O.push(m.entry),c.push(...m.inferredExpressions),u.push(...m.expressionReads)}}return{components:e(O),expressions:c,expressionReads:u}};

package/dist/application-spec/parse-application-files/spec/expressions/expression-read-types.d.ts

@@ -0,0 +1,24 @@
+import type { SpecExpression } from '#package/domain';
+import type { ParseContext } from '../../../core/index.js';
+import type { EntityOrAliasName, ExpressionName, ModelTypeResolution } from '../model/index.js';
+import type { ExpressionRead } from './expression-read.js';
+/** Where an expression is declared: the spec section and the entity or alias under it. */
+export interface ExpressionLocation {
+    readonly section: string;
+    readonly entityKey: EntityOrAliasName;
+}
+interface ExpressionReadTypesInput {
+    readonly userExpressions: readonly SpecExpression[];
+    readonly expressionReads: readonly ExpressionRead[];
+    /** Finds where a read expression is declared, which is where a conflict is reported. */
+    readonly locateDeclaration: (entityKey: EntityOrAliasName, name: ExpressionName) => ExpressionLocation;
+}
+/**
+ * Reports an expression whose declared type and the types its `$read`s expect have no value in
+ * common, or whose `$read`s expect types that have none: generated code types the expression by
+ * the intersection of them all, which no value can be, so the implementation cannot type-check.
+ * A type given as `tsType` text is not read, and never reported. Relation and invariant
+ * expressions state their types only as `tsType`, so only a conflict among their reads is reported.
+ */
+export declare const checkExpressionReadTypes: ({ userExpressions, expressionReads, locateDeclaration }: ExpressionReadTypesInput, typeResolution: ModelTypeResolution, ctx: ParseContext) => void;
+export {};

package/dist/application-spec/parse-application-files/spec/expressions/expression-read-types.js

@@ -0,0 +1 @@
+import{DiagnosticCode as e,diagnosticMessages as t}from"../../../errors/index.js";import{ValueType as r,formatValueType as n,intersectValueTypes as o}from"../common/index.js";export const checkExpressionReadTypes=({userExpressions:i,expressionReads:a,locateDeclaration:c},d,l)=>{let s=new Map,m=(e,t)=>{let r=`${String(e)}\0${String(t)}`,n=s.get(r);return n||(n={entityKey:e,name:t,reads:[]},s.set(r,n)),n};for(let e of i)e.declaredSchema&&(m(e.entityKey,e.name).declared=r(e.declaredSchema,{...d,author:"project"}));for(let e of a)m(e.entityKey,e.name).reads.push(e);for(let{entityKey:r,name:i,declared:a,reads:d}of s.values()){let[s,...m]=[...a?[a]:[],...d.map(e=>e.expected)];if(!s||m.reduce(o,s).length>0)continue;let p=c(r,i);l.at(p.section,String(p.entityKey),String(i)).error(e.EXPRESSION_READ_TYPE_CONFLICT,t.EXPRESSION_READ_TYPE_CONFLICT(String(p.entityKey),String(i),a&&n(a),d.map(e=>`${n(e.expected)} at "${e.location}"`)))}};

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

@@ -0,0 +1,13 @@
+import type { ValueType } from '../common/index.js';
+import type { EntityOrAliasName, ExpressionName } from '../model/index.js';
+/**
+ * A `$read` of an expression in a component, with the type the component expects where the value
+ * goes: a prop, the whole state, a filter criterion or the whole filter.
+ */
+export interface ExpressionRead {
+    readonly entityKey: EntityOrAliasName;
+    readonly name: ExpressionName;
+    readonly expected: ValueType;
+    /** The place of the read, such as `Hole.detail.main.title`. */
+    readonly location: string;
+}

package/dist/application-spec/parse-application-files/spec/expressions/expression-value-type.d.ts

@@ -0,0 +1,9 @@
+import { type EnhancedJsonValue } from '../../../core/index.js';
+import { ValueType } from '../common/index.js';
+import type { ModelTypeResolution } from '../model/index.js';
+/**
+ * The type generated code gives the inline value of an expression that declares a schema: a `$msg`
+ * compiles to a lingui `MessageDescriptor`. The only other such value is an `$eval`, which is code
+ * whose type is not read; constants never declare a schema.
+ */
+export declare const expressionValueType: (value: EnhancedJsonValue, resolution: ModelTypeResolution) => ValueType;

package/dist/application-spec/parse-application-files/spec/expressions/expression-value-type.js

@@ -0,0 +1 @@
+import{isMsgMarker as e}from"../../../core/index.js";import{ValueType as o}from"../common/index.js";let r=[{kind:"unknown"}];export const expressionValueType=(n,s)=>e(n)?o({$ref:"phx:MessageDescriptor"},{...s,author:"sdk"}):r;

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

@@ -1,42 +1,24 @@
-import { Branded } from '@salsita-ai/common/utils';
-import { type EvalExpressionParser, type ParseContext } from '../../../core/index.js';
+import type { Expressions as ExpressionsData, SpecExpression } from '#package/domain';
+import { type EvalExpressionParser, type ParseContext, type PhoenixDefinitions } from '../../../core/index.js';
 import type { MergedExpressions } from '../../merge/index.js';
-import type { Aliases, EntityOrAliasName, EntityTypeName, ExpressionName, ModelVersion } from '../model/index.js';
-import type { Expression } from './expression.js';
-import type { MemoEvalPlan } from './memo-eval-plan.js';
-export type { Expression, ExpressionImplementation } from './expression.js';
-/**
- * Resolved expressions for a single entity type. Holds the ordered list of
- * shape source keys (entity itself + aliases it belongs to) — codegen appends
- * `"Expressions"` to each key to reference the typed expression group.
- */
-export type EntityExpressions = Branded<'EntityExpressions', {
-    /** Entity/alias keys whose expressions this entity inherits. Codegen appends "Expressions" suffix. */
-    readonly shapeGroups: readonly EntityOrAliasName[];
-}>;
-/**
- * Final merged expressions for a domain — user-declared + inferred.
- * The internal `expressions` map groups by entity/alias for codegen/runtime lookups.
- * `entityExpressions` provides per-entity alias expansion.
- * `constants` projects the self-free `constants:` values, grouped like `expressions`;
- * codegen passes them to the enhanced entity/alias reflections so they are readable at
- * module level (`phx.domain.enhancedModel.$Wall.$maxWidth`). A constant whose plan uses
- * `self` needs an instance, so it stays an ordinary value expression and is absent here.
- */
-export type Expressions = Branded<'Expressions', {
-    readonly expressions: ReadonlyMap<EntityOrAliasName, ReadonlyMap<ExpressionName, Expression>>;
-    readonly entityExpressions: ReadonlyMap<EntityTypeName, EntityExpressions>;
-    readonly constants: ReadonlyMap<EntityOrAliasName, ReadonlyMap<ExpressionName, MemoEvalPlan>>;
-}>;
+import { type Aliases, type EntityTypeName, type ModelVersion } from '../model/index.js';
+import type { ExpressionRead } from './expression-read.js';
+export type { EntityExpressions } from '#package/domain';
+export type { ExpressionImplementation, SpecExpression as Expression } from '#package/domain';
+/** The merged expressions of a domain; see {@link ExpressionsData | Expressions} in `domain`. */
+export type Expressions = ExpressionsData;
 interface ExpressionsProps {
     readonly rawExpressions: MergedExpressions;
-    readonly inferredExpressions: readonly Expression[];
+    readonly inferredExpressions: readonly SpecExpression[];
+    /** The `$read`s of expressions in components, whose expected types the expressions must share. */
+    readonly expressionReads: readonly ExpressionRead[];
 }
 interface ExpressionsContext {
     readonly latestModel: ModelVersion;
     readonly aliases: Aliases;
     readonly entityTypes: readonly EntityTypeName[];
     readonly evalExpressionParser: EvalExpressionParser;
+    readonly phxDefinitions: PhoenixDefinitions;
     readonly parsingContext: ParseContext;
 }
 /**