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

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

@@ -0,0 +1 @@
+import{Branded as o}from"@salsita-ai/common/utils";import{DiagnosticCode as r,diagnosticMessages as s}from"../../../../errors/index.js";let t=/^\$[a-z]\w*$/;export const ExpressionName=(e,i)=>t.test(e)?o(e):void i.error(r.INVALID_EXPRESSION_NAME,s.INVALID_EXPRESSION_NAME(e));

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

@@ -0,0 +1,9 @@
+export * from './alias-name.js';
+export * from './entity-or-alias-name.js';
+export * from './entity-type-name.js';
+export * from './expression-name.js';
+export * from './instance-name.js';
+export * from './invariant-name.js';
+export * from './relation-name.js';
+export * from './shape-property-name.js';
+export * from './violation-type-name.js';

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

@@ -0,0 +1 @@
+export*from"./alias-name.js";export*from"./entity-or-alias-name.js";export*from"./entity-type-name.js";export*from"./expression-name.js";export*from"./instance-name.js";export*from"./invariant-name.js";export*from"./relation-name.js";export*from"./shape-property-name.js";export*from"./violation-type-name.js";

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

@@ -0,0 +1,9 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../../core/index.js';
+/**
+ * Branded component instance name.
+ * User-declared names must start with a letter (e.g. "default", "body", "main").
+ * SDK-derived names may include `$` prefix and `.` separators (e.g. "$top", "Table.$top").
+ */
+export type InstanceName = Branded<'InstanceName', string>;
+export declare const InstanceName: (name: string, entityKey: string, componentName: string, ctx: ParseContext) => InstanceName | undefined;

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

@@ -0,0 +1 @@
+import{Branded as N}from"@salsita-ai/common/utils";import{DiagnosticCode as o,diagnosticMessages as r}from"../../../../errors/index.js";let t=/^[$a-zA-Z][\w.$]*$/;export const InstanceName=(e,s,i,m)=>t.test(e)?N(e):void m.error(o.COMPONENT_INVALID_INSTANCE_NAME,r.COMPONENT_INVALID_INSTANCE_NAME(s,i,e));

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

@@ -0,0 +1,5 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../../core/index.js';
+/** A camelCase identifier for an invariant implementation declared in YAML. */
+export type InvariantName = Branded<'InvariantName', string>;
+export declare const InvariantName: (name: string, ctx: ParseContext) => InvariantName | undefined;

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

@@ -0,0 +1 @@
+import{Branded as r}from"@salsita-ai/common/utils";import{DiagnosticCode as o,diagnosticMessages as t}from"../../../../errors/index.js";let I=/^[a-z]\w*$/;export const InvariantName=(N,i)=>I.test(N)?r(N):void i.error(o.INVALID_INVARIANT_NAME,t.INVALID_INVARIANT_NAME(N));

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

@@ -0,0 +1,9 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../../core/index.js';
+/**
+ * Branded relation name starting with $ followed by camelCase (e.g. "$top", "$legs").
+ * Relations are accessor properties on entities that resolve related entities via state lookup.
+ */
+export type RelationName = Branded<'RelationName', string>;
+/** Validates that a name follows the relation naming convention ($camelCase). */
+export declare const RelationName: (name: string, ctx: ParseContext) => RelationName | undefined;

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

@@ -0,0 +1 @@
+import{Branded as o}from"@salsita-ai/common/utils";import{DiagnosticCode as r,diagnosticMessages as t}from"../../../../errors/index.js";let e=/^\$[a-z]\w*$/;export const RelationName=(i,m)=>e.test(i)?o(i):void m.error(r.INVALID_RELATION_NAME,t.INVALID_RELATION_NAME(i));

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

@@ -0,0 +1,20 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { ParseContext } from '../../../../core/index.js';
+/**
+ * Branded shape property name — the key under which an entity shape (or
+ * alias shape) declares a field, and the key under which `defaults:` attaches
+ * initial values. Must match /^[a-z]\w*$/: start with a lowercase letter,
+ * then word characters (letters, digits, underscore).
+ *
+ * Examples: `height`, `positionX`, `hoodId`. Rejected: `Height`, `$height`,
+ * `3D`, `height-px`.
+ */
+export type ShapePropertyName = Branded<'ShapePropertyName', string>;
+/** Validates `name` as a shape property identifier. Emits `INVALID_SHAPE_PROPERTY_NAME` on failure. */
+export declare const ShapePropertyName: (name: string, ctx: ParseContext) => ShapePropertyName | undefined;
+/**
+ * Type guard — returns true if `name` matches the shape property pattern.
+ * Delegates to {@link ShapePropertyName} with a throwaway context so both paths
+ * share the exact same validation rule.
+ */
+export declare const isShapePropertyName: (name: string) => name is ShapePropertyName;

package/dist/application-spec/parse-application-files/spec/model/names/shape-property-name.js

@@ -0,0 +1 @@
+import{Branded as r}from"@salsita-ai/common/utils";import{ParseContext as o}from"../../../../core/index.js";import{DiagnosticCode as e,diagnosticMessages as t}from"../../../../errors/index.js";let i=/^[a-z]\w*$/;export const ShapePropertyName=(o,m)=>i.test(o)?r(o):void m.error(e.INVALID_SHAPE_PROPERTY_NAME,t.INVALID_SHAPE_PROPERTY_NAME(o));export const isShapePropertyName=r=>void 0!==ShapePropertyName(r,new o);

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

@@ -0,0 +1,5 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../../core/index.js';
+/** A stable violation discriminator returned by an invariant. */
+export type ViolationTypeName = Branded<'ViolationTypeName', string>;
+export declare const ViolationTypeName: (name: string, ctx: ParseContext) => ViolationTypeName | undefined;

package/dist/application-spec/parse-application-files/spec/model/names/violation-type-name.js

@@ -0,0 +1 @@
+import{Branded as o}from"@salsita-ai/common/utils";import{DiagnosticCode as r,diagnosticMessages as t}from"../../../../errors/index.js";let i=/^[a-z][\w-]*$/;export const ViolationTypeName=(e,I)=>i.test(e)?o(e):void I.error(r.INVALID_VIOLATION_TYPE_NAME,t.INVALID_VIOLATION_TYPE_NAME(e));

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

