@salsita-ai/sdk 0.50.0-develop.be40f0cee8 → 0.50.0-develop.d81d7591c5

package/dist/docs/phoenix/phoenix-cli.mdx

@@ -491,6 +491,85 @@ phoenix screenshot -o preview.png -w 1920 --height 1080
 | `--height`        | `1080`  | Image height in pixels         |
 | `--format` / `-f` | `png`   | Image format (`png` or `jpeg`) |
 
+### `phoenix variants`
+
+Show several options over the configurator and wait for your pick. It is built for coding agents: when a decision is a matter of taste, such as the edge of a table top, how glossy a finish is or where a control sits, the agent writes one file per option, you choose in the browser, and the command hands your answer back to the agent.
+
+```bash
+phoenix variants .phoenix/variants/table-edge --title 'Which edge suits the table?' --description 'Only the edge of the top differs.'
+```
+
+Every `<id>.variant.js` script or `<id>.html` page in the folder is one option, shown in file-name order. Each script edits frontend project files on top of the same captured baseline. Original is always the first choice and restores that baseline. Switching options removes the previous option's edits and applies the selected script; the editor dialog has any number of choices on the left and your already loaded configurator on the right.
+
+```js
+// .phoenix/variants/brand/blue.variant.js
+export const title = 'Blue brand'
+export const description = 'A blue primary colour with the current layout.'
+
+export default ({ read, write, remove }) => {
+  const file = 'src/handlers/theme.ts'
+  write(file, read(file).replace("main: '#E93335'", "main: '#2364aa'"))
+}
+```
+
+`read(path)` always reads the baseline. `write(path, contents)` replaces or creates a file; `remove(path)` deletes it. Scripts run in the browser and collect edits; Phoenix validates and writes the batch locally. Supported files are YAML under `spec/` outside `spec/admin/`, and TypeScript under `src/components`, `transformers`, `handlers`, `elements` and `_`-prefixed shared folders. Expressions, actions and invariants also run on the server, so a script cannot edit them.
+
+For standalone UI or branding proposals, write self-contained HTML files. Each page renders in its own iframe when selected; its `<title>` names the option and `<meta name="description" content="...">` describes it. HTML and scripts may share a set if their file names give distinct option ids.
+
+```html
+<!-- .phoenix/variants/brand/blue.html -->
+<!doctype html>
+<title>Blue studio</title>
+<meta name="description" content="A calm blue identity with generous spacing." />
+<style>
+  body {
+    margin: 0;
+    padding: 40px;
+    background: #f0f5fa;
+    color: #163b66;
+    font-family: sans-serif;
+  }
+</style>
+<h1>Made for your everyday.</h1>
+<button>Design your table</button>
+```
+
+Scripts run once per selection. The completed file batch calls the existing rebuild queue directly, without a separate file-change event stream or a watcher that reapplies the option.
+
+Use script options for controls, layout, brand, lights, visual effects, materials, positions, components, elements and transformers. Changes to the model, schemas, data or deployment settings are rejected before any files are written. Environment files, webhooks, their shared implementation dependencies, dependencies and uploaded assets cannot be overridden. Files connected through symbolic links are also excluded, so restoring the baseline preserves the original files. No server preparation or webhook rebuild runs for a variant transaction.
+
+Picking a script keeps its exact implementation in the project. Picking an HTML page returns the selected proposal for the agent to implement; the page itself changes no project source files. Choosing Original keeps the captured baseline. Users finish by confirming Original or another option. Escape stays available to the configurator, and clicking the backdrop leaves the comparison open. The agent can use `--close` to restore the baseline source files without giving an answer. Phoenix records recovery information on disk and restores interrupted previews at the next `phoenix dev` start. It never overwrites a file edited outside the preview: switching options over such an edit is refused, and when the comparison ends, or is restored at the next start, that file is left as it is with a warning in the dev log while the others are restored. Other source changes made while a comparison is open are rebuilt once it ends.
+
+Answers are held for four seconds with Undo and Send now.
+
+The command prints the outcome as JSON. After `chosen` it removes the folder:
+
+| `status`  | Meaning                                                                                                                                      |
+| --------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `chosen`  | An option was picked: `choice` is its id, or `null` for Original; `label` is its name.                                                       |
+| `waiting` | The wait ran out. The preview stays open: the same command attaches to it again, and an answer given in between is returned by the next run. |
+| `closed`  | The preview was closed without an answer, by `--close` or by another set of options taking its place. The folder is kept.                    |
+
+| Flag                   | Default                       | Description                                               |
+| ---------------------- | ----------------------------- | --------------------------------------------------------- |
+| `--title` / `-t`       | `Which option do you prefer?` | Question shown above the options                          |
+| `--description` / `-d` | —                             | A line saying what differs between the options            |
+| `--timeout`            | `540`                         | Seconds to wait for the answer                            |
+| `--keep`               | `false`                       | Keep the folder after the answer                          |
+| `--close`              | `false`                       | Close the open preview without an answer; needs no folder |
+| `--port` / `-p`        | `3020`                        | Editor WebSocket port                                     |
+
+Known limits:
+
+- Variant transactions start rebuilding immediately, bypassing the normal file-watcher debounce. Hot reload still needs to parse and apply the updated implementation. There is no wait for UI or scene loading to settle; allow a visible transition to finish before judging or choosing.
+- Only one option is displayed at a time; simultaneous comparison is not supported.
+- For script options and Original, the dialog moves the existing configurator into the preview and returns it on close, preserving the loaded scene, camera and UI state. Opening the dialog starts no second application or initial loading screen. Configuration interactions still change the current configuration; restoring source files does not undo them.
+- Custom scripts are trusted project code. Their file API stages edits; scripts must not make network requests or other side effects.
+- Binary assets, CSS files, locale catalog changes, dependency changes and edits requiring a full application restart are unsupported.
+- Storybook `story-dev` has no variant previews. A project on the legacy pipeline has no variant previews; the command says so and exits.
+
+Generated projects carry the `phoenix-variants` agent skill, which tells coding agents when to offer options, how to write each kind and what to do with your answer.
+
 ## SDK Development
 
 ### `phoenix link`
