@salsita-ai/sdk 0.50.0-develop.5a0bcdee42 → 0.50.0-develop.5ac9723d62

package/dist/domain/application/GetThemeHandler.d.ts

@@ -1,5 +1,5 @@
 import type { ThemeOptions } from '@mui/material';
-import type { HandlerRegistration, SystemPhoenixHandlerRegistration } from './handler-registration.js';
+import type { HandlerRegistration, SystemPhoenixHandlerRegistration } from '../spec/index.js';
 export declare const GetThemeHandlerName = "GetThemeHandler";
 export declare const createGetThemeHandler: (fn: () => ThemeOptions) => SystemPhoenixHandlerRegistration<void, ThemeOptions>;
 export type CreateGetThemeHandler = (fn: () => ThemeOptions) => SystemPhoenixHandlerRegistration<void, ThemeOptions>;

package/dist/domain/application/GetWebComponentOptions.d.ts

@@ -1,5 +1,5 @@
+import type { HandlerRegistration, SystemPhoenixHandlerRegistration } from '../spec/index.js';
 import type { WebComponentOptions } from './application-config.js';
-import type { HandlerRegistration, SystemPhoenixHandlerRegistration } from './handler-registration.js';
 export declare const createGetWebComponentOptionsHandler: (fn: () => WebComponentOptions) => SystemPhoenixHandlerRegistration<undefined, WebComponentOptions>;
 export type CreateGetWebComponentOptionsHandler = (fn: () => WebComponentOptions) => SystemPhoenixHandlerRegistration<undefined, WebComponentOptions>;
 export declare const isGetWebComponentOptionsHandler: (handler: HandlerRegistration<any, any>) => handler is SystemPhoenixHandlerRegistration<undefined, WebComponentOptions>;

package/dist/domain/application/admin-page-factories.d.ts

@@ -1,7 +1,6 @@
-import type { DomainEntityId } from '../core/model.js';
+import type { DataCellValue, DataSchema, DomainEntityId } from '../core/index.js';
 import type { AttributeSelectionComponentState } from '../system-components/attribute-selection.js';
 import type { NavigationListItem, NestedNavigationListItem } from '../system-components/navigation-panel-list.js';