@@ -0,0 +1,40 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../core/index.js';
+import type { MergedPresets } from '../../merge/index.js';
+import type { RawPreset } from '../../raw-spec/index.js';
+import type { Relations } from '../relations/index.js';
+import type { ModelVersion } from './model-version.js';
+/**
+ * A single entity within a preset — id, type, and shape properties.
+ * Properties are validated against the entity's schema from ConfigurationSchema.
+ */
+export type PresetEntity = Branded<'PresetEntity', {
+    readonly id: string;
+    readonly type: string;
+    readonly properties: Readonly<Record<string, unknown>>;
+}>;
+/**
+ * A single parsed preset — the root entity type, initial entities, and optional metadata.
+ * Represents one initial configuration state for a configurator deployment.
+ */
+export type Preset = Branded<'Preset', {
+    readonly rootEntityType: string;
+    readonly initialDomainEntities: readonly PresetEntity[];
+    readonly name?: string;
+    readonly description?: string;
+    readonly img?: string;
+    readonly imgAlt?: string;
+    readonly detailTitle?: string;
+    readonly detailDescription?: string;
+    readonly tags?: readonly string[];
+}>;
+/** All parsed presets for a parsed configurator or admin model. */
+export type Presets = Branded<'Presets', {
+    readonly presets: readonly Preset[];
+}>;
+export declare const Preset: (raw: RawPreset, latestModel: ModelVersion, relations: Relations, ctx: ParseContext) => Preset | undefined;
+/**
+ * Parses and validates merged presets against the domain model.
+ * Validates entity types, ID formats, root entity presence, and entity property schemas.
+ */
+export declare const Presets: (rawPresets: MergedPresets, latestModel: ModelVersion, relations: Relations, ctx: ParseContext) => Presets;

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

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{DomainEntityIdSchema as t}from"#package/domain";import{DiagnosticCode as i,diagnosticMessages as r}from"../../../errors/index.js";let n=new RegExp(t.pattern),E=e=>{let t=e.lastIndexOf("-");if(!(t<=0))return e.slice(0,t)},o=e=>{if(e.references)return e.references;for(let t of["anyOf","oneOf"]){let i=e[t];if(i){for(let e of i)if(e.references)return e.references}}if(e.items)return o(Array.isArray(e.items)?e.items[0]:e.items)},T=e=>"string"==typeof e?[e]:Array.isArray(e)?e.filter(e=>"string"==typeof e):[],a=(e,t)=>{let i=t.aliases.get(e);return i?i.map(String):[e]},l=(e,t,i)=>a(t,i).includes(e.type),s=(e,t,n,E,o,T)=>{let l=a(E,T.latestModel);for(let E of n){let n=o.get(E);if(!n){T.parsingContext.error(i.PRESET_UNKNOWN_REFERENCE,r.PRESET_UNKNOWN_REFERENCE(e,t,E));continue}l.includes(n.type)||T.parsingContext.error(i.PRESET_REFERENCE_TYPE_MISMATCH,r.PRESET_REFERENCE_TYPE_MISMATCH(e,t,E,n.type,l))}},_=(e,t,i,r)=>"direct"===t.kind?T(e.properties[t.field]):"indirect"===t.kind?i.filter(e=>l(e,t.target,r)).filter(i=>{let r,n;return r=t.field,n=e.id,T(i.properties[r]).includes(n)}).map(e=>e.id):i.filter(e=>l(e,t.target,r)).map(e=>e.id),I=(e,t,n,E)=>{"0-N"===t.cardinality||"0-1"===t.cardinality&&n<=1||"1-1"===t.cardinality&&1===n||"1-N"===t.cardinality&&n>=1||E.error(i.PRESET_RELATION_CARDINALITY_VIOLATION,r.PRESET_RELATION_CARDINALITY_VIOLATION(e,String(t.name),t.cardinality,n))},p=(e,t,n,E,o)=>{let T=e.get(n);T||(T=new Set,e.set(n,T)),T.add(E);let a=t.get(E);a&&a!==n?o.error(i.PRESET_COMPOSITION_MULTIPLE_PARENTS,r.PRESET_COMPOSITION_MULTIPLE_PARENTS(E,a,n)):t.set(E,n)};export const Preset=(t,f,N,d)=>{let S,O=new Set(f.entityTypes.map(String)),P=new Set(f.rootEntityTypes.map(String));if(!P.has(t.rootEntityType))return void d.error(i.PRESET_UNKNOWN_ROOT_ENTITY_TYPE,r.PRESET_UNKNOWN_ROOT_ENTITY_TYPE(t.rootEntityType,[...P]));let R=new Map(f.entitySchemas.map(e=>[String(e.entityType),e])),y=0,m=[];for(let E of t.initialDomainEntities){if(E.type===t.rootEntityType&&(y++,S=E.id),!O.has(E.type)){d.error(i.PRESET_UNKNOWN_ENTITY_TYPE,r.PRESET_UNKNOWN_ENTITY_TYPE(E.id,E.type,[...O]));continue}n.test(E.id)||d.warning(i.PRESET_INVALID_ENTITY_ID_FORMAT,r.PRESET_INVALID_ENTITY_ID_FORMAT(E.id));let{id:o,type:T,...a}=E,l=R.get(E.type);if(l)for(let e of l.validateShape(a).errors){let t=e.instancePath?e.instancePath:"(root)";d.error(i.PRESET_ENTITY_SCHEMA_VIOLATION,r.PRESET_ENTITY_SCHEMA_VIOLATION(E.id,E.type,t,e.message))}m.push(e({id:o,type:T,properties:a}))}0===y?d.error(i.PRESET_MISSING_ROOT_ENTITY,r.PRESET_MISSING_ROOT_ENTITY(t.rootEntityType)):y>1&&d.error(i.PRESET_MULTIPLE_ROOT_ENTITIES,r.PRESET_MULTIPLE_ROOT_ENTITIES(t.rootEntityType,y));let g=e({rootEntityType:t.rootEntityType,initialDomainEntities:m,name:t.name,description:t.description,img:t.img,imgAlt:t.imgAlt,detailTitle:t.detailTitle,detailDescription:t.detailDescription,tags:t.tags});return S&&((e,t,n)=>{let f=new Map(e.initialDomainEntities.map(e=>[e.id,e]));((e,t)=>{let n=new Set;for(let o of e){n.has(o.id)&&t.error(i.PRESET_DUPLICATE_ENTITY_ID,r.PRESET_DUPLICATE_ENTITY_ID(o.id)),n.add(o.id);let e=E(o.id);e&&e!==o.type&&t.error(i.PRESET_ENTITY_ID_TYPE_MISMATCH,r.PRESET_ENTITY_ID_TYPE_MISMATCH(o.id,o.type,e))}})(e.initialDomainEntities,n.parsingContext),((e,t,i)=>{let r=new Map(i.latestModel.entitySchemas.map(e=>[String(e.entityType),e]));for(let n of e){let e=r.get(n.type);if(e)for(let[r,E]of Object.entries(e.shapeProperties)){let e=o(E);e&&s(n.id,r,T(n.properties[r]),e,t,i)}}})(e.initialDomainEntities,f,n);var N=e.initialDomainEntities;for(let[e,t]of Object.entries(n.relations.entries)){let i=N.filter(t=>l(t,e,n.latestModel));for(let e of Object.values(t))for(let t of i){let i=_(t,e,N,n.latestModel);I(t.id,e,i.length,n.parsingContext),s(t.id,String(e.name),i,e.target,f,n)}}((e,t,n,E)=>{let o=new Map,T=new Map;for(let[t,i]of Object.entries(E.relations.entries)){let r=e.initialDomainEntities.filter(e=>l(e,t,E.latestModel));for(let t of Object.values(i)){if(!t.composedOf)continue;let i=a(t.target,E.latestModel);for(let a of r)for(let r of _(a,t,e.initialDomainEntities,E.latestModel)){let e=n.get(r);e&&i.includes(e.type)&&p(o,T,a.id,r,E.parsingContext)}}}let s=new Set,I=new Set,f=e=>{if(I.has(e))return void E.parsingContext.error(i.PRESET_COMPOSITION_CYCLE,r.PRESET_COMPOSITION_CYCLE(e));if(!s.has(e)){for(let t of(I.add(e),o.get(e)??[]))f(t);I.delete(e),s.add(e)}};for(let n of(f(t),e.initialDomainEntities))s.has(n.id)||E.parsingContext.error(i.PRESET_ENTITY_NOT_IN_COMPOSITION_TREE,r.PRESET_ENTITY_NOT_IN_COMPOSITION_TREE(n.id,t))})(e,t,f,n)})(g,S,{latestModel:f,relations:N,parsingContext:d}),g};export const Presets=(t,i,r,n)=>{let E=[];for(let e=0;e<t.length;e++){let o=t[e],T=Preset(o,i,r,n.at(`presets[${e}]`));T&&E.push(T)}return e({presets:E})};

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