@@ -603,7 +682,7 @@ SDK-builder workspaces sign the CLI in with a personal API token instead of proj
 
 Signs the CLI in to the SDK-builder workspace `<customer>`:
 
-1. Opens Studio, where you name the token and approve the sign-in (use `--no-open` to only print the link). The page shows the workspace, your account, the computer the CLI runs on and how long the link still works. The CLI suggests the name `phoenix CLI on <computer>`; change it so you can tell your machines and agents apart later.
+1. Opens Studio, where you name the token and approve the sign-in (use `--no-open` to only print the link). Only a super admin of the workspace can open its Studio, so only a super admin can sign the CLI in. The page shows the workspace, your account, the computer the CLI runs on and how long the link still works. The CLI suggests the name `phoenix CLI on <computer>`; change it so you can tell your machines and agents apart later.
 2. Studio sends a one-time code back to the CLI on `127.0.0.1`.
 3. The CLI exchanges the code for a token with the name you approved, and sends the browser back to Studio, which confirms the sign-in.
 
@@ -628,7 +707,7 @@ Revokes the token on the server and removes it from the credentials file. `--reg
 
 ### `phoenix deploy`
 
-Validates the spec, adds the pnpm settings `phoenix init` writes to `pnpm-workspace.yaml` when they are missing, packs and uploads the project, starts its build on the server and follows it until the configurator is live. Before the upload the server compares the domain model with the deployed one: a model that changed under an already deployed model version is refused with the reason, and needs a new model version and a [migration](?path=/docs/phoenix-migrations--docs). Once the build starts it prints `Follow the build in Studio: <url>`, the build's page in the Studio you signed in through; a sign-in stored by an older CLI has no Studio URL, so sign in again to get the link. `--region` or `--serverUrl` selects the server, as for `login`; `--no-wait` returns as soon as the build starts.
+Validates the spec, adds the pnpm settings `phoenix init` writes to `pnpm-workspace.yaml` when they are missing, packs and uploads the project, starts its build on the server and follows it until the configurator is live. Before the upload the server compares the domain model with the deployed one: a model that changed under an already deployed model version is refused with the reason, and needs a new model version and a [migration](?path=/docs/phoenix-migrations--docs). Once the build starts it prints `Follow the build in Studio: <url>`, the build's page in the Studio you signed in through; a sign-in stored by an older CLI has no Studio URL, so sign in again to get the link. After `Your configurator is live at <url>` it prints one line for coding agents, which tells them to offer the run evaluation of the `phoenix-feedback` skill once you have nothing more to build; you can ignore it when you run the command yourself. `--region` or `--serverUrl` selects the server, as for `login`; `--no-wait` returns as soon as the build starts.
 
 ### `phoenix feedback [message]`
 

package/dist/docs/phoenix/project-structure.mdx

@@ -49,6 +49,12 @@ project-root/
 | `locales/`      | Locale catalogs (`.po` sources; compiled `.ts`, do not edit)           |
 | `_*`            | Shared code folders at any depth (not auto-imported)                   |
 
+Every file in `components/`, `elements/`, `expressions/`, `actions/`, `invariants/`, `transformers/` and `handlers/`
+(and their `admin/` counterparts) is imported by its location, so its default export must be what that folder's `phx`
+factory returns, or an array of those. A file that exports anything else, such as a plain React component in
+`elements/`, stops the application at start with an `Invalid default export in <file>` error that names the expected
+shape. Keep plain components and helpers in a `_*` folder.
+
 ### Admin Folders (src/admin/)
 
 The `admin/` folder supports these admin-specific categories:
@@ -189,7 +195,7 @@ type CustomMaterial = Phx['AdminModel']['CustomMaterial']
 
 ### DO NOT EDIT (Fully Auto-Generated)
 
-- **Everything in `.phoenix/`** - Completely regenerated on each build
+- **Everything in `.phoenix/`** - Completely regenerated on each build. The one exception is `.phoenix/variants/`, where a coding agent writes the option files for `phoenix variants`; a rebuild keeps it
 - `tsconfig.json`, `eslint.config.js`, `prettier.config.js`, `.prettierignore`
 - `.linguirc`, `.nvmrc`
 - `src/locales/**/*.ts` - Compiled from `.po` catalogs
@@ -198,7 +204,7 @@ type CustomMaterial = Phx['AdminModel']['CustomMaterial']
 
 ### Agent Guidance
 
-Coding agents (Claude Code, Codex, Cursor) read `AGENTS.md` and the Phoenix agent skills. `AGENTS.md` is written once with the build commands, the do-not-edit list and a pointer to the skills; after that it is yours. The `phoenix`, `phoenix-cli`, `phoenix-feedback` and `phoenix-review` skills carry the SDK conventions, CLI tooling and review checklist, and the `phoenix-create-configurator` skill walks the agent from your product documents and assets to a reviewed configurator in five stages. Phoenix keeps them in step with the installed SDK, including the reference files inside a skill folder. During the internal beta, a project created from a canary build of the SDK gets one more section in the `phoenix` skill: once per conversation the agent checks for a newer canary and, after telling you, updates the project's SDK and runs `phoenix sync`. Other skill folders are never touched.
+Coding agents (Claude Code, Codex, Cursor) read `AGENTS.md` and the Phoenix agent skills. `AGENTS.md` is written once with the build commands, the do-not-edit list and a pointer to the skills; after that it is yours. The `phoenix`, `phoenix-cli`, `phoenix-feedback` and `phoenix-review` skills carry the SDK conventions, CLI tooling and review checklist, and the `phoenix-create-configurator` skill walks the agent from your product documents and assets to a reviewed configurator in five stages. The `phoenix-variants` skill has the agent show you several options over the dev preview when a decision is a matter of taste, and build the one you pick. Phoenix keeps them in step with the installed SDK, including the reference files inside a skill folder. During the internal beta, a project created from a canary build of the SDK gets one more section in the `phoenix` skill: once per conversation the agent checks for a newer canary and, after telling you, updates the project's SDK and runs `phoenix sync`. Other skill folders are never touched.
 
 Projects created by earlier SDK versions had this guidance in `CLAUDE.md`, `.cursor/rules/phoenix.mdc` and `commands/review.md`. Sync removes the SDK block from the first two, keeps your own text around it, deletes a file that held nothing else, and deletes the review commands; use the `phoenix-review` skill instead of `/review`.
 
@@ -316,6 +322,7 @@ project-root/
 │   │   └── builders.ts
 │   ├── .swc/                      # SWC transpiled sources
 │   ├── .lingui/                   # Compiled i18n catalogs
+│   ├── variants/                  # Option files of `phoenix variants`, written by coding agents
 │   ├── dist/                      # Build output
 │   │   ├── frontend/              # Frontend bundles
 │   │   └── webhooks/              # Webhook bundles

package/dist/docs/phoenix/sdk-builder-workflow.mdx

@@ -36,7 +36,7 @@ The starter `spec/application.yaml` begins with `project: default`, which means
 pnpm phoenix login <workspace>
 ```
 
