@salsita-ai/sdk 0.50.0-develop.bc4bdb2ffc → 0.50.0-develop.bd84173265

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/component-entry.d.ts

@@ -1,4 +1,5 @@
 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 { EntityOrAliasName, InstanceName } from '../model/index.js';
 import type { ComponentReadBinding, ComponentWriteBinding } from './bindings/index.js';
@@ -46,15 +47,6 @@ interface UserBoundImplementation {
     readonly plan: MemoEvalPlan;
     readonly implementation: RootReadImplementation | CompositeImplementation;
 }
-/**
- * A parameter that should be emitted as an unquoted code reference in codegen
- * (e.g. an entity reflection variable like `Top`).
- * At runtime, the string value is resolved to the actual object (e.g. entity reflection).
- */
-export interface SdkCodeRef {
-    readonly $codeRef: string;
-}
-export declare const isSdkCodeRef: (value: unknown) => value is SdkCodeRef;
 export type SdkFactoryParam = SdkCodeRef | string | number | boolean | null | readonly SdkFactoryParam[] | {
     readonly [key: string]: SdkFactoryParam;
 };

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

@@ -1 +1 @@
-export const isSdkCodeRef=e=>"object"==typeof e&&null!==e&&"$codeRef"in e&&"string"==typeof e.$codeRef;
+export{};

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

@@ -1,58 +1,5 @@
 import { Branded } from '@salsita-ai/common/utils';