@@ -0,0 +1,46 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { EnhancedJsonObjectSchemaType, ParseContext } from '../../../core/index.js';
+import { type DataSpec } from '../sections/index.js';
+/**
+ * Published data schema used by generated applications and deployment metadata.
+ *
+ * The schema describes the runtime JSON shape expected from admin publishing.
+ * Without configured chunks it is the merged `publishedData` schema. With
+ * chunks enabled it becomes a chunk map where `system` contains the original
+ * published data properties and data entries are exposed as arrays inside their
+ * assigned chunks.
+ *
+ * The hash is a deterministic 12-character schema fingerprint used to match
+ * deployed client code with compatible published data revisions.
+ */
+export type PublishedDataSchema = Branded<'PublishedDataSchema', {
+    /** Enhanced JSON schema after applying published-data chunk behavior. */
+    readonly schema: EnhancedJsonObjectSchemaType;
+    /** Stable schema hash used by deployment and published-data lookup. */
+    readonly hash: string;
+}>;
+/**
+ * Inputs needed to derive the published data contract from parsed application spec state.
+ *
+ * `publishedData` is the merged application-level schema, including platform
+ * admin fields. `dataSpec` contributes chunk definitions and data entries that
+ * may extend the final published data schema when chunked publishing is enabled.
+ */
+interface PublishedDataSchemaProps {
+    readonly publishedData: EnhancedJsonObjectSchemaType;
+    readonly dataSpec: DataSpec;
+    readonly parsingContext: ParseContext;
+}
+/**
+ * Creates the published data schema and deterministic hash for a parsed application spec.
+ *
+ * Behavior:
+ * - No chunks configured: returns the merged published data schema unchanged.
+ * - Chunks configured: creates one closed object per chunk, copies application
+ *   published data fields into `system`, and appends chunk-assigned data entries
+ *   as arrays under their data-entry keys.
+ * - Data entries without a chunk, or pointing to a chunk not present after
+ *   validation, are ignored for this schema because they are not chunk-published.
+ */
+export declare const PublishedDataSchema: (props: PublishedDataSchemaProps) => PublishedDataSchema | undefined;
+export {};

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

@@ -0,0 +1 @@
+import e from"spark-md5";import{Branded as t,canonicalStringify as r}from"@salsita-ai/common/utils";import{ChunkName as i}from"../sections/index.js";let s=e=>({type:"array",items:{type:"object",properties:Object.fromEntries(Object.entries(e).map(([e,t])=>[e,(e=>Array.isArray(e)?{type:e}:"object"!=typeof e||Array.isArray(e)?{type:e}:"localized"===e.type?{type:"object",properties:{$lang:{type:"object",additionalProperties:{type:"string"}}},required:["$lang"],additionalProperties:!1}:"array"===e.type?{type:"array",items:{type:e.items}}:{type:"integer"===e.type?"number":e.type,...void 0===e.enum?{}:{enum:e.enum}})(t)])),required:Object.keys(e),additionalProperties:!1}}),o=t=>e.hash(r(t)).slice(0,12);export const PublishedDataSchema=e=>{let{publishedData:r,dataSpec:a,parsingContext:p}=e;if(p.hasErrors)return;if(0===Object.keys(a.chunks).length)return t({schema:r,hash:o(r)});let n={};for(let e of Object.keys(a.chunks).sort()){let t=i(e,p);t&&(n[t]="system"===t?{...r.properties}:{})}for(let e of Object.values(a.dataEntries)){if(!e.chunk)continue;let t=i(e.chunk,p);if(!t)continue;let r=n[t];r&&(r[e.key]=s(e.definition))}if(p.hasErrors)return;let y={type:"object",properties:Object.fromEntries(Object.entries(n).map(([e,t])=>[e,{type:"object",properties:t,required:[],additionalProperties:!1}])),required:[],additionalProperties:!1};return t({schema:y,hash:o(y)})};

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