-`phoenix login` opens Studio, where you name the token and approve the sign-in. The CLI suggests `phoenix CLI on <computer>`; a name of your own, such as the agent and the machine, tells your tokens apart later. Studio sends a one-time code back to the CLI on `127.0.0.1`, the CLI exchanges it for a personal token and returns the browser to Studio, which confirms the sign-in. The code only works for the CLI that asked for it and expires after five minutes. **Deny** stops the waiting CLI at once and creates no token. Use `--no-open` to print the link instead of opening a browser.
+`phoenix login` opens Studio, where you name the token and approve the sign-in. Only a super admin of the workspace can open Studio, so only a super admin can approve it. The CLI suggests `phoenix CLI on <computer>`; a name of your own, such as the agent and the machine, tells your tokens apart later. Studio sends a one-time code back to the CLI on `127.0.0.1`, the CLI exchanges it for a personal token and returns the browser to Studio, which confirms the sign-in. The code only works for the CLI that asked for it and expires after five minutes. **Deny** stops the waiting CLI at once and creates no token. Use `--no-open` to print the link instead of opening a browser.
 
 The CLI stores the token in `~/.phoenix/credentials.json`, readable only by you, with one entry per server. `PHOENIX_CREDENTIALS_FILE` moves the file. The token acts for you in your workspace until you revoke it. It stops working when you are removed from the workspace or banned.
 
@@ -59,7 +59,7 @@ pnpm phoenix dev
 
 Signed in, `phoenix dev` needs no `.env` and nothing set up in Studio. When it starts, it asks the server for your development environment in the project the spec names. The server creates that environment the first time and finds it again on every later run. `phoenix dev` prints the workspace, project and environment it works in, prepares a development deployment there and opens the webhook tunnel, as for any Phoenix project (see [Phoenix CLI](?path=/docs/phoenix-phoenix-cli--docs)). It then prints the address of the preview as `Preview: <url>`; the preview talks to the server the deployment was prepared on.
 