-import { type EnhancedJsonSchemaType, type EnhancedJsonValue } from '../../../core/index.js';
-/**
- * A single filter criterion — static value, dynamic `$read` reference, or
- * inline `$eval` expression evaluated against `self` at runtime.
- *
- * The `target` field on the `'dynamic'` variant is a bare name (matches the
- * same pattern as prop-level reads); codegen emits `self.target`, runtime
- * reads `self[target]`.
- */
-export type FilterCriterion<T> = {
-    readonly kind: 'static';
-    readonly value: T;
-} | {
-    readonly kind: 'dynamic';
-    readonly target: string;
-} | {
-    readonly kind: 'eval';
-    readonly code: string;
-};
-/**
- * Parsed component filter controlling when the component is active. Two
- * mutually-exclusive shapes:
- *
- * - `'gradual'` — zero or more per-criterion fields; compiles to one entry per
- *   set key inside `.withGradualFilter({…})`. The preferred form.
- * - `'root'` — the entire filter is a single `$read` at the root (legacy
- *   form `$filter: { $read: '$x' }`); compiles to `.withFilter(self => (self.target))`.
- *   Distinct codegen because the SDK's `withFilter` and `withGradualFilter`
- *   methods have different evaluation semantics (whole-closure vs per-key).
- *
- * See `components.md §"Simple expression filter"` / `§"Declarative filter"`.
- */
-export type ComponentFilter = {
-    readonly kind: 'gradual';
-    readonly navigationStates?: FilterCriterion<readonly string[]>;
-    readonly viewStates?: FilterCriterion<readonly string[]>;
-    readonly toolStates?: FilterCriterion<readonly string[]>;
-    readonly exportStates?: FilterCriterion<readonly string[]>;
-    readonly modes?: FilterCriterion<readonly string[]>;
-    readonly roles?: FilterCriterion<readonly string[]>;
-    readonly selectedEntityIds?: FilterCriterion<unknown>;
-    readonly hoveredEntityIds?: FilterCriterion<unknown>;
-    readonly draggedEntityIds?: FilterCriterion<unknown>;
-    readonly exportedEntityIds?: FilterCriterion<unknown>;
-    readonly active?: FilterCriterion<boolean>;
-    readonly fullscreen?: FilterCriterion<boolean>;
-    readonly debug?: FilterCriterion<boolean>;
-    readonly viewports?: FilterCriterion<unknown>;
-} | {
-    readonly kind: 'root';
-    readonly target: string;
-};
-/** Criterion field names on the gradual variant — used for parse and iteration. */
-export declare const FILTER_CRITERION_KEYS: readonly ["navigationStates", "viewStates", "toolStates", "exportStates", "modes", "roles", "selectedEntityIds", "hoveredEntityIds", "draggedEntityIds", "exportedEntityIds", "active", "fullscreen", "debug", "viewports"];
+import { type ComponentFilter, 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

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

@@ -1 +1 @@
-import{Branded as t}from"@salsita-ai/common/utils";import{FILTER_OR_KEY as e,READ_MARKER_KEY as r,isEnhancedJsonObject as i,isEvalMarker as s,isRawReadMarker as a}from"../../../core/index.js";export const FILTER_CRITERION_KEYS=["navigationStates","viewStates","toolStates","exportStates","modes","roles","selectedEntityIds","hoveredEntityIds","draggedEntityIds","exportedEntityIds","active","fullscreen","debug","viewports"];let o={tsType:"IdOrWithId | readonly IdOrWithId[]",import:[{module:"@salsita-ai/sdk/domain",member:"IdOrWithId"}]};export const FILTER_CRITERION_SCHEMAS={navigationStates:{type:"array",items:{type:"string"}},viewStates:{type:"array",items:{type:"string"}},toolStates:{type:"array",items:{type:"string"}},exportStates:{type:"array",items:{type:"string"}},modes:{type:"array",items:{type:"string"}},roles:{type:"array",items:{type:"string"}},selectedEntityIds:o,hoveredEntityIds:o,draggedEntityIds:o,exportedEntityIds:o,active:{type:"boolean"},fullscreen:{type:"boolean"},debug:{type:"boolean"},viewports:{type:"array",items:{type:"string"},tsType:"readonly Viewport[]",import:[{module:"@salsita-ai/sdk/domain",member:"Viewport"}]}};let n=new Set(FILTER_CRITERION_KEYS),d=t=>a(t)?{kind:"dynamic",target:t[r]}:s(t)?{kind:"eval",code:t.$eval}:{kind:"static",value:t},y=t=>{let e=t[r];if("string"==typeof e&&!Object.keys(t).some(t=>n.has(t)))return{kind:"root",target:e};let i={};for(let[e,r]of Object.entries(t))n.has(e)&&void 0!==r&&(i[e]=d(r));return{kind:"gradual",...i}};export const ComponentFilters=r=>{if(void 0===r||!i(r))return t({items:[]});let s=r[e];return Array.isArray(s)?t({items:s.filter(i).map(y)}):t({items:[y(r)]})};
+import{Branded as t}from"@salsita-ai/common/utils";import{FILTER_CRITERION_KEYS as e,FILTER_OR_KEY as r,READ_MARKER_KEY as i,isEnhancedJsonObject as s,isEvalMarker as a,isRawReadMarker as o}from"../../../core/index.js";let n={tsType:"IdOrWithId | readonly IdOrWithId[]",import:[{module:"@salsita-ai/sdk/domain",member:"IdOrWithId"}]};export const FILTER_CRITERION_SCHEMAS={navigationStates:{type:"array",items:{type:"string"}},viewStates:{type:"array",items:{type:"string"}},toolStates:{type:"array",items:{type:"string"}},exportStates:{type:"array",items:{type:"string"}},modes:{type:"array",items:{type:"string"}},roles:{type:"array",items:{type:"string"}},selectedEntityIds:n,hoveredEntityIds:n,draggedEntityIds:n,exportedEntityIds:n,active:{type:"boolean"},fullscreen:{type:"boolean"},debug:{type:"boolean"},viewports:{type:"array",items:{type:"string"},tsType:"readonly Viewport[]",import:[{module:"@salsita-ai/sdk/domain",member:"Viewport"}]}};let y=new Set(e),d=t=>o(t)?{kind:"dynamic",target:t[i]}:a(t)?{kind:"eval",code:t.$eval}:{kind:"static",value:t},p=t=>{let e=t[i];if("string"==typeof e&&!Object.keys(t).some(t=>y.has(t)))return{kind:"root",target:e};let r={};for(let[e,i]of Object.entries(t))y.has(e)&&void 0!==i&&(r[e]=d(i));return{kind:"gradual",...r}};export const ComponentFilters=e=>{if(void 0===e||!s(e))return t({items:[]});let i=e[r];return Array.isArray(i)?t({items:i.filter(s).map(p)}):t({items:[p(e)]})};

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/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,5 +1,5 @@
 export * from './bindings/index.js';
-export * from './component-entry.js';
+export type * from './component-entry.js';
 export * from './component-filter.js';
 export * from './component-prop-target.js';
 export * from './components.js';

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

@@ -1 +1 @@
-export*from"./bindings/index.js";export*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";export*from"./user-components.js";
+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";

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,4 +1,6 @@
 import { type EnhancedJsonObject, type ParseContext } from '../../../core/index.js';
+import { type ValueTypeResolution } from '../common/index.js';
+import type { ExpressionRead } from '../expressions/expression-read.js';
 import type { Expression } from '../expressions/expression.js';
 import type { EntityOrAliasName, InstanceName, ResolvedShape } from '../model/index.js';
 import type { ComponentEntry } from './component-entry.js';
@@ -11,10 +13,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[];
+    /** 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 m,isImportRefShaped as p,isRawBindMarker as s,isRawDataRefMarker as l,isRawEvalWriteMarker as d,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/memo-eval-plan.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 v}from"./filter-criterion-types.js";import{checkStaticEntityId as _}from"./static-entity-id.js";let x=(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(l(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(m(e))return e;if(p(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)=>x(e,[...t,i],n,r)).filter(e=>void 0!==e);let i={};for(let[o,a]of Object.entries(e)){let e=x(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=(m,p)=>{let{implementation:l,inferredExpressions:c,expressionReads:T}=((m,p)=>{let l,c=t.get(m.componentName),T=c?.schema,P=new Set,w=[],D=[],I=[],K={entityKey:m.typeOrAlias,componentName:m.componentName,instanceName:m.instanceName,resolvedShape:p.resolvedShape,parsingContext:p.parsingContext},B={entityKey:m.typeOrAlias,componentName:m.componentName,instanceName:m.instanceName,resolvedShape:p.resolvedShape,parsingContext:p.parsingContext},F={...K,typeResolution:p.typeResolution},M=e=>T?$(l??=E(T,p.typeResolution),e):[{kind:"unknown"}],G=[],V=e=>{b(e.target)?G.push({entityKey:m.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:m}=y(r,n),p=n=>e({entityKey:i,name:t,schema:n,implementation:{kind:"user"}});if(void 0!==a){let e=m.map(e=>"number"==typeof e?"[number]":`['${e}']`).join("");return p({...o,tsType:`${a.tsType}${e}`,import:a.import})}if(Object.keys(o).length>0)return p(o)})(t,n,T,m.typeOrAlias);r&&I.push(r)}},W={addReadBinding:L,checkStaticValue:(e,t)=>_(e,t,M(t),K)},q=h(m.rawProps[r]);((e,t,o,m)=>{let p=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){m({marker:"$read",target:a.target,path:t,expected:p(v)});continue}for(let e of n){let n=a[e],r=[...t,e],i=p(j[e]);n?.kind==="dynamic"?m({marker:"$read",target:n.target,path:r,expected:i}):n?.kind==="static"&&U(n.value,r,i,o)}}})(m.rawProps[r],q,F,V);let z=`${String(m.typeOrAlias)}.${String(m.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})(m.rawProps)){let e=m.rawProps[o];return L(e,[],"$read"),C(q,m.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(m.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(d(t)){D.push(A(e,t.$write,B)),H[e]={$eval:t.$eval};continue}let n=x(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?p.parsingContext.error(u.WRITE_BINDING_DUPLICATE_TARGET,g.WRITE_BINDING_DUPLICATE_TARGET(String(m.typeOrAlias),m.componentName,String(m.instanceName),e.entityField,t,e.propKey)):J.set(e.entityField,e.propKey)}return C(q,m.typeOrAlias,I),{implementation:{kind:"userBound",filters:q,plan:O(H,z),implementation:{kind:"composite",resolvedProps:H,readBindings:w,writeBindings:D}},inferredExpressions:I,expressionReads:G}})(m,p);return{entry:e({typeOrAlias:m.typeOrAlias,instanceName:m.instanceName,isAlias:"alias"===p.resolvedShape.kind,componentName:m.componentName,implementation:l}),inferredExpressions:c,expressionReads:T}};

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

@@ -1,19 +1,22 @@
 import { Branded } from '@salsita-ai/common/utils';
-import type { ParseContext } from '../../../core/index.js';
+import type { ParseContext, PhoenixDefinitions } from '../../../core/index.js';
 import type { MergedComponents } from '../../merge/index.js';
+import type { ExpressionRead } from '../expressions/expression-read.js';
 import type { Expression } from '../expressions/expression.js';
-import type { ResolvedShapes } from '../model/index.js';
+import type { ModelVersion } from '../model/index.js';
 import type { ComponentEntry } from './component-entry.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[];
+    /** 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,19 @@
+import type { ParseContext } from '../../../core/index.js';
+import type { ModelTypeResolution } from '../model/index.js';
+import type { ExpressionRead } from './expression-read.js';
+import type { Expression } from './expression.js';
+interface ExpressionReadTypesInput {
+    readonly userExpressions: readonly Expression[];
+    readonly expressionReads: readonly ExpressionRead[];
+    /** The spec section that declares an expression (`relations` or `invariants` for theirs), where it is reported. */
+    readonly sectionOf: (entityKey: string, name: string) => string;
+}
+/**
+ * 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, sectionOf }: 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 r}from"../../../errors/index.js";import{ValueType as t,formatValueType as o,intersectValueTypes as a}from"../common/index.js";export const checkExpressionReadTypes=({userExpressions:n,expressionReads:c,sectionOf:d},i,l)=>{let m=new Map,p=(e,r)=>{let t=`${e}\0${r}`,o=m.get(t);return o||(o={entityKey:e,name:r,reads:[]},m.set(t,o)),o};for(let e of n)e.declaredSchema&&(p(String(e.entityKey),String(e.name)).declared=t(e.declaredSchema,{...i,author:"project"}));for(let e of c)p(String(e.entityKey),String(e.name)).reads.push(e);for(let{entityKey:t,name:n,declared:c,reads:i}of m.values()){let[m,...p]=[...c?[c]:[],...i.map(e=>e.expected)];m&&!(p.reduce(a,m).length>0)&&l.at(d(t,n),t,n).error(e.EXPRESSION_READ_TYPE_CONFLICT,r.EXPRESSION_READ_TYPE_CONFLICT(t,n,c&&o(c),i.map(e=>`${o(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-read.js

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

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

@@ -1,32 +1,7 @@
 import type { Branded } from '@salsita-ai/common/utils';
-import type { EnhancedJsonSchemaType, EnhancedJsonValue } from '../../../core/index.js';
+import type { EnhancedJsonSchemaType, EnhancedJsonValue, SdkExpressionImplementation } from '../../../core/index.js';
 import type { EntityOrAliasName, ExpressionName } from '../model/index.js';
 import type { MemoEvalPlan } from './memo-eval-plan.js';
-/**
- * The relation factory's single positional param: the relation's kind, the entity type or alias it
- * points to and its cardinality, plus the id field for `direct` and `indirect` relations. The
- * assistant schema reads `target` and `cardinality` to type a relation edge.
- */
-export interface RelationExpressionParams {
-    readonly kind: 'direct' | 'indirect' | 'allOfType';
-    readonly target: string;
-    readonly cardinality: '0-1' | '1-1' | '0-N' | '1-N';
-    readonly field?: string;
-}
-/**
- * An expression implementation built by an SDK factory at runtime. The kind is the
- * semantic source of the expression, declared by the section that generated it —
- * codegen and runtime dispatch on it instead of inspecting factory-function names.
- * - `relation`: generated from a `relations:` declaration
- * - `violations`: generated from `invariants:` declarations (the `$violations` expression)
- */
-export type SdkExpressionImplementation = {
-    readonly kind: 'relation';
-    readonly params: readonly [RelationExpressionParams];
-} | {
-    readonly kind: 'violations';
-    readonly params: readonly unknown[];
-};
 /**
  * How an expression's runtime implementation is provided.
  * - `user`: implementation from `src/expressions/*.ts` (dynamic import)
@@ -47,8 +22,6 @@ export type ExpressionImplementation = {
     readonly value: EnhancedJsonValue;
     readonly plan: MemoEvalPlan;
 };
-/** Narrows to implementations that are built by an SDK expression factory at runtime. */
-export declare const isSdkExpressionImplementation: (implementation: ExpressionImplementation) => implementation is SdkExpressionImplementation;
 /** A single parsed expression declaration. */
 export type Expression = Branded<'Expression', {
     readonly entityKey: EntityOrAliasName;

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

@@ -1 +1 @@
-export const isSdkExpressionImplementation=i=>"relation"===i.kind||"violations"===i.kind;
+export{};

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

@@ -1,8 +1,9 @@
 import { Branded } from '@salsita-ai/common/utils';
-import { type EvalExpressionParser, type ParseContext } from '../../../core/index.js';
+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 Aliases, type EntityOrAliasName, type EntityTypeName, type ExpressionName, type ModelVersion } from '../model/index.js';
+import type { ExpressionRead } from './expression-read.js';
+import type { Expression } from './expression.js';
 import type { MemoEvalPlan } from './memo-eval-plan.js';
 export type { Expression, ExpressionImplementation } from './expression.js';
 /**
@@ -31,12 +32,15 @@ export type Expressions = Branded<'Expressions', {
 interface ExpressionsProps {
     readonly rawExpressions: MergedExpressions;
     readonly inferredExpressions: readonly Expression[];
+    /** The `$read`s of expressions in components, whose expected types the expressions must share. */
+    readonly expressionReads: readonly ExpressionRead[];
 }
 interface ExpressionsContext {
     readonly latestModel: ModelVersion;
     readonly aliases: Aliases;
     readonly entityTypes: readonly EntityTypeName[];
     readonly evalExpressionParser: EvalExpressionParser;
+    readonly phxDefinitions: PhoenixDefinitions;
     readonly parsingContext: ParseContext;
 }
 /**

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

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{intersectSchemas as t}from"../../../core/index.js";import{DiagnosticCode as n,diagnosticMessages as o}from"../../../errors/index.js";import{isSdkExpressionImplementation as i}from"./expression.js";import{UserExpressions as r}from"./user-expressions.js";let s=(e,t)=>{let n=e.get(t.entityKey);n||(n=new Map,e.set(t.entityKey,n)),n.set(t.name,t)},a=(n,o)=>{let i=n.get(o.entityKey);i||(i=new Map,n.set(o.entityKey,i));let r=i.get(o.name);r?i.set(o.name,e({...r,schema:t(r.schema,o.schema),...r.declaredSchema||!o.declaredSchema?{}:{declaredSchema:o.declaredSchema}})):i.set(o.name,o)},l=e=>"relation"===e.implementation.kind?"relations":"violations"===e.implementation.kind?"invariants":"expressions";export const Expressions=(t,m)=>{let{rawExpressions:f,inferredExpressions:p}=t,{latestModel:c,aliases:d,entityTypes:y,evalExpressionParser:u,parsingContext:g}=m,x=r(f,{latestModel:c,evalExpressionParser:u,parsingContext:g});if(void 0===x)return;let S=new Map;for(let e of x)s(S,e);for(let e of p)a(S,e);let h=((e,t)=>{let n=new Map,o=e=>{let t=n.get(e.entityKey);t||(t=new Set,n.set(e.entityKey,t)),t.add(e.name)};for(let t of e)o(t);for(let e of t)i(e.implementation)&&o(e);return n})(x,p),w=new Map;for(let e of x){let{implementation:t}=e;if("value"!==t.kind||!t.constant||t.plan.usesSelf)continue;let n=w.get(e.entityKey);n||(n=new Map,w.set(e.entityKey,n)),n.set(e.name,t.plan)}let K=new Map;for(let t of y){let i=[],r=new Map,s=e=>{let s=S.get(e);if(!s||0===s.size)return;i.push(e);let a=h.get(e);for(let[i,m]of s){if(!a?.has(i))continue;let s=r.get(i);if(s){g.at(l(m),e,i).error(n.DUPLICATE_EXPRESSION,o.DUPLICATE_EXPRESSION(t,i,s,e));continue}r.set(i,e)}};for(let[e,n]of d)n.includes(t)&&s(e);s(t),K.set(t,e({shapeGroups:i}))}return e({expressions:S,entityExpressions:K,constants:w})};
+import{Branded as e}from"@salsita-ai/common/utils";import{intersectSchemas as t,isSdkExpressionImplementation as n}from"../../../core/index.js";import{DiagnosticCode as o,diagnosticMessages as i}from"../../../errors/index.js";import{ModelTypeResolution as r}from"../model/index.js";import{checkExpressionReadTypes as s}from"./expression-read-types.js";import{UserExpressions as a}from"./user-expressions.js";let l=(e,t)=>{let n=e.get(t.entityKey);n||(n=new Map,e.set(t.entityKey,n)),n.set(t.name,t)},f=(n,o)=>{let i=n.get(o.entityKey);i||(i=new Map,n.set(o.entityKey,i));let r=i.get(o.name);r?i.set(o.name,e({...r,schema:t(r.schema,o.schema),...r.declaredSchema||!o.declaredSchema?{}:{declaredSchema:o.declaredSchema}})):i.set(o.name,o)},m=e=>"relation"===e.implementation.kind?"relations":"violations"===e.implementation.kind?"invariants":"expressions";export const Expressions=(t,p)=>{let{rawExpressions:c,inferredExpressions:d,expressionReads:y}=t,{latestModel:g,aliases:u,entityTypes:x,evalExpressionParser:S,parsingContext:h}=p,w=a(c,{latestModel:g,evalExpressionParser:S,parsingContext:h});if(void 0===w)return;let M=new Map;for(let e of w)l(M,e);for(let e of d)f(M,e);let K=new Map;for(let[e,t]of M)for(let[n,o]of t)K.set(`${String(e)}\0${String(n)}`,m(o));s({userExpressions:w,expressionReads:y,sectionOf:(e,t)=>K.get(`${e}\0${t}`)??"expressions"},r(g,p.phxDefinitions),h);let E=((e,t)=>{let o=new Map,i=e=>{let t=o.get(e.entityKey);t||(t=new Set,o.set(e.entityKey,t)),t.add(e.name)};for(let t of e)i(t);for(let e of t)n(e.implementation)&&i(e);return o})(w,d),j=new Map;for(let e of w){let{implementation:t}=e;if("value"!==t.kind||!t.constant||t.plan.usesSelf)continue;let n=j.get(e.entityKey);n||(n=new Map,j.set(e.entityKey,n)),n.set(e.name,t.plan)}let v=new Map;for(let t of x){let n=[],r=new Map,s=e=>{let s=M.get(e);if(!s||0===s.size)return;n.push(e);let a=E.get(e);for(let[n,l]of s){if(!a?.has(n))continue;let s=r.get(n);if(s){h.at(m(l),e,n).error(o.DUPLICATE_EXPRESSION,i.DUPLICATE_EXPRESSION(t,n,s,e));continue}r.set(n,e)}};for(let[e,n]of u)n.includes(t)&&s(e);s(t),v.set(t,e({shapeGroups:n}))}return e({expressions:M,entityExpressions:v,constants:j})};

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

@@ -1,5 +1,4 @@
 export type * from './expression.js';
-export { isSdkExpressionImplementation } from './expression.js';
 export * from './expressions.js';
 export * from './memo-eval-plan.js';
 export * from './user-expressions.js';

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

@@ -1 +1 @@
-export{isSdkExpressionImplementation}from"./expression.js";export*from"./expressions.js";export*from"./memo-eval-plan.js";export*from"./user-expressions.js";
+export*from"./expressions.js";export*from"./memo-eval-plan.js";export*from"./user-expressions.js";

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

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{evalCodeUsesSelf as r}from"../../../core/eval-code-uses-self.js";import{isEvalMarker as t,isMsgMarker as n}from"../../../core/index.js";import{isComponentPropTarget as o}from"../components/component-prop-target.js";let l=(e,r)=>0===r.length?e:`${e}.${r.join(".")}`,i=(r,a,u,d)=>{if(void 0===r)throw Error(`MemoEvalPlan: found undefined at ${l(u,d)}, undefined cannot be generated, remove the property or use null.`);if(t(r)){let t=((r,t,n)=>{let o=t.trim();for(let e=0;e<r.length;e++){let t=r[e];if("eval"===t.kind&&t.code===o)return e}return r.push(e({kind:"eval",code:o,label:n})),r.length-1})(a,r.$eval,u);return e({kind:"slot",depIndex:t})}if(o(r)){let t=((r,t)=>{for(let e=0;e<r.length;e++){let n=r[e];if("read"===n.kind&&n.target===t)return e}return r.push(e({kind:"read",target:t})),r.length-1})(a,r.$target);return e({kind:"slot",depIndex:t})}if(n(r))return e({kind:"msg",marker:r});if(null===r||"object"!=typeof r)return e({kind:"literal",value:r});if(Array.isArray(r))return e({kind:"array",items:r.map((e,r)=>i(e,a,u,[...d,String(r)]))});if("object"!=typeof r||null===r)throw Error(`MemoEvalPlan: found unsupported value at ${l(u,d)}, remove it or use null.`);let f=[];for(let e in r){let t=r[e];f.push([e,i(t,a,u,[...d,e])])}return e({kind:"object",entries:f})};export const MemoEvalPlan=(t,n)=>{let o=[],l=i(t,o,n,[]),a=o.some(e=>"read"===e.kind||r(e.code));return e({deps:o,template:l,usesSelf:a})};
+import{Branded as e}from"@salsita-ai/common/utils";import{isEvalMarker as r,isMsgMarker as t}from"../../../core/index.js";import{evalCodeUsesSelf as n}from"../../../enhanced-json/eval-code-uses-self.js";import{isComponentPropTarget as o}from"../components/component-prop-target.js";let l=(e,r)=>0===r.length?e:`${e}.${r.join(".")}`,i=(n,a,d,u)=>{if(void 0===n)throw Error(`MemoEvalPlan: found undefined at ${l(d,u)}, undefined cannot be generated, remove the property or use null.`);if(r(n)){let r=((r,t,n)=>{let o=t.trim();for(let e=0;e<r.length;e++){let t=r[e];if("eval"===t.kind&&t.code===o)return e}return r.push(e({kind:"eval",code:o,label:n})),r.length-1})(a,n.$eval,d);return e({kind:"slot",depIndex:r})}if(o(n)){let r=((r,t)=>{for(let e=0;e<r.length;e++){let n=r[e];if("read"===n.kind&&n.target===t)return e}return r.push(e({kind:"read",target:t})),r.length-1})(a,n.$target);return e({kind:"slot",depIndex:r})}if(t(n))return e({kind:"msg",marker:n});if(null===n||"object"!=typeof n)return e({kind:"literal",value:n});if(Array.isArray(n))return e({kind:"array",items:n.map((e,r)=>i(e,a,d,[...u,String(r)]))});if("object"!=typeof n||null===n)throw Error(`MemoEvalPlan: found unsupported value at ${l(d,u)}, remove it or use null.`);let s=[];for(let e in n){let r=n[e];s.push([e,i(r,a,d,[...u,e])])}return e({kind:"object",entries:s})};export const MemoEvalPlan=(r,t)=>{let o=[],l=i(r,o,t,[]),a=o.some(e=>"read"===e.kind||n(e.code));return e({deps:o,template:l,usesSelf:a})};

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

@@ -1 +1 @@
-import{Branded as e}from"@salsita-ai/common/utils";import{schemaFromValue as t}from"../../../core/index.js";import{DiagnosticCode as r,diagnosticMessages as s}from"../../../errors/index.js";import{ExpressionName as o}from"../model/index.js";import{MemoEvalPlan as a}from"./memo-eval-plan.js";let i=(e,r,s,o)=>{if("user"===e.kind)return{schema:e.schema,implementation:{kind:"user"}};let i=a(e.value,r),m={kind:"value",constant:e.constant,value:e.value,plan:i};if(Object.keys(e.schema).length>0)return{schema:e.schema,implementation:m};let n=t(e.value,s,o);if(void 0!==n)return{schema:n,implementation:m}};export const UserExpressions=(t,a)=>{let{latestModel:m,evalExpressionParser:n,parsingContext:l}=a,{allNames:c}=m,f=[...c].map(String),h=[];for(let[a,m]of Object.entries(t)){c.has(a)||l.error(r.EXPRESSION_UNKNOWN_ENTITY_KEY,s.EXPRESSION_UNKNOWN_ENTITY_KEY(a,f));let t=e(a);for(let[r,s]of Object.entries(m)){let m=l.at(a),c=o(r,m);if(!c)continue;let f=i(s,`${a}.${r}`,m.at(r),n);f&&h.push(e({entityKey:t,name:c,schema:f.schema,declaredSchema:f.schema,implementation:f.implementation}))}}if(!l.hasErrors)return h};
+import{Branded as e}from"@salsita-ai/common/utils";import{schemaFromValue as t}from"../../../enhanced-json/index.js";import{DiagnosticCode as r,diagnosticMessages as n}from"../../../errors/index.js";import{ExpressionName as s}from"../model/index.js";import{MemoEvalPlan as a}from"./memo-eval-plan.js";let o=(e,r,n,s)=>{if("user"===e.kind)return{schema:e.schema,implementation:{kind:"user"}};let o=a(e.value,r),i={kind:"value",constant:e.constant,value:e.value,plan:o};if(Object.keys(e.schema).length>0)return{schema:e.schema,implementation:i};let m=t(e.value,n,s);if(void 0!==m)return{schema:m,implementation:i}};export const UserExpressions=(t,a)=>{let{latestModel:i,evalExpressionParser:m,parsingContext:l}=a,{allNames:c}=i,h=[...c].map(String),f=[];for(let[a,i]of Object.entries(t)){c.has(a)||l.error(r.EXPRESSION_UNKNOWN_ENTITY_KEY,n.EXPRESSION_UNKNOWN_ENTITY_KEY(a,h));let t=e(a);for(let[r,n]of Object.entries(i)){let i=l.at(a),c=s(r,i);if(!c)continue;let h=o(n,`${a}.${r}`,i.at(r),m);h&&f.push(e({entityKey:t,name:c,schema:h.schema,declaredSchema:h.schema,implementation:h.implementation}))}}if(!l.hasErrors)return f};