@@ -0,0 +1,41 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { EnhancedJsonSchemaType } from '../../../core/index.js';
+import type { Aliases } from './aliases.js';
+import type { EntityTypes } from './entity-types.js';
+import type { AliasName } from './names/alias-name.js';
+import type { EntityOrAliasName } from './names/entity-or-alias-name.js';
+import type { ShapePropertyName } from './names/shape-property-name.js';
+import type { Shapes } from './shapes/shapes.js';
+/**
+ * Effective shape for an entity type or alias, prepared for downstream consumers.
+ *
+ * Entity shapes merge every contributing alias shape in alias iteration order,
+ * followed by the entity's own shape. Alias shapes contain the intersection of
+ * their resolved member shapes, followed by the alias's own authored shape, so
+ * they expose every property guaranteed for every alias member.
+ */
+export type ResolvedShape = Branded<'ResolvedShape', {
+    readonly name: EntityOrAliasName;
+    readonly kind: 'entity' | 'alias';
+    readonly properties: Readonly<Record<ShapePropertyName, EnhancedJsonSchemaType>>;
+    readonly fieldSchemas: ReadonlyMap<string, EnhancedJsonSchemaType>;
+    readonly contributingAliases: readonly AliasName[];
+    readonly contributingShapes: readonly EntityOrAliasName[];
+    readonly hasOwnShape: boolean;
+}>;
+/** Prepared shape lookup for every entity type and alias in its owning model version. */
+export type ResolvedShapes = Branded<'ResolvedShapes', ReadonlyMap<EntityOrAliasName, ResolvedShape>>;
+/** Runtime-managed entity fields that authors can read but never declare or write. */
+export declare const IMPLICIT_ENTITY_FIELDS: ReadonlySet<string>;
+/**
+ * Reads a prepared shape after the owning model version has validated the name.
+ * A miss indicates a pipeline invariant violation, not invalid author input.
+ */
+export declare const getResolvedShape: (resolvedShapes: ResolvedShapes, name: EntityOrAliasName) => ResolvedShape;
+/**
+ * Prepares effective shapes once at the model-version boundary.
+ *
+ * A result exists for every entity type and alias, including names without an
+ * authored shape, so consumers never need to repeat alias traversal or fallback logic.
+ */
+export declare const ResolvedShapes: (entityTypes: EntityTypes, aliases: Aliases, shapes: Shapes) => ResolvedShapes;

package/dist/application-spec/parse-application-files/spec/model/resolved-shapes.js

@@ -0,0 +1 @@
+import e from"lodash-es/isEqual.js";import{Branded as t}from"@salsita-ai/common/utils";export const IMPLICIT_ENTITY_FIELDS=new Set(["id","type"]);export const getResolvedShape=(e,t)=>{let r=e.get(t);if(!r)throw Error(`Missing prepared shape for model name "${String(t)}"`);return r};let r=(e,r,s,i,o,n,l)=>{let p=new Map(Object.entries(i));return p.set("id",{type:"string"}),p.set("type",{type:"string",enum:s}),t({name:e,kind:r,properties:i,fieldSchemas:p,contributingAliases:o,contributingShapes:n,hasOwnShape:l})},s=t=>{let[r,...s]=t;if(!r)return{};let i={};for(let[t,o]of r.fieldSchemas){if(IMPLICIT_ENTITY_FIELDS.has(t))continue;let r=[o];for(let e of s){let s=e.fieldSchemas.get(t);if(!s){r.length=0;break}r.push(s)}if(0===r.length)continue;let n=r.filter((t,s)=>r.findIndex(r=>e(r,t))===s);i[t]=1===n.length?o:{anyOf:n}}return i};export const ResolvedShapes=(e,i,o)=>{let n=new Map;for(let t of e){let e={},s=[],l=[];for(let[r,n]of i){if(!n.includes(t))continue;let i=o.get(r);i&&(Object.assign(e,i.properties),s.push(r),l.push(r))}let p=o.get(t);p&&(Object.assign(e,p.properties),l.push(t)),n.set(t,r(t,"entity",[String(t)],e,s,l,void 0!==p))}for(let e of i.keys()){let t=[];for(let r of i.get(e)??[]){let e=n.get(r);if(!e)throw Error(`Missing prepared shape for alias member "${String(r)}"`);t.push(e)}let l=o.get(e),p=s(t);l&&Object.assign(p,l.properties),n.set(e,r(e,"alias",(i.get(e)??[]).map(String),p,[],l?[e]:[],void 0!==l))}return t(n)};

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

@@ -0,0 +1,22 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { EnhancedJsonObjectSchemaType, ParseContext } from '../../../core/index.js';
+import type { AppMetadata } from '../sections/index.js';
+/**
+ * Session context schema validated against the application's auth configuration.
+ *
+ * A branded value proves the schema can accept every payload the configured auth
+ * integration produces: with `useClerk` enabled, the built-in Clerk handlers always
+ * return the full `ClerkSessionData` identity fields, and `DomainFactory.parseSessionData`
+ * hard-rejects payloads the schema does not accept (deliberate, per CON-2642) — so an
+ * incompatible schema turns every Clerk sign-in into a runtime 500. This constructor
+ * moves that failure to spec parsing. Without `useClerk`, the project-defined schema
+ * is unrestricted.
+ */
+export type SessionDataSchema = Branded<'SessionDataSchema', EnhancedJsonObjectSchemaType>;
+interface SessionDataSchemaProps {
+    readonly sessionData: EnhancedJsonObjectSchemaType;
+    readonly appMetadata: AppMetadata;
+    readonly parsingContext: ParseContext;
+}
+export declare const SessionDataSchema: (props: SessionDataSchemaProps) => SessionDataSchema | undefined;
+export {};

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

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as t,diagnosticMessages as r}from"../../../errors/index.js";let i=[{name:"id",types:["string"],expected:'type "string"'},{name:"accessToken",types:["string"],expected:'type "string"'},{name:"tags",types:["array"],itemTypes:["string"],expected:'type "array" with items of type "string"'},{name:"emailAddress",types:["string"],expected:'type "string"'},{name:"fullName",types:["string","null"],expected:'type "string | null"'}],s=e=>{if(void 0!==e.type)return Array.isArray(e.type)?e.type:[e.type]},n=(e,t)=>e.length===t.length&&t.every(t=>e.includes(t)),p=e=>void 0===e?'no "type"':`type "${e.join(" | ")}"`;export const SessionDataSchema=a=>{let{sessionData:d,appMetadata:y,parsingContext:m}=a;if(!y.useClerk)return e(d);let l=i.flatMap(e=>{let t=((e,t)=>{if(void 0===e)return`"${t.name}" is missing (expected ${t.expected})`;let r=s(e);if(void 0===r||!n(r,t.types))return`"${t.name}" declares ${p(r)} (expected ${t.expected})`;if(t.itemTypes){let r=e.items;if(void 0===r||Array.isArray(r))return`"${t.name}" declares no single "items" schema (expected ${t.expected})`;let i=s(r);if(void 0===i||!n(i,t.itemTypes))return`"${t.name}" declares array items with ${p(i)} (expected ${t.expected})`}})(d.properties[e.name],e);return void 0===t?[]:[t]});return l.length>0?void m.error(t.CLERK_SESSION_DATA_INCOMPATIBLE,r.CLERK_SESSION_DATA_INCOMPATIBLE(l)):e(d)};

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

@@ -0,0 +1 @@
+export * from './shapes.js';

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

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

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