-Every user of the workspace gets their own development environment, so a teammate who clones the project and signs in doesn't overwrite your schema or take over your webhooks. The development environment is separate from `production`: nothing you do in `phoenix dev` changes the live configurator.
+Every user who signs the CLI in gets their own development environment, so a teammate (a super admin of the workspace, like you) who clones the project and signs in doesn't overwrite your schema or take over your webhooks. The development environment is separate from `production`: nothing you do in `phoenix dev` changes the live configurator.
 
 `pnpm dev:local` still runs the project without any server, with state kept in the browser.
 
@@ -107,4 +107,5 @@ Coding agents working in your project use the same command, guided by the genera
 - `phoenix deploy` always deploys to the workspace's default project; it doesn't read `project` from the spec yet.
 - Only `phoenix dev` works from the sign-in. `phoenix deployment:prepare-dev` still needs the `.env` block of a Studio development environment.
 - Every deploy uploads the whole project; there are no incremental uploads.
-- Your own environment variables can't use platform names such as `LAMBDA_FUNCTION_NAME` or the `AWS_` prefix. A deploy that sets them fails before it registers.
+- Your own environment variables are set in Studio under Environment, by a super admin of the workspace, and apply from the next deploy. `phoenix dev` doesn't receive them: your development environment has its own variables. A build reads them from `process.env`; a webhook reads the ones the spec declares under `env.webhook`, through `phx.webhooksEnv` (see [Webhooks](?path=/docs/phoenix-webhooks--docs)). They can't use platform names such as `LAMBDA_FUNCTION_NAME`, the `AWS_` prefix, the identity provider settings such as `CLERK_API_KEY`, or names the CLI and the deploy tooling read themselves, such as `SERVER_URL` or `NODE_OPTIONS`; Studio refuses those names.
+- Only super admins of a workspace can open its Studio. Admins and users see a page that says so.

package/dist/docs/recipes-and-delete/recipe-hierarchy-selection.mdx

@@ -160,21 +160,23 @@ Room: {
 
 ### Entity Replacement Transformer
 
-Configure transformers to handle entity deselection when replacement occurs. This ensures clean state transitions:
+Add a transformer to handle entity deselection when replacement occurs. This ensures clean state transitions:
 
 ```typescript
-const config = configuratorBuilder
-  .withTransformers(ctx => {
-    return [
-      phx.frontend.transformerBuilder.when
-        .entity(['RedSpecialConsole', 'BlueSpecialConsole'])
-        .replacedWith(['RedSpecialConsole', 'BlueSpecialConsole'])
-        .then.deselect()
-        .build('Deselect special console on replacement')
-        .register(ctx),
-    ]
-  })
-  .buildConfig()
+// src/transformers/deselect-special.ts
+export default phx.frontend.transformerBuilder.when
+  .entity(['RedSpecialConsole', 'BlueSpecialConsole'])
+  .replacedWith(['RedSpecialConsole', 'BlueSpecialConsole'])
+  .then.deselect()
+  .build('deselect-special')
+```
+
+Each file in `src/transformers/` default-exports one transformer and is picked up by its location. The `transformers` section of the spec turns it on by name. For a transformer made with `build(name)` that is the name passed to `build(...)`, which must match the file name with case and dashes ignored (`fix-finish.ts` and `fixFinish` match). For a plain-function export it is the file name:
+
+```yaml
+# spec/application.yaml
+transformers:
+  - name: deselect-special
 ```
 
 ### Initial Configuration

package/dist/docs/relations/hierarchy.mdx

@@ -69,8 +69,19 @@ relations:
 
 Consider enabling select-parent-on-deselection to keep selection stable:
 
-```ts
-.withTransformers(ctx => [{ priority: 101, transformer: createSelectParentOnDeselectionTransformer(ctx) }])
+```typescript
+// src/transformers/select-parent.ts
+import { createSelectParentOnDeselectionTransformer } from '@salsita-ai/sdk/domain'
+
+export default createSelectParentOnDeselectionTransformer
+```
+
+Each file in `src/transformers/` default-exports one transformer and is picked up by its location. The `transformers` section of the spec turns it on by name. For a transformer made with `build(name)` that is the name passed to `build(...)`, which must match the file name with case and dashes ignored (`fix-finish.ts` and `fixFinish` match). For a plain-function export it is the file name:
+
+```yaml
+# spec/application.yaml
+transformers:
+  - name: select-parent
 ```
 
 ## Example

package/dist/domain/actions/action-factory.d.ts

@@ -4,7 +4,8 @@ import type { $DomainEntity, DomainEntity } from '../core/model.js';
  * Creates the `implementActions` factory the generated `domain-spec.ts` exposes as
  * `phx.domain.implementActions`. A module in `src/actions/` implements any subset of the declared
  * actions and gets each parameter and result typed from the spec; a name the spec does not declare
- * is a type error, since its implementation would have to be `never`. The generated barrel merges
- * the modules and checks that every declared action is implemented.
+ * is a type error, since its implementation would have to be `never`. The generated barrel lists
+ * the modules; `DomainBuilder.withActionModules` merges them, and domain initialization checks that
+ * every declared action is implemented.
  */
 export declare const createActionFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, NAVIGATION_STATES extends string, VIEW_STATES extends string, TOOL_STATES extends string, EXPORT_STATES extends string, ACTION_TYPES extends ActionTypes>() => <IMPLEMENTATIONS extends Partial<ActionImplementations<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES, ACTION_TYPES>>>(implementations: IMPLEMENTATIONS & Readonly<Record<Exclude<keyof IMPLEMENTATIONS, keyof ACTION_TYPES>, never>>) => IMPLEMENTATIONS;

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

@@ -6,12 +6,11 @@ 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 { $DomainEntity, DomainEntity, DomainFactory, ProductPreset } from '../core/index.js';
+import type { AnalyticsSystem, TransformerFactory } 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 { ProjectModule } from '../project-modules/index.js';
+import type { AssistantResolvedManifest } from './assistant/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> = {
@@ -22,6 +21,17 @@ export type SpecTransformer = {
     name: string;
     priority?: number;
 };
+/**
+ * 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 interface DataSchemaPrimitiveField {
     readonly type: 'string' | 'number' | 'integer' | 'boolean';
     readonly enum?: ReadonlyArray<string | number>;
@@ -64,67 +74,6 @@ export type DataSpec = {
 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.
- */
-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;
@@ -171,9 +120,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 +303,14 @@ 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[];
     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-manifest.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+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 rebuilt from the resolved manifest; `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>>;
+}

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