-import type { DataCellValue, DataSchema } from './application-config.js';
 interface PresetPagesConfig {
     readonly categoryNavigationState: string;
     readonly presetNavigationState: string;

package/dist/domain/application/application-config.d.ts

@@ -6,42 +6,32 @@ import type { Logger } from '@salsita-ai/common/utils';
 import type { SessionRole, SessionTokenPayload } from '@salsita-ai/contracts/api';
 import type { CellValue } from '@salsita-ai/contracts/webhook';
 import type { AdminIntegrationService } from '#package/react-sdk';
-import type { DomainComponentOptic } from '../components/domain-component-optic.js';
-import type { $DomainEntity, DomainEntity, DomainFactory, ProductPreset, SystemComponentTypeConstraint } from '../core/index.js';
-import type { AnalyticsSystem, DomainContextSystems, TransformerFactory, Transformers } from '../domain-context/index.js';
-import type { RegistrableTransformer } from '../domain-context/transformers/index.js';
-import type { ElementRegistration } from './element-registration.js';
-import type { HandlerRegistration } from './handler-registration.js';
+import type { $DomainEntity, DataCellValue, DataSchema, DomainEntity, DomainFactory, ProductPreset } from '../core/index.js';
+import type { AnalyticsSystem, RegistrableTransformer, TransformerFactory } from '../domain-context/index.js';
+import type { AdminPagesSection, AssistantResolvedManifest, ElementRegistration, ProjectModule } from '../spec/index.js';
 import type { WebComponentEventDescriptor } from './web-component-event.js';
 import type { WebComponentPropertyDescriptor } from './web-component-property.js';
-export type ImportedTransformer<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, NAVIGATION_STATES extends string, VIEW_STATES extends string, TOOL_STATES extends string, EXPORT_STATES extends string> = {
+type TransformerExport = ReturnType<TransformerFactory<any, any, any, any, any, any, any>> | RegistrableTransformer<any, any, any, any, any, any, any>;
+/** The transformers one `src/transformers/` file exports, under the name of the file. */
+export type ImportedTransformer = {
     name: string;
-    transformer: ReturnType<TransformerFactory<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>> | RegistrableTransformer<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES> | ReadonlyArray<ReturnType<TransformerFactory<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>> | RegistrableTransformer<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>>;
+    transformer: TransformerExport | ReadonlyArray<TransformerExport>;
 };
 export type SpecTransformer = {
     name: string;
     priority?: number;
 };
-export interface DataSchemaPrimitiveField {
-    readonly type: 'string' | 'number' | 'integer' | 'boolean';
-    readonly enum?: ReadonlyArray<string | number>;
-    readonly description?: string;
-}
-export interface DataSchemaLocalizedField {
-    readonly type: 'localized';
-    readonly description?: string;
-}
-export interface DataSchemaArrayField {
-    readonly type: 'array';
-    readonly items: 'string' | 'number' | 'boolean';
-    readonly description?: string;
+/**
+ * The transformers of an application: the `src/transformers/` files as project modules, and the spec's
+ * `transformers` section, which selects them by name and orders them by priority. A plain-function
+ * export is selected by its file name; a transformer made with `build(name)` by that name, which the spec
+ * parser requires to match the file name with case and dashes ignored. The runtime spec resolves the two
+ * into the factory the store system calls on every update.
+ */
+export interface TransformersConfig {
+    readonly importedTransformers: readonly ProjectModule[];
+    readonly specTransformers: readonly SpecTransformer[];
 }
-export type DataSchemaFieldObject = DataSchemaPrimitiveField | DataSchemaLocalizedField | DataSchemaArrayField;
-export type DataSchemaField = 'string' | 'number' | 'boolean' | readonly ['string', 'null'] | readonly ['number', 'null'] | readonly ['boolean', 'null'] | DataSchemaFieldObject;
-export type DataSchema = Record<string, DataSchemaField>;
-export type DataCellValue = CellValue | null | {
-    readonly $lang: Record<string, string>;
-} | readonly CellValue[];
 export type DataSpecEntry = {
     readonly definition: DataSchema;
     readonly chunk?: string;
@@ -65,90 +55,10 @@ export type ChunksSpec = Readonly<Record<string, {
     readonly scope: string;
 }>>;
 /**
- * Where one exposed assistant GraphQL field reads its value on the `$` entity: a stored field name,
- * or an expression name including its `$`. `localized` marks a localizable value that resolves to a
- * string in the current locale.
+ * The admin pages of an application config: the `$adminPages` section of the application spec as
+ * written, which `createAdminPagesFromSpec` turns into admin pages; see {@link AdminPagesSection}.
  */
-export interface AssistantFieldSource {
-    readonly source: string;
-    readonly localized?: true;
-}
-/**
- * One recipe group the assistant manifest exposes on an entity type: a `childEntityRecipes` instance
- * under `childRecipes`, a `replaceEntityRecipes` instance under `replaceRecipes`. `groupId` is the
- * name the agent addresses the group by, `instanceName` the component instance it reads,
- * `description` the manifest's text replacing the component's group description, and `dryRuns`
- * whether the recipes of the group can be dry-run.
- */
-export interface AssistantRecipeGroup {
-    readonly groupId: string;
-    readonly instanceName: string;
-    readonly description?: string;
-    readonly dryRuns: boolean;
-}
-/**
- * The options edge of one writable field the assistant manifest links to its component. `field` is
- * the delta field of `modify<Type>` the choices are for, `edgeName` the field of `<Type>Meta` that
- * lists them, `componentType` and `instanceName` the component instance they are read from, and
- * `validate` whether `modify<Type>` rejects a value that is not among them, and `dryRuns` whether
- * the choices can be dry-run.
- */
-export interface AssistantFieldOptions {
-    readonly field: string;
-    readonly edgeName: string;
-    readonly componentType: 'materialSwatch' | 'attributeSelection' | 'distanceDimensionSelect';
-    readonly instanceName: string;
-    readonly validate: boolean;
-    readonly dryRuns: boolean;
-}
-/**
- * Experimental assistant manifest generated from the application spec `assistant` section. `sdl` is
- * the GraphQL schema text prepared at parse time; `fields` maps each GraphQL object type's exposed
- * fields (type name → GraphQL field name) to the stored field or expression its resolvers read;
- * `deletableTypes` lists the entity types the `deleteEntity` mutation may delete, with aliases
- * already expanded, and absent means none; `writableFields` maps, per entity type with a
- * `modify<Type>` mutation, each field of its delta input to the stored property it writes, and
- * absent means no entity type is writable; `childRecipes` lists, per entity type with a `meta` field,
- * the recipe groups `meta { childRecipes }` and `addChild` expose, in manifest order, and absent
- * means none; `replaceRecipes` lists the same for `meta { replaceRecipes }` and `replaceEntity`;
- * `fieldOptions` lists, per entity type, the options edges `meta` exposes for its
- * writable fields, and absent means none; `actions` maps each custom `Mutation` field to the
- * declared action it runs, and absent means none. Consumed by the configurator GraphQL system.
- */
-export interface AssistantManifest {
-    readonly sdl: string;
-    readonly fields: Readonly<Record<string, Readonly<Record<string, AssistantFieldSource>>>>;
-    readonly deletableTypes?: readonly string[];
-    readonly writableFields?: Readonly<Record<string, Readonly<Record<string, string>>>>;
-    readonly childRecipes?: Readonly<Record<string, readonly AssistantRecipeGroup[]>>;
-    readonly replaceRecipes?: Readonly<Record<string, readonly AssistantRecipeGroup[]>>;
-    readonly fieldOptions?: Readonly<Record<string, readonly AssistantFieldOptions[]>>;
-    readonly actions?: Readonly<Record<string, string>>;
-}
-export type AdminPagesSpec = {
-    readonly presets?: boolean | {
-        readonly categoryNavigationState?: string;
-        readonly presetNavigationState?: string;
-    };
-    readonly recipes?: ReadonlyArray<{
-        readonly name: string;
-        readonly navigationState?: string;
-    }>;
-    readonly pages?: ReadonlyArray<{
-        readonly key: string;
-        readonly title: string;
-        readonly icon?: string;
-        readonly navigationState?: string;
-        readonly entity?: string;
-        readonly component?: string;
-        readonly actionsComponent?: string;
-        readonly connectedDataEntry?: string;
-        readonly sidebar?: {
-            readonly title: string;
-            readonly component: string;
-        };
-    }>;
-};
+export type AdminPagesSpec = AdminPagesSection;
 type PersistenceConfig = {
     readonly type: 'server';
     /**
@@ -171,9 +81,11 @@ export interface DomainConfig<ENTITIES extends DomainEntity<string>, ALLOWED_ROO
      */
     readonly domainFactory: DomainFactory<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>;
     /**
-     * Components attached to the domain used for the Application to work.
+     * Components attached to the domain used for the Application to work, as project modules: the
+     * `src/components/` files and the optics a generated file lists. The runtime spec validates and
+     * flattens them.
      */
-    readonly componentOptics: ReadonlyArray<DomainComponentOptic<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, SystemComponentTypeConstraint>>;
+    readonly componentOptics: readonly ProjectModule[];
     /**
      * List of languages that the user will be able to provide in multi-lingual text fields in the Admin UI
      */
@@ -352,15 +264,16 @@ export interface ApplicationConfig<ENTITIES extends DomainEntity<string>, ALLOWE
     readonly chunks?: ChunksSpec;
     readonly dataSpec?: DataSpec;
     readonly publishedDataHash?: string;
-    readonly assistant?: AssistantManifest | null;
-    /**
-     * Factory for transformers that will be registered in the store system and called on any update.
-     */
-    readonly createTransformers?: (ctx: DomainContextSystems<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>) => Transformers<ENTITIES>;
+    readonly assistant?: AssistantResolvedManifest | null;
+    /** The project's transformers; the runtime spec validates the files and builds the store's transformer factory from them. */
+    readonly transformers?: TransformersConfig;
     readonly adminNavigation?: AdminNavigationConfig<ADMIN_NAVIGATION_STATES, ADMIN_VIEW_STATES> | undefined;
     readonly adminDomain: DomainConfig<ADMIN_ENTITIES, ADMIN_ALLOWED_ROOT_ENTITIES, ADMIN_$MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>;
-    readonly handlers: ReadonlyArray<HandlerRegistration<any, any>>;
-    readonly elements: readonly ElementRegistration[];
+    /** The `src/handlers/` and `src/elements/` files as project modules; the runtime spec validates and flattens both. */
+    readonly handlers: readonly ProjectModule[];
+    readonly elements: readonly ProjectModule[];
+    /** The SDK's default element registrations; a project element with the same name replaces one. */
+    readonly defaultElements?: readonly ElementRegistration[];
     readonly mount: MountConfig<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES, CHAT_CONTEXT, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ADMIN_ENTITIES, ADMIN_ALLOWED_ROOT_ENTITIES, ADMIN_$MAP, ADMIN_NAVIGATION_STATES, ADMIN_VIEW_STATES>;
 }
 export {};

package/dist/domain/application/assistant/assistant-fields.d.ts

@@ -0,0 +1,12 @@
+import type { AssistantDeclaredField, AssistantResolvedField } from '../../spec/index.js';
+/** Combines the effective description with allowed string values. */
+export declare const describeAssistantValues: (description: string | undefined, values: readonly string[] | undefined) => string | undefined;
+/** Applies GraphQL field inheritance identically at parse time and after session narrowing. */
+export declare const mergeAssistantFields: (inherited: ReadonlyArray<readonly AssistantDeclaredField[]>, own: readonly AssistantDeclaredField[], ownEnumValues: (source: string) => readonly string[] | undefined, conflict: (name: string, first: string, second: string) => void) => readonly AssistantDeclaredField[];
+/**
+ * The serializable form of a merged field of one alias or type. Merging keeps the inherited entry of
+ * a field declared twice, so the lens tags are taken from `own`, the declarations of that alias or
+ * type itself: each lens condition then comes from its own declaration, at parse time and after
+ * session narrowing alike.
+ */
+export declare const resolveAssistantField: (field: AssistantDeclaredField, own: readonly AssistantDeclaredField[]) => AssistantResolvedField;

package/dist/domain/application/assistant/assistant-fields.js

@@ -0,0 +1 @@
+export const describeAssistantValues=(e,s)=>{if(!s?.length)return e;let t=`One of: ${s.map(e=>`"${e}"`).join(", ")}.`;return e?`${e}${/[.!?]$/.test(e)?"":"."} ${t}`:t};export const mergeAssistantFields=(e,s,t,n)=>{let r=new Map,i=new Set(s);for(let t of[...e.flat(),...s]){let e=r.get(t.name);e?e.source!==t.source?n(t.name,e.source,t.source):r.set(t.name,{...e,...i.has(t)&&t.describedByManifest?{description:t.description,describedByManifest:!0,valueDescription:t.valueDescription}:{}}):r.set(t.name,t)}return[...r.values()].map(e=>{let s=e.enumValues&&t(e.source);return s?{...e,enumValues:s,description:describeAssistantValues(e.valueDescription,s)}:e})};export const resolveAssistantField=(e,s)=>{let t=s.find(s=>s.name===e.name&&s.source===e.source)?.lenses;return{name:e.name,source:e.source,localized:e.localized,type:e.type,...void 0===e.description?{}:{description:e.description},...t?.length?{lenses:t}:{}}};

package/dist/domain/application/assistant/assistant-value-type.d.ts

@@ -0,0 +1,9 @@
+import { type GraphQLInputType, type GraphQLOutputType, GraphQLScalarType } from 'graphql';
+import type { AssistantValueType } from '../../spec/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>;
+/** Recreates a GraphQL value type from the JSON descriptor, preserving every list and nullability layer. */
+export declare const createAssistantValueType: (descriptor: AssistantValueType) => GraphQLInputType & GraphQLOutputType;

package/dist/domain/application/assistant/assistant-value-type.js

@@ -0,0 +1 @@
+import{GraphQLBoolean as e,GraphQLFloat as n,GraphQLID as t,GraphQLInt as a,GraphQLList as r,GraphQLNonNull as l,GraphQLScalarType as i,GraphQLString as s}from"graphql";export const GraphQLJSON=new i({name:"JSON",description:"Any JSON value, returned unchanged as plain serializable data."});let o={Int:a,Float:n,String:s,Boolean:e,ID:t,JSON:GraphQLJSON};export const createAssistantValueType=e=>{let n="list"===e.kind?new r(createAssistantValueType(e.item)):o[e.name];return e.nonNull?new l(n):n};

package/dist/domain/application/assistant/build-assistant-lenses.d.ts

@@ -0,0 +1,13 @@
+import { type GraphQLSchema } from 'graphql';
+import type { AssistantManifest, AssistantResolvedManifest } from '../../spec/index.js';
+/**
+ * Generates the lens fragments of a resolved manifest for the execution schema compiled from it. A
+ * declared lens becomes one fragment on `AnyDomainEntity`; one that session narrowing left without a
+ * tagged field is dropped, so the agent is never offered a lens that selects nothing. A built-in lens
+ * is present only when the schema has its type. A tagged relation spreads the lens itself in the
+ * declarations, which GraphQL forbids, so the definitions unroll it into copies down to `maxDepth`,
+ * where relations select only `id`. The definitions are checked here against the execution schema,
+ * with every declared lens spread on one entity, so a fault in them fails the build and not the
+ * operations that spread them.
+ */
+export declare const buildAssistantLenses: (resolved: AssistantResolvedManifest, schema: GraphQLSchema) => NonNullable<AssistantManifest['lenses']>;

package/dist/domain/application/assistant/build-assistant-lenses.js

@@ -0,0 +1,5 @@
+import{NoUnusedFragmentsRule as e,parse as t,specifiedRules as i,validate as n}from"graphql";let s="AnyDomainEntity",r=[{name:"RecipeGroup",description:"A recipe group with its recipes, without their dry-runs.",selections:["groupId","name","description","recipes { ...Recipe }"]},{name:"Recipe",description:"A recipe without its dry-run.",selections:["key","name","description","imageUrl"]},{name:"FieldOption",description:"A value a field accepts, without its dry-run.",selections:["value","name","description","imageUrl","color"]},{name:"DryRun",description:"What a dry-run would do, with the ids of the entities it would change instead of the entities.",selections:["ok","deletedEntityIds","sideEffects","warnings","errors { type entityId message }","changedEntities { id }"]}],a=(e,t)=>0===t?e:`${e}__${t}`,l=e=>e.split("\n").map(e=>`# ${e}`.trimEnd()).join("\n"),o=(e,t,i)=>[`fragment ${e} on ${t} {`,...i.map(e=>`  ${e}`),"}"].join("\n"),p=(e,t,i)=>{let n=e=>"edge"===e.type.kind?`${e.name} { ${i} }`:e.name;return o(e,s,["id",...t.flatMap(({typeName:e,fields:t})=>e===s?t.map(n):[`... on ${e} {`,...t.map(e=>`  ${n(e)}`),"}"])])};export const buildAssistantLenses=(d,m)=>{let c=Object.entries(d.lenses).flatMap(([e,t])=>{let i=[s,...Object.keys(d.aliases).filter(e=>e!==s),...d.entityTypes].flatMap(t=>{let i=(d.fields[t]??[]).filter(t=>t.lenses?.includes(e));return i.length>0?[{typeName:t,fields:i}]:[]});return i.length>0?[{name:e,...t,conditions:i}]:[]}),$=r.filter(({name:e})=>void 0!==m.getType(e)),h=[...c.map(({name:e,description:t,maxDepth:i,conditions:n})=>{let s=n.some(({fields:e})=>e.some(e=>"edge"===e.type.kind));return`${l(s?`${t} ${`Nested relations carry the same selection up to ${i} ${1===i?"level":"levels"}, below that only \`id\`.`}`:t)}
+${p(e,n,`...${e}`)}`}),...$.map(({name:e,description:t,selections:i})=>`${l(t)}
+${o(e,e,i)}`)].join("\n\n"),u=[...c.flatMap(({name:e,maxDepth:t,conditions:i})=>Array.from({length:t+1},(n,s)=>p(a(e,s),i,s<t?`...${a(e,s+1)}`:"id"))),...$.map(({name:e,selections:t})=>o(e,e,t))].join("\n\n");if(""!==u){let s=c.length>0?`entities { ${c.map(({name:e})=>`...${e}`).join(" ")} }`:"__typename",r=n(m,t(`${u}
+
+{ ${s} }`),i.filter(t=>t!==e));if(r.length>0)throw Error(`The lens fragments generated from "assistant.lenses" are not valid GraphQL: ${[...new Set(r.map(e=>e.message))].join(" ")}`)}return{declarations:h,definitions:u}};

package/dist/domain/application/assistant/build-assistant-manifest.d.ts

@@ -0,0 +1,3 @@
+import type { AssistantManifest, AssistantResolvedManifest } from '../../spec/index.js';
+/** Constructs the schema and runtime sources exclusively from serializable resolved data. */
+export declare const buildAssistantManifest: (resolved: AssistantResolvedManifest) => Required<AssistantManifest>;

package/dist/domain/application/assistant/build-assistant-manifest.js

@@ -0,0 +1 @@
+import{GraphQLBoolean as e,GraphQLEnumType as t,GraphQLID as n,GraphQLInputObjectType as i,GraphQLInterfaceType as s,GraphQLList as r,GraphQLNonNull as o,GraphQLObjectType as a,GraphQLSchema as p,GraphQLString as d,printSchema as c,validateSchema as l}from"graphql";import{GraphQLJSON as h,createAssistantValueType as y}from"./assistant-value-type.js";import{buildAssistantLenses as w}from"./build-assistant-lenses.js";import{createAssistantExecutionSchema as u}from"./create-assistant-execution-schema.js";let g="AnyDomainEntity",f="RootEntity",m=[["navigationState","Active navigation state.","navigationStates"],["viewState","Active view state.","viewStates"],["toolState","Active tool state.","toolStates"]],b={section:"childRecipes",mutation:"addChild",typeSuffix:"ChildRecipes"},v={section:"replaceRecipes",mutation:"replaceEntity",typeSuffix:"ReplaceRecipes"},$=(e,t)=>Object.entries(e).find(([e])=>e===t)?.[1],j=(e,t)=>{if(!t||0===t.length)return e;let n=`One of: ${t.map(e=>`"${e}"`).join(", ")}.`;return e?/[.!?]$/.test(e)?`${e} ${n}`:`${e}. ${n}`:n},O=({target:e,list:t,nullable:n},i)=>{let s=t?new r(new o(i(e))):i(e);return n?s:new o(s)},E=(e,t,i)=>{let s={id:{type:new o(n),description:i?`Unique id of the entity, assigned by the configurator, e.g. "${i}-1".`:void 0},type:{type:new o(d),description:i?`Entity type name, e.g. "${i}".`:void 0}};for(let n of e)s[n.name]={type:"edge"===n.type.kind?O(n.type,t):y(n.type.type),description:n.description};return s},R=e=>Object.fromEntries(e.map(({name:e,source:t,localized:n})=>[e,n?{source:t,localized:!0}:{source:t}])),k=new o(new r(new o(h))),T=' Each is { type, severity, entityId, message }: severity is "warning" or "notice", entityId the entity it is on or null, message the warning as the user would be told it or null.',I={sameForAllInstances:e=>`Same recipes for every ${e}.`,constantDuringSession:()=>"Fixed for the session."},S={sameForAllInstances:e=>`Same for every ${e}.`,constantDuringSession:()=>"Fixed for the session."},N=(e,t,n)=>e.map(e=>` ${t[e](n)}`).join(""),A=({section:e,typeSuffix:t},n,{entityType:i,purpose:s,recipeGroup:r})=>0===n.length?{}:{[e]:{type:new o(new a({name:`${i}${t}`,fields:Object.fromEntries(n.map(({groupId:e,description:t,dryRuns:n,hints:s})=>{let o;return[e,{type:r,description:`${!(o=t?.trim())?"":/[.!?]$/.test(o)?`${o} `:`${o}. `}Null while the configurator does not offer it on the entity.${n?"":" Cannot be dry-run."}${N(s,I,i)}`}]}))})),description:`The recipe groups for ${s} this ${i}, one field each.`}},M=({entityType:e,childRecipes:n,replaceRecipes:i,optionsEdges:s,screenshots:p,hasInvariants:d},{recipeGroup:c,fieldOption:l,screenshot:y})=>new a({name:`${e}Meta`,fields:Object.assign(A(b,n,{entityType:e,purpose:"adding children to",recipeGroup:c}),A(v,i,{entityType:e,purpose:"replacing",recipeGroup:c}),...s.map(({options:{edgeName:t,field:n,validate:i,dryRuns:s},hints:a})=>({[t]:{type:new r(new o(l)),args:{values:{type:new r(new o(h)),description:"Only the options with these values; values not listed are ignored."}},description:`Values "${n}" accepts on this ${e}. Null when there is no choice to make.${i?"":" Not checked on write."}${s?"":" Cannot be dry-run."}${N(a,S,e)}`}})),0===p.length?{}:{screenshot:{type:y,args:{view:{type:new o(new t({name:`${e}ScreenshotView`,values:Object.fromEntries(p.map(({view:e,description:t})=>[e,{description:t}]))}))}},description:"Renders this entity from a predefined view. The picture follows the tool result as an image labelled with `image`. Null when the view does not apply to this entity right now."}},d?{warnings:{type:k,description:`The warnings and notices this ${e} has right now.${T}`}}:{})}),D=(e,t)=>t?e?"What can be done to this entity right now, and its warnings.":"The warnings of this entity right now.":"What can be done to this entity right now.",W=e=>Object.entries(e).map(([e,t])=>`${e} (${t.map(({groupId:e})=>e).join(", ")})`);export const buildAssistantManifest=t=>{var I,S,N,A,x;let C,F,q,G,{entityTypes:U,aliases:K,exampleType:P,fields:V,states:z,deletableTypes:L,writableTypes:Q,actionFields:B,optionsEdges:H,invariantTypes:J}=t,{childRecipes:X,replaceRecipes:Y}=t,Z=new Map,_=new Map,ee=new Map,et=e=>{let[t,...n]=Object.entries(K).find(([t])=>t===e)?.[1]??[];return(t&&0===n.length?_.get(t):void 0)??ee.get(e)??ei},en=e=>_.get(e)??et(e),ei=new s({name:g,description:"Every entity of the configuration.",fields:()=>E(V[g]??[],en,P)});for(let e of(ee.set(g,ei),Object.keys(K)))e!==g&&ee.set(e,new s({name:e,interfaces:[ei],fields:()=>E(V[e]??[],en)}));let es={};for(let e of U){let t=[g,...Object.entries(K).filter(([t,n])=>t!==g&&n.includes(e)).map(([e])=>e)],n=V[e]??[];es[e]=R(n),_.set(e,new a({name:e,interfaces:t.flatMap(e=>ee.get(e)??[]),fields:()=>{let t=Z.get(e);return{...E(n,en),...t?{meta:{type:new o(t.type),description:t.description}}:{}}}}))}let er=(I=()=>et(ee.has(f)?f:g),S=()=>et(g),C=new a({name:"DryRunError",description:"One reason a change cannot be made right now.",fields:{type:{type:new o(d),description:"Kind of the problem."},entityId:{type:n,description:"The entity the problem is on, when it is on one."},message:{type:d,description:"The problem as the user would be told it."}}}),new a({name:"DryRun",description:"What using a recipe or writing an option would do, tried out on the configuration the query reads. Nothing is changed.",fields:()=>({ok:{type:new o(e),description:"Whether the change would succeed on the configuration the query reads."},root:{type:I(),description:"The root entity of the configuration as it would be after the change; null when ok is false. Everything selected under it reads that configuration."},changedEntities:{type:new o(new r(new o(S()))),description:"Entities the change would add or modify; empty when ok is false. One whose id is not in the configuration would be added, and its real id may differ. An entity written to is listed even when its values stay the same."},deletedEntityIds:{type:new o(new r(new o(n))),description:"The ids of the entities the change would remove; empty when ok is false."},sideEffects:{type:new o(new r(new o(d))),description:"The major or unexpected things the configurator would change along with it; empty when ok is false."},warnings:{type:k,description:`The warnings and notices the change would newly cause, which do not stop it; empty when ok is false.${T}`},errors:{type:new o(new r(new o(C))),description:"Why the change cannot be made; empty when ok is true."}})})),eo={recipeGroup:(N=[...Object.keys(X).length>0?[b.mutation]:[],...Object.keys(Y).length>0?[v.mutation]:[]],F=N.join(" or "),q=new a({name:"Recipe",description:`${N.includes("addChild")?"One thing that can be added to the entity (under childRecipes)":"One thing the entity can be replaced with (under replaceRecipes)"}${N.length>1?" or that it can be replaced with (under replaceRecipes)":""}.`,fields:{key:{type:new o(d),description:`Pass to ${F} as recipeKey, or to recipes(keys:) to read this recipe again.`},name:{type:new o(d),description:"Name shown to the user."},description:{type:d},imageUrl:{type:d,description:"Thumbnail shown to the user."},dryRun:{type:er,description:"What using this recipe would do. Null when it cannot be tried."}}}),new a({name:"RecipeGroup",description:"A group of recipes for this entity.",fields:{groupId:{type:new o(d),description:`Pass to ${F} as recipeGroupId.`},name:{type:new o(d),description:"Name shown to the user."},description:{type:d},recipes:{type:new o(new r(new o(q))),args:{keys:{type:new r(new o(d)),description:"Only the recipes with these keys; keys not in the group are ignored."}}}}})),fieldOption:new a({name:"FieldOption",description:"One value a field accepts. Writing a value outside the list is rejected unless the field description says it is not checked.",fields:{value:{type:new o(h),description:"The value to write to the field."},name:{type:d,description:"Name shown to the user."},description:{type:d},imageUrl:{type:d,description:"Image shown to the user."},color:{type:d,description:'Color shown to the user, as "#rrggbb".'},dryRun:{type:er,description:"What writing this value would do. Null when it cannot be tried."}}}),screenshot:new a({name:"Screenshot",description:"A screenshot of an entity. The picture itself follows the tool result.",fields:{image:{type:new o(n),description:"Label of the image that follows the tool result."}}})};for(let e of U){let n=$(X,e)??[],i=$(Y,e)??[],s=$(H,e)??[],r=$(t.screenshots,e)??[],o=J.includes(e),a=n.length>0||i.length>0||s.length>0||r.length>0;(a||o)&&Z.set(e,{description:D(a,o),type:M({entityType:e,childRecipes:n,replaceRecipes:i,optionsEdges:s,screenshots:r,hasInvariants:o},eo)})}let ea=new p({query:(A=et(ee.has(f)?f:g),x=et(g),G=(e=>{let t={};for(let[n,i,s]of m){let r=e[s];r.length>1&&(t[n]={type:new o(d),description:j(i,r)})}if(0!==Object.keys(t).length)return new a({name:"Navigation",description:"The active UI states of the configurator.",fields:t})})(z),new a({name:"Query",fields:{root:{type:new o(A),description:"The root entity of the configuration."},entities:{type:new o(new r(x)),args:{ids:{type:new r(new o(n))}},description:"Every entity, or the given ids in order with null for an unknown id."},selectedEntity:{type:new o(x),description:"The selected entity, or the root entity when nothing is selected."},...G?{navigation:{type:new o(G)}}:{},warnings:{type:k,description:`Every warning and notice of the configuration the query reads.${T}`}}})),mutation:(({deletableTypes:e,writableTypes:t,childRecipes:s,replaceRecipes:p,actionFields:c,objectTypes:l,anyDomainEntity:h,targetOutputType:w})=>{let u,g;if(0!==e.length||0!==t.length||0!==Object.keys(s).length||0!==Object.keys(p).length||0!==c.length)return new a({name:"Mutation",fields:Object.assign(0===e.length?{}:{deleteEntity:{type:new o(new r(new o(n))),args:{id:{type:new o(n)}},description:`Deletes the entity and everything composed into it. Deletable types: ${e.join(", ")}. Returns the ids removed, the given one first.`}},0===(u=W(s)).length?{}:{addChild:{type:new o(new r(new o(h))),args:{parentId:{type:new o(n)},recipeGroupId:{type:new o(d)},recipeKey:{type:new o(d)}},description:`Adds a child to the entity parentId from a recipe listed under its meta { childRecipes }. Types with child recipes: ${u.join("; ")}. Returns the entities added, the recipe's own first; empty when they were removed again.`}},0===(g=W(p)).length?{}:{replaceEntity:{type:new o(new r(new o(h))),args:{entityId:{type:new o(n)},recipeGroupId:{type:new o(d)},recipeKey:{type:new o(d)}},description:`Replaces the entity entityId from a recipe listed under its meta { replaceRecipes }. Types with replace recipes: ${g.join("; ")}. The replacement is a new entity: it has a new id and the field values of its recipe, and entityId no longer exists. Returns the entities added, the replacement first; empty when they were removed again.`}},...t.flatMap(e=>{let t=l.get(e.entityType);return t?[(({entityType:e,fields:t},s)=>{let r=Object.fromEntries(t.map(({name:e,type:t,description:n})=>[e,{type:y(t),description:n}]));return{[`modify${e}`]:{type:s,args:{id:{type:new o(n)},delta:{type:new o(new i({name:`${e}Delta`,fields:r}))}},description:`Sets the fields named in delta on one ${e}. Returns the entity after the change, or null when the change removed it.`}}})(e,t)]:[]}),Object.fromEntries(c.map(e=>{var t;return[e.fieldName,{type:new o(new a({name:(t=e.fieldName,`${t.charAt(0).toUpperCase()+t.slice(1)}Result`),description:`What ${e.fieldName} returns, read from the configuration after the change.`,fields:()=>Object.fromEntries(Object.entries(e.result).map(([e,t])=>[e,{type:"edge"===t.kind?O(t,w):y(t.type),description:t.description}]))})),args:Object.fromEntries(Object.entries(e.args).map(([e,t])=>[e,{type:y(t.type),description:t.description}])),description:e.description}]})))})})({deletableTypes:L,writableTypes:Q,childRecipes:X,replaceRecipes:Y,actionFields:B,objectTypes:_,anyDomainEntity:et(g),targetOutputType:en}),types:[...ee.values(),..._.values()]}),ep=l(ea);if(ep.length>0)throw Error(ep.map(e=>e.message).join(" "));let ed=c(ea);return{sdl:ed,navigationFields:m.filter(([,,e])=>z[e].length>1).map(([e])=>e),fields:es,deletableTypes:L,writableFields:Object.fromEntries(Q.map(({entityType:e,fields:t})=>[e,Object.fromEntries(t.map(({name:e,property:t})=>[e,t]))])),childRecipes:X,replaceRecipes:Y,fieldOptions:Object.fromEntries(U.flatMap(e=>{let t=$(H,e);return t?[[e,t.map(({options:e})=>e)]]:[]})),screenshots:Object.fromEntries(U.flatMap(e=>{let n=$(t.screenshots,e);return n?[[e,n]]:[]})),actions:Object.fromEntries(B.map(({fieldName:e,actionName:t})=>[e,t])),lenses:w(t,u(ed)),formElements:t.formElements}};

package/dist/domain/application/assistant/create-assistant-execution-schema.d.ts

@@ -0,0 +1,32 @@
+import { type GraphQLSchema } from 'graphql';
+/** One entity type or alias exposing a field, with the field's type as the assistant schema prints it. */
+export interface AssistantFieldExposure {
+    readonly typeName: string;
+    readonly type: string;
+}
+/**
+ * Entity types or aliases expose one field name in shapes no selection can hold together: a single
+ * entity, a list of entities and a plain value cannot share a name. GraphQL rejects every operation
+ * that selects the field on both, and no common type exists to widen them to. `exposures` lists the
+ * aliases and types that declare the field, without the members that only repeat an alias's field.
+ */
+export declare class AssistantFieldClashError extends Error {
+    readonly fieldName: string;
+    readonly exposures: readonly AssistantFieldExposure[];
+    constructor(fieldName: string, exposures: readonly AssistantFieldExposure[]);
+}
+/**
+ * Compiles the schema operations are validated and executed against from the assistant SDL the agent
+ * reads. GraphQL requires fields selected under one name to have the same type, nullability included,
+ * even on entity types that can never be the same entity, so a lens or a hand-written selection that
+ * reaches such a field on two types would be rejected although its result is unambiguous. The
+ * execution schema therefore widens the type of every field name that entity types and aliases
+ * expose with different types, and leaves everything else as it is. It accepts every operation the
+ * SDL accepts and some the SDL would reject; the SDL stays the precise description of the data.
+ * Accepted: a widened field no longer enforces its SDL type on the value it resolves to. A null in a
+ * field the SDL declares non-null is returned as null instead of failing the operation, and a field
+ * widened to `JSON` is returned as it is, without the coercion of its scalar. Values that match their
+ * SDL type, which is every value a valid configuration holds, give the same result. Throws
+ * {@link AssistantFieldClashError} for the shapes nothing can widen.
+ */
+export declare const createAssistantExecutionSchema: (sdl: string) => GraphQLSchema;

package/dist/domain/application/assistant/create-assistant-execution-schema.js

@@ -0,0 +1 @@
+import{Kind as e,buildASTSchema as t,parse as n,print as a}from"graphql";let i="AnyDomainEntity",l="JSON",s=new Set(["Int","Float","String","Boolean","ID",l]);export class AssistantFieldClashError extends Error{fieldName;exposures;constructor(e,t){super(`The field "${e}" cannot be selected on every entity type that has it: ${t.map(({typeName:t,type:n})=>`${t}.${e} is ${n}`).join(", ")}.`),this.fieldName=e,this.exposures=t,this.name="AssistantFieldClashError"}}let r=t=>(t.kind===e.OBJECT_TYPE_DEFINITION||t.kind===e.INTERFACE_TYPE_DEFINITION)&&(t.name.value===i||(t.interfaces??[]).some(({name:e})=>e.value===i)),o=t=>t.kind===e.NON_NULL_TYPE?t.type:t,m=t=>t.kind===e.NAMED_TYPE?t.name.value:m(t.type),u=e=>a(e).replace(m(e),""),p={kind:e.NAMED_TYPE,name:{kind:e.NAME,value:l}},d=(t,n)=>{let i=n.map(({type:e})=>e);if(1===new Set(i.map(e=>a(e))).size)return;let l=i.map(e=>s.has(m(e)));if(l.every(Boolean))return 1===new Set(i.map(e=>a(o(e)))).size?"nullable":"json";if(!l.some(Boolean)){if(1===new Set(i.map(u)).size)return;if(i.every(t=>o(t).kind===e.NAMED_TYPE))return"nullable"}throw new AssistantFieldClashError(t,n.filter(({inherited:e})=>!e).map(({typeName:e,type:t})=>({typeName:e,type:a(t)})))};export const createAssistantExecutionSchema=a=>t((t=>{let n=t.definitions.filter(r),a=(e,t)=>n.some(n=>n.name.value===e&&(n.fields??[]).some(e=>e.name.value===t)),i=new Map;for(let e of n)for(let t of e.fields??[])i.set(t.name.value,[...i.get(t.name.value)??[],{typeName:e.name.value,type:t.type,inherited:(e.interfaces??[]).some(({name:e})=>a(e.value,t.name.value))}]);let s=new Map;for(let[e,t]of i){let n=d(e,t);n&&s.set(e,n)}let m=e=>{let t=s.get(e.name.value);return t?{...e,type:"json"===t?p:o(e.type)}:e},u=t.definitions.map(e=>r(e)?{...e,fields:e.fields?.map(m)}:e),f=u.some(t=>t.kind===e.SCALAR_TYPE_DEFINITION&&t.name.value===l),E=[...s.values()].includes("json");return{...t,definitions:E&&!f?[...u,{kind:e.SCALAR_TYPE_DEFINITION,name:{kind:e.NAME,value:l}}]:u}})(n(a)));

package/dist/domain/application/assistant/generate-assistant-prompt.d.ts

@@ -0,0 +1,5 @@
+import { type AssistantFormElementDescriptor, type AssistantManifest } from '../../spec/index.js';
+/** How the prompt writes an element: its tag with each attribute and what it takes. Exported for tests. */
+export declare const formElementSignature: ({ name, role, attributes }: AssistantFormElementDescriptor) => string;
+/** SDK-version conventions for using the manifest's capabilities and reading their results. */
+export declare const generateAssistantPrompt: (assistant: AssistantManifest) => string;

package/dist/domain/application/assistant/generate-assistant-prompt.js

@@ -0,0 +1 @@
+import{ASSISTANT_BUILT_IN_FORM_ELEMENTS as e}from"../../spec/index.js";let t=[["Containers",["group","choice","choices"]],["Options",["option"]],["Inputs",["input"]]];export const formElementSignature=({name:e,role:t,attributes:a})=>{let n=["label",...Object.entries(a).map(([e,t])=>((e,{type:t,enum:a})=>a?`${e}="${a.join("|")}"`:"string"===t?e:`${e}="<${t}>"`)(e,t))];return"option"===t||"input"===t?`<${e} ${n.join(" ")} />`:`<${e} ${n.join(" ")}>…</${e}>`};export const generateAssistantPrompt=a=>{let n,s=Object.values(a.childRecipes??{}).some(e=>e.length>0),o=Object.values(a.replaceRecipes??{}).some(e=>e.length>0),i=Object.values(a.fieldOptions??{}).some(e=>e.length>0),r=Object.keys(a.actions??{}).length>0,h=Object.values(a.screenshots??{}).some(e=>e.length>0),l=(a.deletableTypes?.length??0)>0||Object.values(a.writableFields??{}).some(e=>Object.keys(e).length>0)||s||o||r,d=s||o||i,c=[...s?["`childRecipes` is what can be added to it"]:[],...o?["`replaceRecipes` what it can be replaced with"]:[],...i?["`<field>Options` the values a field accepts"]:[]],u=["`selected`",...(a.navigationFields??[]).map(e=>`\`${e}\``)].join(", ");return[["Tools","- Put related operations in one call and select only the fields you need.",`- Give every ${l?"`query` and `apply` call":"`query` call"} a \`title\` of two to five words in the user's language that says what it does for them, e.g. ${l?'"Add two drawers"':'"Compare drawer prices"'}.`,...l?[`- Use a mutation inside \`query\` to answer a what-if about a change ${d?"the lists under `meta` do not show":"before making it"}.`,"- Use `apply` only for what the user asked for."]:["- Nothing in this configurator can be changed through you. Say so when the user asks for a change."],"- When an operation fails, its `errors` say why and what to send instead. A change the configuration does not allow fails with one error per reason, as the user would be told it.","- Warnings and notices never make anything fail. The root `warnings` field lists every current one, and `meta { warnings }` those of one entity, where its type has them."],...l?[["After a change","- A change is made only when the `apply` result has `committed: true`. Otherwise `errors` or `message` says what happened; without either, nothing changed. Never say a change was made when it was not.","- `sideEffects` names the major or unexpected things the configurator changed along with your change. Tell the user about them when committed; otherwise they describe what would happen. Smaller adjustments are not listed.","- `warnings` lists the warnings and notices your change newly causes. They do not block it: tell the user about them, and offer a fix when one is clear.","- A mutation returns the state after the change: use the ids and values it returned, not the ones you sent.",...r?["- When one mutation does the whole of what the user asked, use it instead of building the same change from several others."]:[]]]:[],...d?[["What can be done to an entity",`- \`meta\` lists what is possible right now: ${c.join(", ")}. Read the list before such a change and before telling the user what is available.`,`- You can select \`dryRun\` on ${[...s||o?["recipes"]:[],...i?["options"]:[]].join(" or ")} to look ahead and pick one that meets what the user asked for. It is optional before a change.`,`- Select only the ${[...s||o?["recipe groups"]:[],...i?["options edges"]:[]].join(" and ")} you need. To read again only the ones you are deciding between, pass ${[...s||o?["their `key` to `recipes(keys:)`"]:[],...i?["their `value` to `<field>Options(values:)`"]:[]].join(" or ")}.`,"- Read the lists again after a change, unless their descriptions say they stay the same."]]:[],...h?[["Seeing the design","- `meta { screenshot(view: …) { image } }` renders an entity from one of the views its `<Type>ScreenshotView` lists. The picture follows the tool result.","- Take one when the user asks how the design looks, or when you are not sure something is laid out right: what sits where, what overlaps or lines up. Otherwise rely on the data.","- Each one costs tokens and blocks the user's configurator while it renders."]]:[],["Images from the user","- The user may attach photos or reference images to a message, such as their room or a design they like.","- Sizes you read from a photo are estimates: tell the user the values you read and confirm them before you apply them.","- An image the message calls an annotation is marked up by the user: the red strokes are drawn by the user, and each numbered red pin marks the place its comment, listed by number before the message, is about.","- An annotation of the configurator view is the user's own current view of the configurator, not one of the screenshot views. An annotation of an image marks up an image, such as one of your drawings."],["The `[changes]` block","- Every user message starts with it: a glimpse of what the user did in the configurator since your last turn.",`- \`[changes: none]\`, or only ${u} lines: what you know still holds. Do not query it again.`,"- Other lines are a hint at what to read again: `A` added, `D` deleted, `M` modified with the fields. Text after `#` says what caused the line; `reset: undo/redo` says the user undid or redid changes.","- Read computed fields again when a listed change may affect them.","- `[changes: unavailable]` and `[changes: too many (n)]`: read again before relying on anything you read earlier.",...l?["- Your applied changes are not listed, except those waiting for user approval: they appear once approved."]:[]],["Reading the schema","- Take ids from results.",...(a.deletableTypes?.length??0)>0||o?["- The id of a deleted or replaced entity is gone and may later be given to another entity."]:[],`- A field whose name starts with \`_\` is computed: read it${l?", never write it":""}.`,"- Numbers are in the unit the field description names. Convert when the user uses another unit."],["Links","- You may link an entity of the current configuration when you speak about that very entity: `[the left burner](entity:CookingTop-1)`. It helps the user find it in the configurator.",...d?["- Whenever you name recipes or options you read from `meta`, in a list, a table or a sentence, link each one: `[Single gas burner](recipe:KitchenRange-1/top/gas_single)` or `[Oak](option:Cabinet-2/finishOptions/oak)`. The link shows the user its picture or color and its description, so never draw previews yourself. The target is the entity id, the recipe group id or the options field you read, and the key or value, each encoded as in a URL."]:[]],["Replies","- Write Markdown only, never HTML: the panel does not render it. Only a drawing holds markup.","- An image, `![alt](path)`, is shown only when its path is relative.","- To make a warning or a key note stand out, write a GitHub alert: a blockquote whose first line is only `[!WARNING]` or `[!NOTE]`. Use it sparingly."],["Drawings","- You can draw a schematic for the user: a fenced code block with the language `svg` that holds one SVG document. The panel shows it as a picture, and the user can open it larger beside the chat.","- Draw when a schematic explains better than words, such as a layout seen from above, dimensions or clearances, or a comparison of options, or when the user or the instructions of this configurator ask for one. Never draw what the product looks like: the user sees it in the configurator.","- At most one drawing per reply.",'- The root is `<svg xmlns="http://www.w3.org/2000/svg" viewBox="…">`, and its first child is a `<title>` that says what the drawing shows.',"- Paint the background first with a `<rect>` that covers the whole `viewBox`, and give every fill and stroke an explicit colour, never `currentColor` or a CSS variable.","- The picture is as wide as the chat panel, about 360 px: keep text at least 14 px tall at that width, and use generic font families such as `sans-serif`.","- A drawing runs no script and loads nothing: no `<script>`, event attributes, `<foreignObject>`, external links or images.","- Keep it simple: a drawing that is not well-formed SVG, or is over 200 KB, is not shown.","- The user can annotate a drawing to give you feedback on it: their message then carries it as an annotation of an image."],["Forms","- To ask the user something they answer by picking or typing, end your reply with a form: a fenced code block with the language `form`. It holds only elements, written as lowercase tags with string attributes, without Markdown or text.","- Every element takes `label`, the text the user sees; on a container or an input it also names the answer. An option or an input whose signature lists `value` takes it: an option sends it instead of its label, and an input starts with it.",'- A bare attribute in a signature takes any text, `name="<type>"` takes a value of that type written as text, such as `min="<number>"`, and `name="a|b"` takes one of the words listed.',"- Options can also stand on their own, outside a `choice` or `choices`.","- An element or attribute not listed here, or an element other than an option inside a `choice` or `choices`, makes the whole form fail.","- The answer is the user's next message. Each container or input gives a line `Label: value`, or the bare value without a label; the lines of a labelled container are indented by two spaces under it, a `choices` lists each picked option on its own line, and `—` marks what was left unanswered.",'- Example: `<choice label="Plinth"><reply label="Black" /><reply label="Oak" /></choice>` is answered with `Plinth: Oak`.',"- The chat shows the answer as the user's own message, so a `value` reads as natural words, never as an id, key or code. Give `value` only when the label alone would be unclear as an answer, and map the answer's labels back to ids yourself.",...(n=[...e,...a.formElements??[]],t.flatMap(([e,t])=>{let a=n.filter(({role:e})=>t.includes(e));return 0===a.length?[]:[`- ${e}:`,...a.map(e=>`  - \`${formElementSignature(e)}\`: ${(({description:e,required:t=[]})=>0===t.length?e:`${e} Requires ${t.map(e=>`\`${e}\``).join(", ")}.`)(e)}`)]}))],...a.lenses?.declarations?[["Built-in fragments","- These fragments are already defined for every operation. Spread one by name on a field of its type, as in `field { ...FragmentName }`, instead of listing its fields.","- A fragment is a starting selection: add the other fields you need next to the spread, by name from the schema.","- Never define a fragment with one of these names.","",a.lenses.declarations]]:[]].map(e=>e.join("\n")).join("\n\n")};

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

@@ -0,0 +1,6 @@
+export { buildAssistantManifest } from './build-assistant-manifest.js';
+export type { AssistantFieldExposure } from './create-assistant-execution-schema.js';
+export { AssistantFieldClashError, createAssistantExecutionSchema } from './create-assistant-execution-schema.js';
+export { generateAssistantPrompt } from './generate-assistant-prompt.js';
+export * from './session-setup/index.js';
+export { describeAssistantValues, mergeAssistantFields, resolveAssistantField } from './assistant-fields.js';

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

@@ -0,0 +1 @@
+export{buildAssistantManifest}from"./build-assistant-manifest.js";export{AssistantFieldClashError,createAssistantExecutionSchema}from"./create-assistant-execution-schema.js";export{generateAssistantPrompt}from"./generate-assistant-prompt.js";export*from"./session-setup/index.js";export{describeAssistantValues,mergeAssistantFields,resolveAssistantField}from"./assistant-fields.js";

package/dist/domain/application/assistant/session-setup/AssistantSetupHandler.d.ts

@@ -0,0 +1,20 @@
+import type { AccessLevel, SessionRole } from '@salsita-ai/contracts/api';
+import type { $DomainEntity, ActionTypes, DomainEntity } from '../../../core/index.js';
+import type { HandlerRegistration, SystemPhoenixHandlerRegistration } from '../../../spec/index.js';
+import type { AssistantSetupManifest } from './assistant-setup-manifest.js';
+/** Project-defined session inputs used by browser execution and the assistant setup webhook. */
+export interface AssistantSetupInputs<SESSION_DATA> {
+    readonly role: SessionRole;
+    readonly sessionData: SESSION_DATA;
+    readonly access: AccessLevel;
+}
+/** Arguments carried by the standard single-props system-handler registration. */
+export interface AssistantSetupHandlerProps<SESSION_DATA, ENTITIES extends DomainEntity<string> = DomainEntity<string>, $MAP extends Record<keyof $MAP, $DomainEntity<ENTITIES>> = Record<string, $DomainEntity<ENTITIES>>, ACTIONS extends ActionTypes = ActionTypes> {
+    readonly manifest: AssistantSetupManifest<ENTITIES, $MAP, ACTIONS>;
+    readonly inputs: AssistantSetupInputs<SESSION_DATA>;
+}
+/** A project setup handler is synchronous, pure and deterministic. Return null to disable the assistant. */
+export type TypedCreateAssistantSetupHandler<SESSION_DATA, ENTITIES extends DomainEntity<string> = DomainEntity<string>, $MAP extends Record<keyof $MAP, $DomainEntity<ENTITIES>> = Record<string, $DomainEntity<ENTITIES>>, ACTIONS extends ActionTypes = ActionTypes> = (fn: (manifest: AssistantSetupManifest<ENTITIES, $MAP, ACTIONS>, inputs: AssistantSetupInputs<SESSION_DATA>) => AssistantSetupManifest<ENTITIES, $MAP, ACTIONS> | null) => SystemPhoenixHandlerRegistration<AssistantSetupHandlerProps<SESSION_DATA, ENTITIES, $MAP, ACTIONS>, AssistantSetupManifest<ENTITIES, $MAP, ACTIONS> | null>;
+export declare const createAssistantSetupHandler: <SESSION_DATA, ENTITIES extends DomainEntity<string> = DomainEntity<string>, $MAP extends Record<keyof $MAP, $DomainEntity<ENTITIES>> = Record<string, $DomainEntity<ENTITIES>>, ACTIONS extends ActionTypes = ActionTypes>(fn: (manifest: AssistantSetupManifest<ENTITIES, $MAP, ACTIONS>, inputs: AssistantSetupInputs<SESSION_DATA>) => AssistantSetupManifest<ENTITIES, $MAP, ACTIONS> | null) => SystemPhoenixHandlerRegistration<AssistantSetupHandlerProps<SESSION_DATA, ENTITIES, $MAP, ACTIONS>, AssistantSetupManifest<ENTITIES, $MAP, ACTIONS> | null>;
+export declare const createAssistantSetupHandlerFactory: <SESSION_DATA, ENTITIES extends DomainEntity<string> = DomainEntity<string>, $MAP extends Record<keyof $MAP, $DomainEntity<ENTITIES>> = Record<string, $DomainEntity<ENTITIES>>, ACTIONS extends ActionTypes = ActionTypes>() => TypedCreateAssistantSetupHandler<SESSION_DATA, ENTITIES, $MAP, ACTIONS>;
+export declare const isAssistantSetupHandler: (handler: Pick<HandlerRegistration<never, unknown>, 'type' | 'name'>) => handler is SystemPhoenixHandlerRegistration<AssistantSetupHandlerProps<Record<string, unknown>>, AssistantSetupManifest | null>;

package/dist/domain/application/assistant/session-setup/AssistantSetupHandler.js

@@ -0,0 +1 @@
+export const createAssistantSetupHandler=t=>({type:"system",name:"AssistantSetupHandler",handler:()=>({handler:({manifest:e,inputs:s})=>t(e,s)})});export const createAssistantSetupHandlerFactory=()=>createAssistantSetupHandler;export const isAssistantSetupHandler=t=>"system"===t.type&&"AssistantSetupHandler"===t.name;

package/dist/domain/application/assistant/session-setup/apply-assistant-setup.d.ts

@@ -0,0 +1,10 @@
+import type { AssistantResolvedManifest } from '../../../spec/index.js';
+import { type AssistantSetupManifest, type AssistantSetupSettings } from './assistant-setup-manifest.js';
+/** A project returned a setup that broadens or invalidates its declared whitelist. */
+export declare class AssistantSetupError extends Error {
+    constructor(key: string, reason: string);
+}
+export declare const applyAssistantSetup: (resolved: AssistantResolvedManifest, settings: AssistantSetupSettings | null, returned: AssistantSetupManifest | null) => {
+    readonly resolved: AssistantResolvedManifest;
+    readonly settings: AssistantSetupSettings | null;
+} | null;

package/dist/domain/application/assistant/session-setup/apply-assistant-setup.js

@@ -0,0 +1 @@
+import{ASSISTANT_AI_PROVIDERS as e,ASSISTANT_HOURLY_LIMIT_LEVELS as t,ASSISTANT_MODEL_TIERS as i,ASSISTANT_REASONING_LEVELS as s}from"@salsita-ai/contracts/assistant";import{describeAssistantValues as n,mergeAssistantFields as o,resolveAssistantField as a}from"../assistant-fields.js";import{projectAssistantSetupManifest as r}from"./assistant-setup-manifest.js";export class AssistantSetupError extends Error{constructor(e,t){super(`${e}: ${t}`),this.name="AssistantSetupError"}}let l=(e,t)=>{throw new AssistantSetupError(e,t)},c=(e,t,i)=>{for(let s of((null===t||"object"!=typeof t||Array.isArray(t))&&l(i,"expected an object; omit an entry to remove it"),Object.keys(t)))Object.hasOwn(e,s)||l(`${i}.${s}`,"not declared in the spec; remove this key")},p=(e,t)=>Object.hasOwn(e,t)?e[t]:void 0,d=(e,t,i)=>(void 0!==e&&"string"!=typeof e&&l(`${i}.description`,"expected a string"),e??t),f=(e,t,i)=>(void 0!==e&&!1!==e&&l(`${i}.allowDryRuns`,"can only disable dry-runs; omit this flag or set false"),!1!==e&&t);export const applyAssistantSetup=(u,m,b)=>{if(null===b)return null;let y=r(u,m),v=u.declarations;c({entities:{},deletable:{},writable:{},childRecipes:{},replaceRecipes:{},screenshots:{},actions:{},instructions:"",ai:{}},b,"assistant"),c(y.entities,b.entities,"assistant.entities"),c(y.deletable,b.deletable,"assistant.deletable"),c(y.writable,b.writable,"assistant.writable"),c(y.actions,b.actions,"assistant.actions"),c(y.screenshots,b.screenshots,"assistant.screenshots");let h=Object.fromEntries(Object.entries(b.entities).map(([e,t])=>{let i=`assistant.entities.${e}`;c(y.entities[e],t,i);let s=v.entities[e];return[e,Object.entries(t).map(([e,t])=>{c({description:""},t,`${i}.${e}`);let o=s.find(t=>t.source===e),a=d(t.description,o.valueDescription,`${i}.${e}`);return{...o,valueDescription:a,description:n(a,o.enumValues),describedByManifest:void 0!==t.description||o.describedByManifest}})]})),g=(e,t,i)=>l(`assistant.entities.${e}`,`conflicting sources ${t} and ${i}`),w=o([],p(h,"AnyDomainEntity")??[],()=>void 0,g),$=new Map([["AnyDomainEntity",w]]);for(let e of Object.keys(u.aliases))"AnyDomainEntity"!==e&&$.set(e,o([w],p(h,e)??[],()=>void 0,g));for(let e of u.entityTypes){let t=Object.entries(u.aliases).filter(([t,i])=>"AnyDomainEntity"!==t&&i.includes(e));$.set(e,o([w,...t.map(([e])=>$.get(e)??[])],p(h,e)??[],t=>v.enumValues[e]?.[t],g))}let O=Object.fromEntries([...$].map(([e,t])=>[e,t.map(t=>a(t,p(h,e)??[]))])),j=new Map,x=new Map;for(let[e,t]of Object.entries(b.writable)){let i=`assistant.writable.${e}`;for(let[s,n]of(c(y.writable[e],t,i),Object.entries(t))){let t=`${i}.${s}`,o=v.writable[e][s];for(let[e,{field:i,options:a,exposedDescription:r}]of(c(Object.values(o.members).some(e=>e.options)?{options:{}}:{},n,t),void 0!==n.options&&(c({validate:!0,allowDryRuns:!1},n.options,`${t}.options`),void 0!==n.options.validate&&!0!==n.options.validate&&l(`${t}.options.validate`,"can only enable validation; omit this flag or set true"),f(n.options.allowDryRuns,!0,`${t}.options`)),Object.entries(o.members))){let c=p(h,e)?.find(e=>e.source===s)?.name??$.get(e)?.find(e=>e.source===s)?.name,d=c??s;void 0===c&&$.get(e)?.some(e=>e.name===s&&e.source!==s)&&l(t,`narrowing leaves ${e}.${s} bound to another read field; retain its original exposure or remove this writable property`);let u=j.get(e)??new Map;if([...u.values()].some(e=>e.name===d&&e.property!==s)&&l(t,`narrowing maps multiple writable properties to ${e}.${d}; retain their original exposures or remove the conflicting property`),u.has(s)||u.set(s,{...i,name:d,...void 0===c?{}:{description:r}}),j.set(e,u),a){let i=o.defaultOptionsName?`${d}Options`:a.options.edgeName;x.get(e)?.some(e=>e.options.edgeName===i||e.options.field===d)&&l(`${t}.options`,`narrowing duplicates options edge ${e}.${i}; retain the original field exposures or remove the conflicting writable declaration`),x.set(e,[...x.get(e)??[],{hints:a.hints,options:{...a.options,field:d,edgeName:i,validate:n.options?.validate??a.options.validate,dryRuns:f(n.options?.allowDryRuns,a.options.dryRuns,`${t}.options`)}}])}}}}for(let[e,t]of Object.entries(u.optionsEdges))for(let i of t){let t=u.writableTypes.find(t=>t.entityType===e)?.fields.find(e=>e.name===i.options.field)?.property;if(i.options.validate&&t&&j.get(e)?.has(t)&&!x.get(e)?.some(i=>i.options.field===j.get(e)?.get(t)?.name&&i.options.validate)){let i=Object.keys(b.writable).find(i=>Object.hasOwn(b.writable[i],t)&&v.writable[i]?.[t]?.members[e]);l(`assistant.writable.${i}.${t}`,`cannot remove declared validation while another declaration keeps ${e}.${t} writable; remove all writable declarations for it`)}}let E=e=>{c(y[e],b[e],`assistant.${e}`);let t=new Map;for(let[i,s]of Object.entries(b[e])){let n=`assistant.${e}.${i}`;c(y[e][i],s,n);let o=v[e][i],a=Object.entries(s).map(([e,t])=>{let i=`${n}.${e}`;c({description:"",allowDryRuns:!1},t,i);let s=o.find(t=>t.instanceName===e);return{...s,description:d(t.description,s.description,i),dryRuns:f(t.allowDryRuns,s.dryRuns,i)}});for(let e of u.entityTypes.includes(i)?[i]:u.aliases[i]??[])t.set(e,[...t.get(e)??[],...a])}return Object.fromEntries(u.entityTypes.flatMap(e=>{let i=t.get(e);return i?.length?[[e,i]]:[]}))},T=new Map;for(let[e,t]of Object.entries(b.screenshots)){let i=`assistant.screenshots.${e}`;c(y.screenshots[e],t,i);let s=u.entityTypes.includes(e)?[e]:u.aliases[e]??[];for(let[n,o]of Object.entries(t)){let t=`${i}.${n}`;c({description:""},o,t);let a=v.screenshots[e].find(e=>e.instanceName===n),r={...a,description:d(o.description,a.description,t)??a.description};for(let e of s)T.set(e,[...T.get(e)??[],r])}}for(let[e,t]of Object.entries(b.deletable))c({},t,`assistant.deletable.${e}`);let R=new Set(Object.keys(b.deletable).flatMap(e=>u.entityTypes.includes(e)?[e]:u.aliases[e]??[])),M=u.actionFields.flatMap(e=>{let t=p(b.actions,e.actionName);if(void 0===t)return[];let i=`assistant.actions.${e.actionName}`;return c({description:""},t,i),[{...e,description:d(t.description,e.description,i)}]}),D=m;if(m){void 0!==b.ai&&c({...m.ai,maxThreadSize:void 0,hourlyLimits:void 0,voice:void 0},b.ai,"assistant.ai");let{hourlyLimits:n,...o}=b.ai??{},a={...m.ai.hourlyLimits};if(void 0!==n)for(let e of(c(Object.fromEntries(t.map(e=>[e,void 0])),n,"assistant.ai.hourlyLimits"),t)){let t=n[e];void 0!==t&&((!Number.isInteger(t)||t<=0)&&l(`assistant.ai.hourlyLimits.${e}`,"expected a positive whole number of weighted tokens"),a[e]=t)}let r={...m.ai,...Object.fromEntries(Object.entries(o).filter(([,e])=>void 0!==e)),...Object.keys(a).length>0&&{hourlyLimits:a}};e.includes(r.provider)&&i.includes(r.model)&&s.includes(r.reasoning)||l("assistant.ai","expected a supported provider, model and reasoning level"),void 0!==r.maxThreadSize&&(!Number.isInteger(r.maxThreadSize)||r.maxThreadSize<=0)&&l("assistant.ai.maxThreadSize","expected a positive whole number of input tokens"),void 0!==r.voice&&"boolean"!=typeof r.voice&&l("assistant.ai.voice","expected true or false"),void 0!==b.instructions&&"string"!=typeof b.instructions&&l("assistant.instructions","expected a string"),D={instructions:""===b.instructions?null:b.instructions??m.instructions,ai:r}}return{resolved:{...u,fields:O,deletableTypes:u.entityTypes.filter(e=>R.has(e)),writableTypes:u.entityTypes.flatMap(e=>{let t=[...j.get(e)?.values()??[]];return t.length?[{entityType:e,fields:t}]:[]}),optionsEdges:Object.fromEntries(x),childRecipes:E("childRecipes"),replaceRecipes:E("replaceRecipes"),screenshots:Object.fromEntries(u.entityTypes.flatMap(e=>{let t=T.get(e);return t?[[e,t]]:[]})),actionFields:M},settings:D}};

package/dist/domain/application/assistant/session-setup/assistant-setup-manifest.d.ts

@@ -0,0 +1,48 @@
+import type { AssistantAiSettings } from '@salsita-ai/contracts/assistant';
+import type { $DomainEntity, ActionTypes, DomainEntity } from '../../../core/index.js';
+import type { AssistantResolvedManifest } from '../../../spec/index.js';
+/** Declaration-shaped whitelist a project may narrow; bindings and hints stay internal. */
+export interface AssistantSetupManifest<ENTITIES extends DomainEntity<string> = DomainEntity<string>, $MAP extends Record<keyof $MAP, $DomainEntity<ENTITIES>> = Record<string, $DomainEntity<ENTITIES>>, ACTIONS extends ActionTypes = ActionTypes> {
+    readonly entities: string extends keyof $MAP ? Readonly<Record<string, Readonly<Record<string, AssistantSetupField>>>> : {
+        readonly [TYPE in keyof $MAP]?: Readonly<Partial<Record<Exclude<keyof $MAP[TYPE], 'id' | 'type' | '_raw' | 'meta'>, AssistantSetupField>>>;
+    };
+    readonly deletable: Readonly<Record<string, Readonly<Record<never, never>>>>;
+    readonly writable: string extends ENTITIES['type'] ? Readonly<Record<string, Readonly<Record<string, AssistantSetupWritableField>>>> : {
+        readonly [TYPE in keyof $MAP]?: Readonly<Partial<Record<Exclude<keyof $MAP[TYPE]['_raw'], 'id' | 'type'>, AssistantSetupWritableField>>>;
+    };
+    readonly childRecipes: Readonly<Record<string, AssistantSetupRecipes>>;
+    readonly replaceRecipes: Readonly<Record<string, AssistantSetupRecipes>>;
+    /** The screenshot views under their original entity or alias key, keyed by `agentScreenshot` instance name. */
+    readonly screenshots: Readonly<Record<string, Readonly<Record<string, AssistantSetupField>>>>;
+    readonly actions: {
+        readonly [ACTION in keyof ACTIONS]?: AssistantSetupField;
+    };
+    readonly instructions?: string;
+    readonly ai?: Partial<AssistantAiSettings>;
+}
+/** Optional description override; omission preserves the declaration's effective text. */
+export interface AssistantSetupField {
+    readonly description?: string;
+}
+/** Only stricter validation and disabled dry-runs are configurable. */
+export interface AssistantSetupOptions {
+    readonly validate?: true;
+    readonly allowDryRuns?: false;
+}
+/** Keeping a property also keeps its declared options binding and baseline restrictions. */
+export interface AssistantSetupWritableField {
+    readonly options?: AssistantSetupOptions;
+}
+/** A recipe group's editable description and dry-run restriction. */
+export interface AssistantSetupRecipeGroup {
+    readonly description?: string;
+    readonly allowDryRuns?: false;
+}
+/** Only explicitly declared groups appear, under their original entity or alias key, keyed by instance name. */
+export type AssistantSetupRecipes = Readonly<Record<string, AssistantSetupRecipeGroup>>;
+/** Server settings baseline, kept out of the browser spec. */
+export interface AssistantSetupSettings {
+    readonly instructions?: string | null;
+    readonly ai: AssistantAiSettings;
+}
+export declare const projectAssistantSetupManifest: (resolved: AssistantResolvedManifest, settings: AssistantSetupSettings | null) => AssistantSetupManifest;

package/dist/domain/application/assistant/session-setup/assistant-setup-manifest.js

@@ -0,0 +1 @@
+export const projectAssistantSetupManifest=(e,t)=>{let i=e=>Object.fromEntries(Object.entries(e).map(([e,t])=>[e,Object.fromEntries(t.map(e=>[e.instanceName,{...void 0===e.description?{}:{description:e.description},...!e.dryRuns?{allowDryRuns:!1}:{}}]))])),s=e.declarations;return{entities:Object.fromEntries(Object.entries(s.entities).map(([e,t])=>[e,Object.fromEntries(t.map(e=>[e.source,{...!e.describedByManifest||void 0===e.valueDescription?{}:{description:e.valueDescription}}]))])),deletable:Object.fromEntries(s.deletable.map(e=>[e,{}])),writable:Object.fromEntries(Object.entries(s.writable).map(([e,t])=>[e,Object.fromEntries(Object.entries(t).map(([e,t])=>{let i=Object.values(t.members).find(e=>e.options)?.options?.options;return[e,i?{options:{...i.validate?{validate:!0}:{},...!i.dryRuns?{allowDryRuns:!1}:{}}}:{}]}))])),childRecipes:i(s.childRecipes),replaceRecipes:i(s.replaceRecipes),screenshots:Object.fromEntries(Object.entries(s.screenshots).map(([e,t])=>[e,Object.fromEntries(t.map(({instanceName:e,description:t})=>[e,{description:t}]))])),actions:Object.fromEntries(e.actionFields.map(e=>[e.actionName,void 0===e.description?{}:{description:e.description}])),...t?{instructions:t.instructions??void 0,ai:{...t.ai}}:{}}};

package/dist/domain/application/assistant/session-setup/create-session-assistant.d.ts

@@ -0,0 +1,14 @@
+import type { AssistantManifest, AssistantResolvedManifest } from '../../../spec/index.js';
+import type { AssistantSetupHandlerProps, TypedCreateAssistantSetupHandler } from './AssistantSetupHandler.js';
+/** Session-derived browser manifest; a rejected setup retains its error without exposing the baseline. */
+export interface SessionAssistantSetup {
+    readonly manifest: AssistantManifest | null;
+    readonly error: Error | null;
+}
+interface Props {
+    readonly resolved: AssistantResolvedManifest | null;
+    readonly handler: ReturnType<TypedCreateAssistantSetupHandler<Record<string, unknown>>> | undefined;
+    readonly inputs: AssistantSetupHandlerProps<Record<string, unknown>>['inputs'] | null;
+}
+export declare const createSessionAssistant: ({ resolved, handler, inputs }: Props) => SessionAssistantSetup;
+export {};

package/dist/domain/application/assistant/session-setup/create-session-assistant.js

@@ -0,0 +1 @@
+import{buildAssistantManifest as r}from"../build-assistant-manifest.js";import{applyAssistantSetup as n}from"./apply-assistant-setup.js";import{projectAssistantSetupManifest as t}from"./assistant-setup-manifest.js";export const createSessionAssistant=({resolved:e,handler:s,inputs:l})=>{if(!e)return{manifest:null,error:null};try{if(!s)return{manifest:r(e),error:null};if(!l)return{manifest:null,error:null};let i=n(e,null,s.handler().handler({manifest:t(e,null),inputs:l}));return{manifest:i?r(i.resolved):null,error:null}}catch(r){return{manifest:null,error:r instanceof Error?r:Error(String(r))}}};

package/dist/domain/application/assistant/session-setup/index.d.ts

@@ -0,0 +1,4 @@
+export * from './assistant-setup-manifest.js';
+export * from './AssistantSetupHandler.js';
+export { applyAssistantSetup, AssistantSetupError } from './apply-assistant-setup.js';
+export { createSessionAssistant, type SessionAssistantSetup } from './create-session-assistant.js';

package/dist/domain/application/assistant/session-setup/index.js

@@ -0,0 +1 @@
+export*from"./assistant-setup-manifest.js";export*from"./AssistantSetupHandler.js";export{applyAssistantSetup,AssistantSetupError}from"./apply-assistant-setup.js";export{createSessionAssistant}from"./create-session-assistant.js";

package/dist/domain/application/assistant-field-options.d.ts

@@ -1,6 +1,5 @@
-import type { DomainEntity, DomainEntityId } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
-import type { AssistantFieldOptions, AssistantManifest } from './application-config.js';
+import type { DomainEntity, DomainEntityId, DomainState } from '../core/index.js';
+import type { AssistantFieldOptions, AssistantManifest } from '../spec/index.js';
 import type { AssistantRecipeContext } from './assistant-recipe-groups.js';
 type AnyDomainState = DomainState<DomainEntity<string>>;
 /**

package/dist/domain/application/assistant-mutations.d.ts

@@ -1,9 +1,7 @@
 import type { Localizable } from '@salsita-ai/common/utils';
-import { type StateUpdate } from '../components/updates.js';
-import type { AnyActionContext } from '../core/action.js';
-import { type DomainEntity } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
-import type { AssistantManifest } from './application-config.js';
+import { type DomainEntity, type DomainState, type StateUpdate } from '../core/index.js';
+import type { AnyActionContext } from '../domain-runtime/index.js';
+import type { AssistantManifest } from '../spec/index.js';
 type AnyDomainState = DomainState<DomainEntity<string>>;
 /**
  * Update tag of user-intended entity deletions, from the configurator's delete controls and the