@@ -0,0 +1,24 @@
+import { Branded } from '@salsita-ai/common/utils';
+import { type EnhancedJsonSchemaType, type JsonSchema, type ParseContext, type PhoenixDefinitions } from '../../../../core/index.js';
+import type { MergedModelVersion } from '../../../merge/index.js';
+import type { CommonTypes } from '../common-types.js';
+import { EntityOrAliasName } from '../names/entity-or-alias-name.js';
+import { ShapePropertyName } from '../names/shape-property-name.js';
+/** A single shape definition with both enhanced properties (for type inference) and resolved runtime schema. */
+export type Shape = Branded<'Shape', {
+    readonly name: EntityOrAliasName;
+    readonly properties: Readonly<Record<ShapePropertyName, EnhancedJsonSchemaType>>;
+    readonly runtimeSchema: JsonSchema;
+}>;
+/** Map of entity/alias name → Shape with both enhanced and runtime schemas. */
+export type Shapes = Branded<'Shapes', ReadonlyMap<EntityOrAliasName, Shape>>;
+/**
+ * Validates and brands shape entries from the merged model version.
+ * Checks shape keys exist in entityTypes/aliases, validates $ref targets
+ * (must be commonTypes or phoenix definitions), and validates `references`
+ * targets exist in allNames.
+ *
+ * Each shape is resolved against the fully-resolved commonTypes + phx definitions,
+ * so each Shape has both enhanced properties and a runtime-ready schema.
+ */
+export declare const Shapes: (merged: MergedModelVersion, versionKey: string, phxDefinitions: PhoenixDefinitions, commonTypes: CommonTypes, ctx: ParseContext) => Shapes | undefined;

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

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{buildPhxDefSchemas as r,collectSchemaRefs as t,toRuntimeSchema as o}from"../../../../core/index.js";import{DiagnosticCode as s,diagnosticMessages as a}from"../../../../errors/index.js";import{validateSchemaRefs as i}from"../../common/index.js";import{AllNames as m}from"../all-names.js";import{EntityOrAliasName as n}from"../names/entity-or-alias-name.js";import{ShapePropertyName as p}from"../names/shape-property-name.js";export const Shapes=(f,l,c,h,j)=>{let E=f.shapes??{},N=m(f),d=new Set(Object.keys(f.commonTypes??{})),O=new Map;for(let[m,f]of Object.entries(E)){N.has(m)||j.error(s.UNKNOWN_SHAPE_KEY,a.UNKNOWN_SHAPE_KEY(m));let E=n(m,j.at(m));if(E){for(let[e,r]of Object.entries(f)){let o=j.at(m,e);if(!p(e,o))continue;let{refs:s,references:a}=t(r);for(let r of(i(s,l,d,c,o),a))N.has(r.value)||o.at(...r.path).error("UNKNOWN_REFERENCE_TARGET",`"${m}.${e}" references "${r.value}" which is not declared`)}if(!j.hasErrors){let t=new Map;for(let[e,r]of h)t.set(e,r.schema);for(let[e,o]of Object.entries(r(c)))t.set(e,o);let s={type:"object",properties:f,required:Object.keys(f),additionalProperties:!1};O.set(E,e({name:E,properties:f,runtimeSchema:o(s,t)}))}}}if(!j.hasErrors)return e(O)};

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

@@ -0,0 +1 @@
+export * from './relations.js';

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

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

package/dist/application-spec/parse-application-files/spec/relations/relation.d.ts

@@ -0,0 +1,45 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../core/index.js';
+import type { RawRelation } from '../../raw-spec/index.js';
+import type { ComponentEntry } from '../components/index.js';
+import type { Expression } from '../expressions/index.js';
+import type { Aliases, EntityOrAliasName, RelationName } from '../model/index.js';
+interface DirectRelation {
+    readonly name: RelationName;
+    readonly kind: 'direct';
+    readonly target: string;
+    readonly cardinality: '0-1' | '1-1' | '0-N' | '1-N';
+    readonly composedOf: boolean;
+    readonly field: string;
+}
+interface IndirectRelation {
+    readonly name: RelationName;
+    readonly kind: 'indirect';
+    readonly target: string;
+    readonly cardinality: '0-1' | '1-1' | '0-N' | '1-N';
+    readonly composedOf: boolean;
+    readonly field: string;
+}
+interface AllOfTypeRelation {
+    readonly name: RelationName;
+    readonly kind: 'allOfType';
+    readonly target: string;
+    readonly cardinality: '0-1' | '1-1' | '0-N' | '1-N';
+    readonly composedOf: boolean;
+}
+type RelationData = DirectRelation | IndirectRelation | AllOfTypeRelation;
+/**
+ * A single validated and expanded relation declaration.
+ * Carries the raw relation data AND its expanded artifacts (expression + components).
+ * Discriminated union on `kind` — direct and indirect carry `field`; allOfType does not.
+ */
+export type Relation = Branded<'Relation', RelationData & {
+    readonly expression: Expression;
+    readonly components: readonly ComponentEntry[];
+}>;
+/**
+ * Constructs a validated and expanded Relation from raw YAML data.
+ * Validates the name, then builds the expression + component artifacts in one step.
+ */
+export declare const Relation: (rawName: string, raw: RawRelation, typeOrAlias: EntityOrAliasName, aliases: Aliases, ctx: ParseContext) => Relation | undefined;
+export {};

package/dist/application-spec/parse-application-files/spec/relations/relation.js

@@ -0,0 +1 @@
+import{match as e}from"ts-pattern";import{Branded as t}from"@salsita-ai/common/utils";import{ComponentFilters as i,SdkComponentEntry as a}from"../components/index.js";import{ExpressionName as r,InstanceName as n}from"../model/index.js";export const Relation=(d,c,o,l,s)=>{let m,p=r(d,s);if(!p)return;let f=e(c).with({kind:"direct"},e=>({name:p,kind:"direct",target:e.target,cardinality:e.cardinality,composedOf:e.composedOf,field:e.field})).with({kind:"indirect"},e=>({name:p,kind:"indirect",target:e.target,cardinality:e.cardinality,composedOf:e.composedOf,field:e.field})).with({kind:"allOfType"},e=>({name:p,kind:"allOfType",target:e.target,cardinality:e.cardinality,composedOf:e.composedOf})).exhaustive(),y=t({entityKey:o,name:p,schema:m=((e,t)=>{let i=`$${e}`;switch(t){case"1-1":return{tsType:i};case"0-1":return{tsType:`${i} | null`};case"1-N":case"0-N":return{tsType:`readonly ${i}[]`}}})(f.target,f.cardinality),declaredSchema:m,implementation:{kind:"relation",params:[{kind:f.kind,target:f.target,cardinality:f.cardinality,..."field"in f?{field:f.field}:{}}]}}),g=((e,t,r,d)=>{let c=[],o=String(e.name),l=String(t),s="0-N"===e.cardinality||"1-N"===e.cardinality?"multiple":"single",m={aliases:r},p=i(void 0);if("direct"===e.kind){let i=n(`${l}.${o}`,l,"reference",d);c.push(a({typeOrAlias:t,instanceName:i,componentName:"reference",implementation:{kind:"sdk",filters:p,readFactory:{sdkFunction:"single"===s?"createSingleReferenceRead":"createMultipleReferenceRead",params:[{$codeRef:e.target},e.field]},writeFactory:{sdkFunction:"single"===s?"createSingleReferenceWrite":"createMultipleReferenceWrite",params:[{$codeRef:e.target},e.field]}}},m))}if(e.composedOf){let e=n(o,l,"composedOf",d);c.push(a({typeOrAlias:t,instanceName:e,componentName:"composedOf",implementation:{kind:"sdk",filters:p,readFactory:{sdkFunction:"single"===s?"createSingleCompositionRead":"createMultipleCompositionRead",params:[o]},writeFactory:{sdkFunction:"createEmptyWrite",params:[]}}},m))}return c})(f,o,l,s);return t({...f,expression:y,components:g})};

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