@@ -0,0 +1,95 @@
+import type { AssistantFieldOptions, AssistantRecipeGroup } from './assistant-manifest.js';
+/** JSON description of a scalar or recursively nested list, including nullability at each level. */
+export type AssistantValueType = {
+    readonly kind: 'scalar';
+    readonly name: 'Int' | 'Float' | 'String' | 'Boolean' | 'ID' | 'JSON';
+    readonly nonNull: boolean;
+} | {
+    readonly kind: 'list';
+    readonly item: AssistantValueType;
+    readonly nonNull: boolean;
+};
+/** A relation edge resolved against the model at parse time, linked to GraphQL types only during building. */
+export interface AssistantRelationType {
+    readonly kind: 'edge';
+    readonly target: string;
+    readonly cardinality: '1-1' | '0-1' | '0-N' | '1-N';
+}
+/** A field's source and resolved type, carried in the application bundle without GraphQL instances. */
+export interface AssistantResolvedField {
+    readonly name: string;
+    readonly source: string;
+    readonly type: {
+        readonly kind: 'value';
+        readonly type: AssistantValueType;
+    } | AssistantRelationType;
+    readonly localized: boolean;
+    readonly description?: string;
+}
+/** Declared UI state values used to describe the navigation query. */
+export interface AssistantStates {
+    readonly navigationStates: readonly string[];
+    readonly viewStates: readonly string[];
+    readonly toolStates: readonly string[];
+}
+/** Serializable resolved whitelist from which the browser or backend constructs the assistant schema. */
+export interface AssistantResolvedManifest {
+    readonly entityTypes: readonly string[];
+    readonly aliases: Readonly<Record<string, readonly string[]>>;
+    readonly exampleType?: string;
+    readonly fields: Readonly<Record<string, readonly AssistantResolvedField[]>>;
+    readonly states: AssistantStates;
+    readonly deletableTypes: readonly string[];
+    readonly writableTypes: readonly AssistantWritableType[];
+    readonly childRecipes: Readonly<Record<string, AssistantResolvedRecipes>>;
+    readonly replaceRecipes: Readonly<Record<string, AssistantResolvedRecipes>>;
+    readonly optionsEdges: Readonly<Record<string, readonly AssistantResolvedOptionsEdge[]>>;
+    readonly actionFields: readonly AssistantResolvedAction[];
+}
+/** Optional mutation input for one stored field, using its exposed name. */
+export interface AssistantWritableField {
+    readonly name: string;
+    readonly property: string;
+    readonly type: AssistantValueType;
+    readonly description?: string;
+}
+/** One entity type's writable fields, in manifest order. */
+export interface AssistantWritableType {
+    readonly entityType: string;
+    readonly fields: readonly AssistantWritableField[];
+}
+/** Description hints resolved from recipe/option entries; no parse context is retained. */
+export type AssistantResolvedHint = 'sameForAllInstances' | 'constantDuringSession';
+/** Recipe groups and their description hints for one entity type. */
+export interface AssistantResolvedRecipes {
+    readonly groups: readonly AssistantRecipeGroup[];
+    readonly hints: readonly AssistantResolvedHint[];
+}
+/** One options edge, carrying the write-validation contract and schema description hints. */
+export interface AssistantResolvedOptionsEdge {
+    readonly options: AssistantFieldOptions;
+    readonly hints: readonly AssistantResolvedHint[];
+}
+/** An action result field, either an entity edge or a plain JSON-described value. */
+export type AssistantResolvedActionResult = {
+    readonly kind: 'edge';
+    readonly target: string;
+    readonly list: boolean;
+    readonly nullable: boolean;
+    readonly description?: string;
+} | {
+    readonly kind: 'value';
+    readonly type: AssistantValueType;
+    readonly description?: string;
+};
+/** A custom mutation resolved against the declared action, independent of its implementation. */
+export interface AssistantResolvedAction {
+    readonly fieldName: string;
+    readonly actionName: string;
+    readonly description?: string;
+    readonly args: Readonly<Record<string, {
+        readonly type: AssistantValueType;
+        readonly description?: string;
+    }>>;
+    readonly result: Readonly<Record<string, AssistantResolvedActionResult>>;
+}

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 './assistant-resolved-manifest.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 t,GraphQLID as a,GraphQLInt as n,GraphQLList as r,GraphQLNonNull as l,GraphQLScalarType as s,GraphQLString as i}from"graphql";export const GraphQLJSON=new s({name:"JSON",description:"Any JSON value, returned as stored. Always plain serializable data."});let o={Int:n,Float:t,String:i,Boolean:e,ID:a,JSON:GraphQLJSON};export const createAssistantValueType=e=>{let t="list"===e.kind?new r(createAssistantValueType(e.item)):o[e.name];return e.nonNull?new l(t):t};

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