@@ -0,0 +1,25 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../core/index.js';
+import type { MergedRelations } from '../../merge/index.js';
+import type { ComponentEntry } from '../components/index.js';
+import type { Expression } from '../expressions/index.js';
+import type { EntityOrAliasName, ModelVersion } from '../model/index.js';
+import { RelationName } from '../model/index.js';
+import { Relation } from './relation.js';
+/**
+ * Validated and expanded relations. Each `Relation` carries its own expression + components.
+ * The aggregate `components` and `expressions` fields are collected from all entries.
+ */
+export type Relations = Branded<'Relations', {
+    readonly entries: Readonly<Record<EntityOrAliasName, Readonly<Record<RelationName, Relation>>>>;
+    readonly components: readonly ComponentEntry[];
+    readonly expressions: readonly Expression[];
+}>;
+/**
+ * Validates merged relations against the latest model, then expands into components + expressions.
+ *
+ * Each relation is individually constructed via `Relation()` which builds its own expression
+ * and component entries. This factory validates cross-relation concerns (counterpart pairing,
+ * composition tree reachability) and aggregates the per-relation artifacts.
+ */
+export declare const Relations: (rawRelations: MergedRelations, latestModel: ModelVersion, ctx: ParseContext) => Relations;

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

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{DiagnosticCode as t,diagnosticMessages as r}from"../../../errors/index.js";import{IMPLICIT_ENTITY_FIELDS as i,RelationName as o,getResolvedShape as n}from"../model/index.js";import{Relation as f}from"./relation.js";let l=(e,t,r)=>{let i=r[t.target];if(!i)return;let o="direct"===t.kind?"indirect":"indirect"===t.kind?"direct":"allOfType";for(let[r,n]of Object.entries(i))if(n.kind===o&&n.target===e&&("allOfType"===t.kind||"allOfType"===n.kind||t.field===n.field))return{entityKey:t.target,name:r,relation:n}},T=(e,t)=>{let r=t.aliases.get(e);return r||[e]};export const Relations=(O,N,E)=>{let{allNames:I,resolvedShapes:_}=N,a=[...I].map(String),s=(e,t)=>n(_,e).fieldSchemas.has(t),d={};for(let[e,n]of Object.entries(O)){let l=E.at(e);if(!I.has(e)){l.error(t.RELATION_UNKNOWN_ENTITY_KEY,r.RELATION_UNKNOWN_ENTITY_KEY(e,a));continue}for(let[T,O]of Object.entries(n)){if(!o(T,l))continue;if(!I.has(O.target)){l.error(t.RELATION_UNKNOWN_TARGET,r.RELATION_UNKNOWN_TARGET(e,T,O.target,a));continue}if("direct"===O.kind){if(i.has(O.field)){l.error(t.RELATION_IMMUTABLE_FIELD,r.RELATION_IMMUTABLE_FIELD(e,T,O.field,e));continue}if(!s(e,O.field)){l.error(t.RELATION_UNKNOWN_FIELD_DIRECT,r.RELATION_UNKNOWN_FIELD_DIRECT(e,T,O.field));continue}}else if("indirect"===O.kind){if(i.has(O.field)){l.error(t.RELATION_IMMUTABLE_FIELD,r.RELATION_IMMUTABLE_FIELD(e,T,O.field,O.target));continue}if(!s(O.target,O.field)){l.error(t.RELATION_UNKNOWN_FIELD_INDIRECT,r.RELATION_UNKNOWN_FIELD_INDIRECT(e,T,O.field,O.target));continue}}let n=f(T,O,e,N.aliases,l);n&&(d[e]||(d[e]={}),d[e][n.name]=n)}}for(let[e,i]of Object.entries(d)){let o=E.at(e);for(let[n,f]of Object.entries(i)){if(f.target===e)continue;let i=l(e,f,d);if(!i){o.error(t.RELATION_MISSING_COUNTERPART,r.RELATION_MISSING_COUNTERPART(e,n,f.kind,f.target,"allOfType"===f.kind?void 0:f.field,f.composedOf));continue}f.composedOf&&i.relation.composedOf&&o.error(t.RELATION_COUNTERPART_COMPOSED_OF_MISMATCH,r.RELATION_COUNTERPART_COMPOSED_OF_MISMATCH(e,n,i.entityKey,i.name))}}((e,i,o)=>{let n=new Map;for(let[t,r]of Object.entries(e))for(let e of Object.values(r)){if(!e.composedOf)continue;let r=T(t,i),o=T(e.target,i);for(let e of r){let t=n.get(e);for(let r of(t||(t=new Set,n.set(e,t)),o))t.add(r)}}let f=new Set(i.rootEntityTypes),l=[...i.rootEntityTypes];for(;l.length>0;){let e=l.shift(),t=n.get(e);if(t)for(let e of t)f.has(e)||(f.add(e),l.push(e))}let O=i.rootEntityTypes.map(String);for(let e of i.entityTypes)f.has(e)||o.at(String(e)).error(t.RELATION_ENTITY_NOT_IN_COMPOSITION_TREE,r.RELATION_ENTITY_NOT_IN_COMPOSITION_TREE(String(e),O))})(d,N,E);let{components:R,expressions:c}=(e=>{let t=[],r=[];for(let i of Object.values(e))for(let e of Object.values(i))t.push(...e.components),r.push(e.expression);return{components:t,expressions:r}})(d);return e({entries:d,components:R,expressions:c})};

package/dist/application-spec/parse-application-files/spec/sections/app-metadata.d.ts