@@ -0,0 +1,4 @@
+import type { AssistantManifest } from './assistant-manifest.js';
+import type { AssistantResolvedManifest } from './assistant-resolved-manifest.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,GraphQLID as t,GraphQLInputObjectType as n,GraphQLInterfaceType as i,GraphQLList as o,GraphQLNonNull as r,GraphQLObjectType as s,GraphQLSchema as a,GraphQLString as p,printSchema as d,validateSchema as h}from"graphql";import{GraphQLJSON as c,createAssistantValueType as l}from"./assistant-value-type.js";let y="AnyDomainEntity",u="RootEntity",f={section:"childRecipes",mutation:"addChild"},g={section:"replaceRecipes",mutation:"replaceEntity"},w=(e,t)=>Object.entries(e).find(([e])=>e===t)?.[1],m=(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},b=({target:e,cardinality:t},n)=>{let i=n(e);switch(t){case"1-1":return new r(i);case"0-1":return i;case"0-N":case"1-N":return new r(new o(new r(i)))}},v=(e,n,i)=>{let o={id:{type:new r(t),description:i?`Unique id of the entity, e.g. "${i}-1".`:void 0},type:{type:new r(p),description:i?`Entity type name, e.g. "${i}".`:void 0}};for(let t of e)o[t.name]={type:"edge"===t.type.kind?b(t.type,n):l(t.type.type),description:t.description};return o},$=e=>Object.fromEntries(e.map(({name:e,source:t,localized:n})=>[e,n?{source:t,localized:!0}:{source:t}])),j={sameForAllInstances:e=>`All ${e} instances have the same recipe groups and recipes.`,constantDuringSession:()=>"They do not change during the session."},O={sameForAllInstances:e=>`All ${e} instances have the same options.`,constantDuringSession:()=>"The options do not change during the session."},E=(e,t,n)=>e.map(e=>` ${t[e](n)}`).join(""),R=({section:e},{groups:t,hints:n},{entityType:i,purpose:s,recipeGroup:a})=>{let p=t.filter(({dryRuns:e})=>!e).map(({groupId:e})=>e);return 0===t.length?{}:{[e]:{type:new r(new o(new r(a))),description:`The recipe groups for ${s} this ${i}: ${t.map(({groupId:e})=>e).join(", ")}. A group is listed only while the configurator offers it on the entity.${p.length>0?` Recipes of these groups cannot be dry-run: ${p.join(", ")}.`:""}${E(n,j,i)}`}}},k=({entityType:e,childRecipes:t,replaceRecipes:n,optionsEdges:i},{recipeGroup:a,fieldOption:p})=>new s({name:`${e}Meta`,fields:Object.assign(R(f,t,{entityType:e,purpose:"adding children to",recipeGroup:a}),R(g,n,{entityType:e,purpose:"replacing",recipeGroup:a}),...i.map(({options:{edgeName:t,field:n,validate:i,dryRuns:s},hints:a})=>({[t]:{type:new o(new r(p)),description:`The values "${n}" of this ${e} can take, as the configurator offers them in the current state of the entity. Null when the configurator does not offer a choice on this entity. ${i?`modify${e} rejects a "${n}" value that is not in the list.`:`modify${e} does not check "${n}" against the list.`}${s?"":" Its options cannot be dry-run."}${E(a,O,e)}`}})))}),I=e=>Object.entries(e).map(([e,t])=>`${e} (${t.map(({groupId:e})=>e).join(", ")})`);export const buildAssistantManifest=b=>{var j,O,E,R,T;let A,N,D,M,{entityTypes:S,aliases:q,exampleType:W,fields:C,states:G,deletableTypes:K,writableTypes:U,actionFields:F,optionsEdges:x}=b,z=Object.fromEntries(Object.entries(b.childRecipes).map(([e,t])=>[e,t.groups])),Q=Object.fromEntries(Object.entries(b.replaceRecipes).map(([e,t])=>[e,t.groups])),B=new Map,H=new Map,J=new Map,L=e=>{let[t,...n]=Object.entries(q).find(([t])=>t===e)?.[1]??[];return(t&&0===n.length?H.get(t):void 0)??J.get(e)??V},P=e=>H.get(e)??L(e),V=new i({name:y,description:"Every domain entity.",fields:()=>v(C[y]??[],P,W)});for(let e of(J.set(y,V),Object.keys(q)))e!==y&&J.set(e,new i({name:e,interfaces:[V],fields:()=>v(C[e]??[],P)}));let X={};for(let e of S){let t=[y,...Object.entries(q).filter(([t,n])=>t!==y&&n.includes(e)).map(([e])=>e)],n=C[e]??[];X[e]=$(n),H.set(e,new s({name:e,interfaces:t.flatMap(e=>J.get(e)??[]),fields:()=>{let t=B.get(e);return{...v(n,P),...t?{meta:{type:new r(t),description:"What the configurator offers on this entity besides its fields."}}:{}}}}))}let Y=(j=()=>L(J.has(u)?u:y),O=()=>L(y),A=new s({name:"DryRunError",description:"One reason a change cannot be made right now.",fields:{type:{type:new r(p),description:'Kind of the problem, or "uncaught".'},entityId:{type:t,description:"The entity the problem is on, when it is on one."},message:{type:p,description:"The problem as the configurator words it for the user."}}}),new s({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 r(e),description:"Whether the change would succeed on the configuration the query reads."},root:{type:j(),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 r(new o(new r(O()))),description:"Every entity the change would add or modify, read from that configuration; empty when ok is false. An entity whose id the configuration does not have yet would be added, and its id may differ in the real mutation. An entity that is written to is listed even when it gets the values it already has."},deletedEntityIds:{type:new r(new o(new r(t))),description:"The ids of the entities the change would remove; empty when ok is false."},sideEffects:{type:new r(new o(new r(p))),description:"What the configurator would do beyond the change itself, such as parts it would add or replace, in its own words; empty when ok is false."},errors:{type:new r(new o(new r(A))),description:"Why the change cannot be made; empty when ok is true."}})})),Z={recipeGroup:(E=[...Object.keys(z).length>0?[f.mutation]:[],...Object.keys(Q).length>0?[g.mutation]:[]],N=E.join(" or "),D=new s({name:"Recipe",description:"One recipe of a recipe group: something that can be added to the entity, or something the entity can be replaced with, depending on the edge the group is listed under.",fields:{key:{type:new r(p),description:`Identifies the recipe within its group; pass it to ${N} as recipeKey. Keys can change with the configuration and with the language, so read them from the listing rather than remembering them.`},name:{type:new r(p),description:"Name shown to the user."},description:{type:p},imageUrl:{type:p,description:"Thumbnail shown to the user."},dryRun:{type:Y,description:"Tries the recipe out. Each selected dry-run costs a full recalculation, so select it only on the recipes you are deciding between. Null for a group whose recipes cannot be dry-run."}}}),new s({name:"RecipeGroup",description:"A group of recipes of an entity, as the configurator offers them to the user.",fields:{groupId:{type:new r(p),description:`Identifies the group on its entity; pass it to ${N} as recipeGroupId.`},name:{type:new r(p),description:"Name shown to the user."},description:{type:p},recipes:{type:new r(new o(new r(D)))}}})),fieldOption:new s({name:"FieldOption",description:"One choice of a field, as the configurator offers it to the user.",fields:{value:{type:new r(c),description:"The value to write to the field."},name:{type:p,description:"Name shown to the user."},description:{type:p},imageUrl:{type:p,description:"Image shown to the user."},color:{type:p,description:'Color shown to the user, as "#rrggbb".'},dryRun:{type:Y,description:"Tries writing the value to the field. Each selected dry-run costs a full recalculation, so select it only on the options you are deciding between. Null for a field whose options cannot be dry-run."}}})};for(let e of S){let t=w(b.childRecipes,e)??{groups:[],hints:[]},n=w(b.replaceRecipes,e)??{groups:[],hints:[]},i=w(x,e)??[];(t.groups.length>0||n.groups.length>0||i.length>0)&&B.set(e,k({entityType:e,childRecipes:t,replaceRecipes:n,optionsEdges:i},Z))}let _=new a({query:(R=L(J.has(u)?u:y),T=L(y),M=(e=>{let t={};for(let[n,i,o]of[["navigationState","Active navigation state.",e.navigationStates],["viewState","Active view state.",e.viewStates],["toolState","Active tool state.",e.toolStates]])o.length>1&&(t[n]={type:new r(p),description:m(i,o)});if(0!==Object.keys(t).length)return new s({name:"Navigation",description:"The active UI states of the configurator.",fields:t})})(G),new s({name:"Query",fields:{root:{type:new r(R),description:"The root entity of the configuration."},entities:{type:new r(new o(T)),args:{ids:{type:new o(new r(t))}},description:`Every entity of the configuration, or, when ids are given, those entities in the same order with null for an unknown id. Ids have the form "<Type>-<number>"${W?`, e.g. "${W}-1"`:""}; any other id is an error.`},selectedEntity:{type:new r(T),description:"The selected entity, or the root entity when nothing is selected."},...M?{navigation:{type:new r(M)}}:{}}})),mutation:(({deletableTypes:e,writableTypes:i,childRecipes:a,replaceRecipes:d,actionFields:h,objectTypes:c,anyDomainEntity:y,targetOutputType:u})=>{let f,g;if(0!==e.length||0!==i.length||0!==Object.keys(a).length||0!==Object.keys(d).length||0!==h.length)return new s({name:"Mutation",fields:Object.assign(0===e.length?{}:{deleteEntity:{type:new r(new o(new r(t))),args:{id:{type:new r(t)}},description:`Deletes the entity with the given id, together with the entities composed into it, and returns the ids of every entity the deletion removed, the given one first. Deletable entity types: ${e.join(", ")}. Nothing can be read from removed entities afterwards, so query what you need from them before deleting.`}},0===(f=I(a)).length?{}:{addChild:{type:new r(new o(new r(y))),args:{parentId:{type:new r(t)},recipeGroupId:{type:new r(p)},recipeKey:{type:new r(p)}},description:`Adds a child to the entity with the id parentId by one recipe of one of its recipe groups. Entity types with recipe groups: ${f.join("; ")}. Read the groupId and the recipe key from "meta { childRecipes }" of the parent. Returns every entity the change added, the recipe's own first and then whatever the configurator added in response, such as a part the new child needs; the list is empty when the configurator removed them again.`}},0===(g=I(d)).length?{}:{replaceEntity:{type:new r(new o(new r(y))),args:{entityId:{type:new r(t)},recipeGroupId:{type:new r(p)},recipeKey:{type:new r(p)}},description:`Replaces the entity with the id entityId by one recipe of one of its replace recipe groups. Entity types with replace recipe groups: ${g.join("; ")}. Read the groupId and the recipe key from "meta { replaceRecipes }" of the entity. The replacement is a new entity with a new id: the id passed in no longer exists afterwards, and the replacement has the field values of its recipe, not those of the entity it replaces. Returns every entity the change added, the replacement first and then whatever the configurator added in response, such as a part the replacement needs; the list is empty when the configurator removed them again.`}},...i.flatMap(e=>{let i=c.get(e.entityType);return i?[(({entityType:e,fields:i},o)=>{let s=Object.fromEntries(i.map(({name:e,type:t,description:n})=>[e,{type:l(t),description:n}]));return{[`modify${e}`]:{type:o,args:{id:{type:new r(t)},delta:{type:new r(new n({name:`${e}Delta`,fields:s}))}},description:`Changes writable fields of the one ${e} with the given id: ${i.map(({name:e})=>e).join(", ")}. The delta sets only the fields it names and needs at least one; values are in stored units, as the field descriptions say. Returns the entity as it is after the change, including what the configurator adjusted in response, or null when the change caused the entity to be removed.`}}})(e,i)]:[]}),Object.fromEntries(h.map(e=>{var t;return[e.fieldName,{type:new r(new s({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?(({target:e,list:t,nullable:n},i)=>{let s=t?new o(new r(i(e))):i(e);return n?s:new r(s)})(t,u):l(t.type),description:t.description}]))})),args:Object.fromEntries(Object.entries(e.args).map(([e,t])=>[e,{type:l(t.type),description:t.description}])),description:e.description}]})))})})({deletableTypes:K,writableTypes:U,childRecipes:z,replaceRecipes:Q,actionFields:F,objectTypes:H,anyDomainEntity:L(y),targetOutputType:P}),types:[...J.values(),...H.values()]}),ee=h(_);if(ee.length>0)throw Error(ee.map(e=>e.message).join(" "));return{sdl:d(_),fields:X,deletableTypes:K,writableFields:Object.fromEntries(U.map(({entityType:e,fields:t})=>[e,Object.fromEntries(t.map(({name:e,property:t})=>[e,t]))])),childRecipes:z,replaceRecipes:Q,fieldOptions:Object.fromEntries(S.flatMap(e=>{let t=w(x,e);return t?[[e,t.map(({options:e})=>e)]]:[]})),actions:Object.fromEntries(F.map(({fieldName:e,actionName:t})=>[e,t]))}};

package/dist/{phoenix/application-spec → domain/application/assistant}/generate-assistant-prompt.d.ts

@@ -1,12 +1,13 @@
-import type { AssistantSpec } from '#package/application-spec';
+import type { AssistantManifest } from './assistant-manifest.js';
 /**
  * The part of the assistant's system prompt that explains how to read the generated GraphQL schema.
- * It is generated here, by the SDK that also runs in the browser, and stored with the deployment,
+ * It is generated here, by the SDK that also runs in the browser, and returned by the deployment webhook,
  * because the conventions it describes belong to this SDK version and not to the server. The part
  * about changes is left out when the schema has no `Mutation` type, the part about adding
  * entities when it has no `addChild` mutation, the part about replacing them when it has no
  * `replaceEntity` mutation, the part about the choices of a field when it has
- * no options edge, and the part about custom changes when the manifest exposes no action. The last section explains the
- * `query` and `apply` tools, which every run registers whatever the schema holds.
+ * no options edge, and the part about custom changes when the manifest exposes no action. The last two sections explain the
+ * `query` and `apply` tools, which every run registers whatever the schema holds, and the change
+ * record the `AssistantSystem` attaches to every user message.
  */
-export declare const generateAssistantPrompt: (assistant: NonNullable<AssistantSpec>) => string;
+export declare const generateAssistantPrompt: (assistant: AssistantManifest) => string;