@@ -0,0 +1,21 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../core/index.js';
+import type { MergedAppMetadata } from '../../merge/index.js';
+import { ApplicationVersion } from './application-version.js';
+/**
+ * Validated application metadata — version, auth, infrastructure settings.
+ * Used by codegen for ApplicationVersion export and builder chain methods.
+ */
+export type AppMetadata = Branded<'AppMetadata', {
+    readonly applicationVersion: ApplicationVersion;
+    readonly workspace: boolean;
+    readonly webComponentTag: string | undefined;
+    readonly pageTitle: string | undefined;
+    readonly useAuthHook: boolean;
+    readonly useClerk: boolean;
+    readonly enableAdminRelease: boolean;
+    readonly jsonSchemaValidator: 'ajv' | 'csp-compatible';
+    readonly gltfDecoder: 'js' | 'wasm';
+    readonly collectFinalizeData: boolean;
+}>;
+export declare const AppMetadata: (merged: MergedAppMetadata, ctx: ParseContext) => AppMetadata | undefined;

package/dist/application-spec/parse-application-files/spec/sections/app-metadata.js

@@ -0,0 +1 @@
+import{Branded as e}from"@salsita-ai/common/utils";import{ApplicationVersion as a}from"./application-version.js";export const AppMetadata=(o,t)=>{let l=a(o.applicationVersion,t);if(l)return e({applicationVersion:l,workspace:o.workspace,webComponentTag:o.webComponentTag,pageTitle:o.pageTitle,useAuthHook:o.useAuthHook,useClerk:o.useClerk,enableAdminRelease:o.enableAdminRelease,jsonSchemaValidator:o.jsonSchemaValidator,gltfDecoder:o.gltfDecoder,collectFinalizeData:o.collectFinalizeData})};

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

@@ -0,0 +1,9 @@
+import { Branded } from '@salsita-ai/common/utils';
+import type { ParseContext } from '../../../core/index.js';
+/**
+ * Branded semantic version (x.y.z) of the application.
+ * Exported by codegen as the `ApplicationVersion` constant and stored as
+ * `applicationVersion` on the deployment record.
+ */
+export type ApplicationVersion = Branded<'ApplicationVersion', string>;
+export declare const ApplicationVersion: (version: string, ctx: ParseContext) => ApplicationVersion | undefined;

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

@@ -0,0 +1 @@
+import{Branded as o}from"@salsita-ai/common/utils";import{DiagnosticCode as r,diagnosticMessages as i}from"../../../errors/index.js";let t=/^\d+\.\d+\.\d+$/;export const ApplicationVersion=(I,s)=>t.test(I)?o(I):void s.error(r.INVALID_APPLICATION_VERSION,i.INVALID_APPLICATION_VERSION(I));

package/dist/application-spec/parse-application-files/spec/sections/assistant/assistant-field-type.d.ts

@@ -0,0 +1,44 @@
+import { type GraphQLOutputType, GraphQLScalarType } from 'graphql';
+import { type EnhancedJsonSchemaType, type PhoenixDefinitions } from '../../../../core/index.js';
+import type { CommonTypes } from '../../model/index.js';
+/**
+ * Opaque scalar for values the assistant schema does not type: objects, custom TypeScript types and
+ * loose unions. A value is plain serializable data and passes through unchanged.
+ */
+export declare const GraphQLJSON: GraphQLScalarType<unknown, unknown>;
+/**
+ * Resolves a `$ref` to the schema it names: nullability is read through phoenix definitions and
+ * common types, and a common type also gives the field its type and default description.
+ * `undefined` for a ref that names nothing known.
+ */
+export type AssistantRefResolver = ($ref: string) => EnhancedJsonSchemaType | undefined;
+/**
+ * The GraphQL type of one whitelisted stored field or declared expression. `enumValues` lists the
+ * allowed values of a string enum, which the schema exposes as `String` and names in the field
+ * description.
+ */
+export interface AssistantFieldType {
+    readonly type: GraphQLOutputType;
+    readonly enumValues?: readonly string[];
+    /**
+     * The schema's own description, or without one that of the common type it references, directly or
+     * as the only non-null member of a union.
+     */
+    readonly description?: string;
+    /** The value is localizable, or a list of localizable values, and the schema exposes it as `String`. */
+    readonly localized?: true;
+}
+/**
+ * Resolves refs to phoenix definitions (full URL, `phx:`, or `#/definitions/` as used inside the
+ * definitions themselves) and to common types (`common:` or internal path).
+ */
+export declare const createAssistantRefResolver: (commonTypes: CommonTypes, phxDefinitions: PhoenixDefinitions) => AssistantRefResolver;
+/**
+ * Maps the JSON Schema of a whitelisted stored field or declared expression to its GraphQL type,
+ * following the resolution order of `schemaToTypeString`: refs to localizable phoenix definitions →
+ * localized `String`, `tsType` → `JSON`, `DomainEntityId` → `ID`, a ref to a common type → whatever
+ * the common type's schema maps to, every other `$ref` → `JSON`, string enums and unions of them →
+ * `String` with their values, primitives → scalars, arrays of mappable items → lists, and everything
+ * else → `JSON`. Every type, `JSON` included, is non-null unless the schema admits `null`.
+ */
+export declare const assistantFieldType: (schema: EnhancedJsonSchemaType, resolveRef: AssistantRefResolver) => AssistantFieldType;

package/dist/application-spec/parse-application-files/spec/sections/assistant/assistant-field-type.js

@@ -0,0 +1 @@
+import{GraphQLBoolean as e,GraphQLFloat as t,GraphQLID as r,GraphQLInt as n,GraphQLList as i,GraphQLNonNull as l,GraphQLScalarType as a,GraphQLString as o,getNamedType as s}from"graphql";import{isArray as f}from"@salsita-ai/common/utils";import{COMMON_SHORT_PREFIX as u,DEFINITION_REF_PATTERN as p,INTERNAL_REF_PATTERN as d,extractPhxDefName as y}from"../../../../core/index.js";export const GraphQLJSON=new a({name:"JSON",description:"Any JSON value, returned as stored. Always plain serializable data."});let c={number:t,integer:n,string:o,boolean:e},m=new Set(["Localizable","EnhancedLocalizable","MessageDescriptor","EnhancedMessageDescriptor","MultilingualString"]),v={type:GraphQLJSON},h=e=>e.startsWith(u)?e.slice(u.length):d.exec(e)?.[2],g=e=>y(e)??p.exec(e)?.[1];export const createAssistantRefResolver=(e,t)=>r=>{let n=g(r);if(void 0!==n)return t[n]?.schema;let i=h(r);return void 0===i?void 0:e.get(i)?.schema};let S=(e,t,r=new Set)=>{if(e.$ref){if(r.has(e.$ref))return!1;let n=t(e.$ref);return void 0===n||S(n,t,new Set([...r,e.$ref]))}let n=[...e.anyOf??[],...e.oneOf??[]];return"null"===e.type||f(e.type)&&e.type.includes("null")||e.enum?.includes(null)===!0||null===e.const||n.some(e=>S(e,t,r))},O=({anyOf:e,oneOf:t})=>[...e??[],...t??[]].filter(e=>"null"!==e.type),w=(e,t,n)=>{let l;if(void 0!==(l=void 0===e.$ref?void 0:g(e.$ref))&&m.has(l))return{type:o,localized:!0};if(e.tsType)return v;if(e.$ref){var a=e.$ref;if("DomainEntityId"===y(a))return{type:r};let i=h(a),l=void 0===i||n.has(i)?void 0:t(a);return void 0!==i&&l?w(l,t,new Set([...n,i])):v}if(e.anyOf||e.oneOf)return((e,t,r)=>{let n=O(e).map(e=>w(e,t,r)),[i]=n;if(1===n.length&&i)return i;let l=n.flatMap(({type:e,enumValues:t})=>e===o&&t?[t]:[]);if(n.length<2||l.length!==n.length||e.anyOf&&e.oneOf)return v;let a=l.flatMap(e=>[...new Set(e)]);return{type:o,enumValues:e.oneOf?a.filter(e=>a.indexOf(e)===a.lastIndexOf(e)):[...new Set(a)]}})(e,t,n);if(e.enum){let t;return(t=e.enum.filter(e=>null!==e)).every(e=>"string"==typeof e)?{type:o,enumValues:t}:v}if(f(e.type)){let r=e.type.filter(e=>"null"!==e),[i]=r;return 1===r.length&&i?w({...e,type:i},t,n):v}if("array"===e.type){var u=e.items;if(!u||f(u))return v;let r=$(u,t,n);return s(r.type)===GraphQLJSON?v:{type:new i(r.type),enumValues:r.enumValues,localized:r.localized}}let p="string"==typeof e.type?c[e.type]:void 0;return p?{type:p}:v},$=(e,t,r)=>{let n=w(e,t,r);return{...n,type:S(e,t)?n.type:new l(n.type)}},x=(e,t,r)=>{let n=h(e),i=void 0===n||r.has(n)?void 0:t(e);if(void 0!==n&&i)return void 0===i.description&&i.$ref?x(i.$ref,t,new Set([...r,n])):i.description};export const assistantFieldType=(e,t)=>{let r=O(e),n=e.$ref??(1===r.length?r[0]?.$ref:void 0),i=void 0===e.description&&n?x(n,t,new Set):e.description;return{...$(e,t,new Set),...void 0===i?{}:{description:i}}};

package/dist/application-spec/parse-application-files/spec/sections/assistant/assistant-schema.d.ts

@@ -0,0 +1,70 @@
+import type { AssistantFieldOptions, AssistantFieldSource, AssistantRecipeGroup } from '#package/domain';
+import type { ParseContext, PhoenixDefinitions } from '../../../../core/index.js';
+import { type RawAssistant } from '../../../raw-spec/index.js';
+import type { Components } from '../../components/index.js';
+import type { Expressions } from '../../expressions/index.js';
+import type { EntityTypeName, ModelVersion } from '../../model/index.js';
+/**
+ * The field sources of every entity object type: GraphQL object type name → GraphQL field name →
+ * its {@link AssistantFieldSource}. Only entity object types appear, since values always resolve on
+ * a concrete type; `id` and `type` are implicit and never listed.
+ */
+export type AssistantFieldSources = Readonly<Record<string, Readonly<Record<string, AssistantFieldSource>>>>;
+/**
+ * The stored property each delta field of a `modify<Type>` mutation writes: entity type → delta
+ * field name → shape property. Only entity types with at least one writable field appear, aliases
+ * expanded to their members.
+ */
+export type AssistantWritableFields = Readonly<Record<string, Readonly<Record<string, string>>>>;
+/**
+ * The recipe groups of one kind per entity type, in manifest
+ * order. Only entity types with at least one group appear, aliases expanded to their members.
+ */
+export type AssistantRecipeGroups = Readonly<Record<string, readonly AssistantRecipeGroup[]>>;
+/**
+ * The options edges `meta` exposes per entity type, which are also the choices `modify<Type>` checks
+ * a written value against, in manifest order. Only entity types with at least one edge appear,
+ * aliases expanded to their members.
+ */
+export type AssistantFieldOptionsByType = Readonly<Record<string, readonly AssistantFieldOptions[]>>;
+/**
+ * The printed assistant GraphQL schema, the field sources its runtime resolvers read through, the
+ * entity types `deleteEntity` may delete, the fields the `modify<Type>` mutations may write, the
+ * recipe groups `addChild` may add from, the ones `replaceEntity` may replace by and the options edges
+ * of writable fields, aliases expanded,
+ * so the runtime checks the same sets the schema describes.
+ */
+export interface AssistantSchema {
+    readonly sdl: string;
+    readonly fields: AssistantFieldSources;
+    readonly deletableTypes: readonly EntityTypeName[];
+    readonly writableFields: AssistantWritableFields;
+    readonly childRecipes: AssistantRecipeGroups;
+    readonly replaceRecipes: AssistantRecipeGroups;
+    readonly fieldOptions: AssistantFieldOptionsByType;
+}
+/** What the assistant schema is built from, besides the manifest. */
+export interface AssistantSchemaInput {
+    readonly model: ModelVersion;
+    readonly states: AssistantStates;
+    /** Resolves `phx:` refs, so a field's nullability is read through phoenix definitions. */
+    readonly phxDefinitions: PhoenixDefinitions;
+    /** The parsed expressions, which `$` manifest entries whitelist by their declared schema. */
+    readonly expressions: Expressions;
+    /** The parsed components, whose instances recipe group entries and the `options` of writable fields name. */
+    readonly components: Components;
+}
+/** The declared UI state values: each non-empty kind becomes a `Navigation` field listing its values. */
+export interface AssistantStates {
+    readonly navigationStates: readonly string[];
+    readonly viewStates: readonly string[];
+    readonly toolStates: readonly string[];
+}
+/**
+ * Builds the assistant GraphQL schema from the manifest whitelist, the latest model and the
+ * configurator states: aliases become interfaces implementing `AnyDomainEntity`, entity types become
+ * object types implementing every alias that contains them, and `Query` exposes the root, entities,
+ * selection and navigation entry points. Returns `undefined` after reporting diagnostics when the
+ * manifest does not fit the model or the generated schema is not valid GraphQL.
+ */
+export declare const createAssistantSchema: (manifest: RawAssistant, { model, states, phxDefinitions, expressions, components }: AssistantSchemaInput, ctx: ParseContext) => AssistantSchema | undefined;