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

package/dist/docs/complex-use-cases/filtered-controls-with-fix-dialog.mdx

@@ -104,106 +104,92 @@ All inputs include countersinkNotAvailable, as that is fixable by auto fix dialo
 And corresponding transformers
 
 ```typescript
-configuratorBuilder
-  .withTransformers(() => [
-    {
-      priority: 3,
-      transformer: (updates, currentState) => {
-        if (updates.length > 1) {
-          return updates
-        }
-
-        const materialUpdate = updates.find(
-          (u): u is ComponentModification<MaterialSwatchComponent> =>
-            u.kind === 'modifyComponent' && u.updateTag === 'selectSwatch-material'
-        )
-
-        if (!materialUpdate) {
-          return updates
-        }
-
-        const plate = currentState.domainState.entities.find(Plate.is)!
-        const newMaterial = materialUpdate.writableState.selectedSwatchKey
-
-        const isAvailable = availableMaterials.some(
-          state =>
-            state.material === newMaterial && state.finish === plate.finish && state.thickness === plate.thickness
-        )
-
-        if (isAvailable) {
-          return updates
-        }
-
-        const similarMaterial = availableMaterials.find(m => m.material === newMaterial)
-
-        if (!similarMaterial) {
-          return updates
-        }
-
-        const fixUpdate = updateFactory.DomainEntityModification({
-          entityId: plate.id,
-          stateDelta: {
-            material: similarMaterial.material,
-            finish: similarMaterial.finish,
-            thickness: similarMaterial.thickness,
-          },
-          updateTag: 'fix.material',
-        })
-
-        return [fixUpdate]
+// src/transformers/fix-finish.ts
+import { availableMaterials } from '../_shared/available-materials.js'
+
+export default phx.frontend.transformerBuilder.when
+  .entity(['Plate'])
+  .modified({ atFields: ['finish'] })
+  .then.overrideMatchingUpdate(({ update, getOld$Entity }) => {
+    const plate = getOld$Entity()
+    const newFinish = update.stateDelta.finish
+
+    const isAvailable = availableMaterials.some(
+      state => state.material === plate.material && state.finish === newFinish && state.thickness === plate.thickness
+    )
+
+    if (isAvailable) {
+      return [update]
+    }
+
+    const similarMaterial = availableMaterials.find(m => m.finish === newFinish && m.material === plate.material)
+
+    if (!similarMaterial) {
+      return [update]
+    }
+
+    const fixUpdate = phx.frontend.updates.DomainEntityModification({
+      entityId: plate.id,
+      stateDelta: {
+        material: similarMaterial.material,
+        finish: similarMaterial.finish,
+        thickness: similarMaterial.thickness,
       },
-    },
-    {
-      priority: 3.1,
-      transformer: (updates, currentState) => {
-        if (updates.length > 1) {
-          return updates
-        }
-
-        const materialUpdate = updates.find(
-          (u): u is ComponentModification<AttributeSelectionComponent> =>
-            u.kind === 'modifyComponent' &&
-            u.updateTag === 'AttributeSelect.update' &&
-            (u.componentInstance.instanceName as string) === 'finish'
-        )
-
-        if (!materialUpdate) {
-          return updates
-        }
-
-        const plate = currentState.domainState.entities.find(Plate.is)!
-        const newFinish = materialUpdate.writableState.value
-
-        const isAvailable = availableMaterials.some(
-          state =>
-            state.material === plate.material && state.finish === newFinish && state.thickness === plate.thickness
-        )
-
-        if (isAvailable) {
-          return updates
-        }
-
-        const similarMaterial = availableMaterials.find(m => m.finish === newFinish && m.material === plate.material)
-
-        if (!similarMaterial) {
-          return updates
-        }
-
-        const fixUpdate = updateFactory.DomainEntityModification({
-          entityId: plate.id,
-          stateDelta: {
-            material: similarMaterial.material,
-            finish: similarMaterial.finish,
-            thickness: similarMaterial.thickness,
-          },
-          updateTag: 'fix.brushed',
-        })
-
-        return [fixUpdate]
+      updateTag: 'fix.brushed',
+    })
+
+    return [fixUpdate]
+  })
+  .build('fix-finish')
+```
+
+```typescript
+// src/transformers/fix-material.ts
+import { availableMaterials } from '../_shared/available-materials.js'
+
+export default phx.frontend.transformerBuilder.when
+  .entity(['Plate'])
+  .modified({ atFields: ['material'] })
+  .then.overrideMatchingUpdate(({ update, getOld$Entity }) => {
+    const plate = getOld$Entity()
+    const newMaterial = update.stateDelta.material
+
+    const isAvailable = availableMaterials.some(
+      state => state.material === newMaterial && state.finish === plate.finish && state.thickness === plate.thickness
+    )
+
+    if (isAvailable) {
+      return [update]
+    }
+
+    const similarMaterial = availableMaterials.find(m => m.material === newMaterial)
+
+    if (!similarMaterial) {
+      return [update]
+    }
+
+    const fixUpdate = phx.frontend.updates.DomainEntityModification({
+      entityId: plate.id,
+      stateDelta: {
+        material: similarMaterial.material,
+        finish: similarMaterial.finish,
+        thickness: similarMaterial.thickness,
       },
-    },
-  ])
-  .buildConfig()
+      updateTag: 'fix.material',
+    })
+
+    return [fixUpdate]
+  })
+  .build('fix-material')
+```
+
+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: fix-finish
+  - name: fix-material
 ```
 
 And FilteredControls

package/dist/docs/complex-use-cases/navigation-reset-selection.mdx

@@ -18,7 +18,7 @@ The `createResetSelectionOnNavigationTransformer` automatically deselects entiti
 
 ## Guide
 
-The `createResetSelectionOnNavigationTransformer` is added through the `.withTransformers()` method. It automatically injects a deselect update when navigating to specified states.
+The `createResetSelectionOnNavigationTransformer` is added as a file in `src/transformers/`. It automatically injects a deselect update when navigating to specified states.
 
 ### Step 1: Import the transformer
 
@@ -28,19 +28,25 @@ Import the transformer function from the domain package:
 import { createResetSelectionOnNavigationTransformer } from '@salsita-ai/sdk/domain'
 ```
 
-### Step 2: Add the transformer to your config
+### Step 2: Add the transformer to your project
 
-Use the `.withTransformers()` method on the builder:
+Create the transformer in a file under `src/transformers/`:
 
 ```typescript
-const config = configuratorBuilder
-  .withTransformers(ctx => [
-    {
-      priority: 32,
-      transformer: createResetSelectionOnNavigationTransformer([ApplicationTypes.NavigationState.SecondStep], ctx),
-    },
-  ])
-  .buildConfig()
+// src/transformers/reset-selection.ts
+import { createResetSelectionOnNavigationTransformer } from '@salsita-ai/sdk/domain'
+
+export default phx.frontend.createTransformer(ctx =>
+  createResetSelectionOnNavigationTransformer([phx.applicationTypes.NavigationState.SecondStep], ctx)
+)
+```
+
+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: reset-selection
 ```
 
 The transformer takes two arguments:
@@ -97,7 +103,7 @@ When the transformer triggers, any selected entity is deselected automatically.
  *
  * @param navigationStates - Array of navigation state names that trigger deselection
  * @param ctx - Domain context providing access to the navigation system
- * @returns Update transformer that can be registered in withTransformers
+ * @returns Update transformer to return from a transformer file in src/transformers/
  *
  * @example
  * // Deselect when entering the summary step

package/dist/docs/index.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-10-09T15:12:45.633Z",
+  "generatedAt": "2026-10-12T21:55:56.545Z",
   "categories": [
     {
       "name": "Phoenix",

package/dist/docs/layouts/custom-price.mdx

@@ -78,24 +78,22 @@ Your custom component has full access to the Material-UI theme and SDK utilities
 
 ### Step 3: Attach the component to your entity
 
-Use the configurator builder to attach your custom price component to the root entity:
+Attach your custom price component to the root entity in a file under `src/components/`. The generated code picks the
+file up by its location and registers its default export:
 
 ```typescript
-const config = configuratorBuilder
-  .withComponentOptics([
-    attachComponent
-      .withEntity('Scene')
-      .withComponent(customPriceFooterComponent, 'default')
-      .attach(
-        memoEval(
-          (s) => [s.$price],
-          (price) => ({
-            node: <AppPrice price={price} />,
-          })
-        )
-      ),
-  ])
-  .buildConfig()
+// src/components/custom-price.tsx
+export default phx.domain.attachComponent
+  .withEntity('Scene')
+  .withComponent(customPriceFooterComponent, 'default')
+  .attach(
+    memoEval(
+      (s) => [s.$price],
+      (price) => ({
+        node: <AppPrice price={price} />,
+      })
+    )
+  )
 ```
 
 The `memoEval` function takes two arguments:

package/dist/docs/layouts/sidebar/tabs.mdx

@@ -179,27 +179,30 @@ When a selected entity has no `sidebarTabs`, its property pages replace the root
 You can use transformers to automatically navigate to specific tabs when entities are selected or deselected:
 
 ```typescript
-const config = configuratorBuilder
-  .withTransformers(ctx => {
-    return [
-      // Navigate to BuckyBall's first tab when selected
-      phx.frontend.transformerBuilder.when
-        .entity(['BuckyBall'])
-        .selected()
-        .then.navigateTo('BuckyBallTab1')
-        .build('Navigate to BuckyBallTab1')
-        .register(ctx),
-
-      // Return to global tab1 when BuckyBall is deselected
-      phx.frontend.transformerBuilder.when
-        .entity(['BuckyBall'])
-        .deselected()
-        .then.navigateTo('tab1')
-        .build('Navigate to Tab1')
-        .register(ctx),
-    ]
-  })
-  .buildConfig()
+// src/transformers/bucky-ball-tab.ts
+export default phx.frontend.transformerBuilder.when
+  .entity(['BuckyBall'])
+  .selected()
+  .then.navigateTo('BuckyBallTab1')
+  .build('buckyBallTab')
+```
+
+```typescript
+// src/transformers/tab.ts
+export default phx.frontend.transformerBuilder.when
+  .entity(['BuckyBall'])
+  .deselected()
+  .then.navigateTo('tab1')
+  .build('tab')
+```
+
+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: buckyBallTab
+  - name: tab
 ```
 
 This creates smooth navigation flows where selecting specific entities automatically switches to their relevant tabs, and deselecting returns to a default tab state.

package/dist/docs/layouts/toolbar.mdx

@@ -84,7 +84,9 @@ Phoenix provides built-in toolbar buttons for common operations:
 - `assistantToolbarButton` - Open and close the built-in assistant panel. It renders only in a project whose
   application spec has an `assistant` section. `props.showTitle` defaults to `true`; the label shows on a
   desktop-sized layout only. The default toolbar includes it, in a group of its own, when the spec has an
-  `assistant` section.
+  `assistant` section. Only the universal layout carries the panel, and the button does not hide itself in a
+  layout without it. A custom layout that renders the toolbar therefore defines a `toolbar` component without the
+  button, because the default toolbar would add it.
 
 ### Mobile Toolbar Configuration
 

package/dist/docs/other-features/domain-actions.mdx

@@ -83,7 +83,7 @@ export default phx.domain.implementActions({
 })
 ```
 
-Throw to reject a call: the message reaches the user through the control's hint and the assistant through the failed mutation, so say what went wrong and what to send instead. An action declared without an implementation, or an implementation of a name the spec does not declare, is a type error. A declared action without an implementation also stops the domain from initializing, and under `phoenix dev` the editor reports it as a `MISSING_ACTION_IMPLEMENTATIONS` diagnostic and does not apply the change; an implementation of an undeclared name is logged.
+Throw to reject a call: the message reaches the user through the control's hint and the assistant through the failed mutation, so say what went wrong and what to send instead. An implementation of a name the spec does not declare is a type error. A declared action without an implementation is not: it stops the domain from initializing, and under `phoenix dev` the editor reports it as a `MISSING_ACTION_IMPLEMENTATIONS` diagnostic and does not apply the change; an implementation of an undeclared name is logged.
 
 ## Run it from the UI
 

package/dist/docs/other-features/side-effects.mdx

@@ -66,42 +66,76 @@ With following control structure. The top input selects the material, the bottom
 The transformer is used to change the finish if necessary and show the notification.
 
 ```typescript
-configuratorBuilder
-  .withTransformers(domainContext => [
-    phx.frontend.transformerBuilder.when
-      .entity(['Plate'])
-      .modified({ atFields: ['material'] })
-      .causes.self.violation(['finishNotAvailable'])
-      .then.applySideEffect(({ update, getOld$Entity }) => {
-        const oldPlate = getOld$Entity()
-        const newMaterial = update.stateDelta.material
-
-        const validMaterial =
-          availableMaterials.find(m => m.material === newMaterial && m.finish === oldPlate.finish) ??
-          availableMaterials.find(m => m.material === newMaterial)
-
-        if (!validMaterial || validMaterial.finish === oldPlate.finish) {
-          return []
-        }
-
-        // create an additional update that will fix the material finish
-        const fixUpdate = phx.frontend.updates.DomainEntityModification({
-          entityId: oldPlate.id,
-          stateDelta: {
-            finish: validMaterial.finish,
-          },
-          updateTag: 'fix.finish',
-          hint: msg`Material finish was adjusted`, // specify a hint for the user (side effect)
-        })
-
-        return [fixUpdate]
-      })
-      .build('Fix material finish')
-      .register(domainContext),
-  ])
-  .buildConfig()
+// src/transformers/fix-finish.ts
+import { msg } from '@lingui/core/macro'
+
+import { availableMaterials } from '../_shared/materials.js'
+
+export default phx.frontend.transformerBuilder.when
+  .entity(['Plate'])
+  .modified({ atFields: ['material'] })
+  .causes.self.violation(['finishNotAvailable'])
+  .then.applySideEffect(({ update, getOld$Entity }) => {
+    const oldPlate = getOld$Entity()
+    const newMaterial = update.stateDelta.material
+
+    const validMaterial =
+      availableMaterials.find(m => m.material === newMaterial && m.finish === oldPlate.finish) ??
+      availableMaterials.find(m => m.material === newMaterial)
+
+    if (!validMaterial || validMaterial.finish === oldPlate.finish) {
+      return []
+    }
+
+    // create an additional update that will fix the material finish
+    const fixUpdate = phx.frontend.updates.DomainEntityModification({
+      entityId: oldPlate.id,
+      stateDelta: {
+        finish: validMaterial.finish,
+      },
+      updateTag: 'fix.finish',
+      hint: msg`Material finish was adjusted`, // specify a hint for the user (side effect)
+    })
+
+    return [fixUpdate]
+  })
+  .build('fix-finish')
 ```
 
+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: fix-finish
+```
+
+### Hints and the AI assistant
+
+In a configurator with the AI assistant, the assistant is told the same hints: they arrive as
+`sideEffects` with the result of its changes and in the dry-runs of recipes and options, so it can
+tell the user what else happened. The hints also explain what the user changed between two messages:
+every message carries a change record of the configuration, and each of its lines ends with the hint
+of the last update that touched it, or with the `updateTag` when the update has none. Set `agentHint`
+beside `hint` when the assistant needs different wording, for example with ids or values a snackbar
+would not show:
+
+```ts
+phx.frontend.updates.DomainEntityModification({
+  entityId: oldPlate.id,
+  stateDelta: { finish: validMaterial.finish },
+  updateTag: 'fix.finish',
+  hint: msg`Material finish was adjusted`,
+  agentHint: `The finish of ${oldPlate.id} was changed to ${validMaterial.finish}, the only one this material comes in.`,
+})
+```
+
+- `agentHint` is a plain string, never shown to the user and not localized.
+- `agentHint: null` keeps the wording from the assistant while the user still gets the `hint`: the
+  update is left out of `sideEffects`, and the change record explains its line by the `updateTag`. It
+  does not hide the change itself, which the assistant can always read from the configuration.
+- `agentHint` without a `hint` tells only the assistant.
+
 ## Example
 
 Here you can see the live example!

package/dist/docs/other-features/transformers.mdx

@@ -102,7 +102,7 @@ export const removeExtraneousBranchesAndLeavesWhenShortened = phx.frontend.trans
     - With `overrideMatchinUpdates(ctx => /* side effect updates */)` the updates returned by the provided callback will replace the original **matched update**. This will be triggered for every matching update. Note that this action is not available in events which are not bound to a specific update - such as a violation check without a defined cause.
     - With `overrideAllUpdates(ctx => /* side effect updates */)` the updates returned by the provided callback will replace all original updates. This will be triggered only once for a single run of the transformer. This allows for implementation of transformers that behave similarly as the raw `UpdateTransformer`
   - High-level actions: `select`, `deselect`, `navigate`, `changeView` - more on these in the other examples.
-- `build(name)` is the final step to create the transformer. Assign a descriptive name (no restrictions) to easily identify the transformer while tracing. Note that this returns a `RegistrableTransformer` which needs to be registered using the `register(domainContext)` method. This is usually done in the `.withTransformers()` method of the configurator builder.
+- `build(name)` is the final step to create the transformer. The name identifies the transformer while tracing, and it is the name the `transformers` section of the spec refers to, so it must match the file name with case and dashes ignored (`fix-finish.ts` and `fixFinish` match). Note that this returns a `RegistrableTransformer`. Default-export it from a file in `src/transformers/` and list the name passed to `build(...)` in the `transformers` section of the spec; the generated code registers it. The shorter snippets on this page use descriptive names for readability; the complete implementation below uses names that match its files.
 
 ### Side-Effect on Update Causing Another Entity's Violation
 

package/dist/docs/phoenix/admin.mdx

@@ -427,43 +427,28 @@ For technical details about data transformation and storage, see [Data Sources -
 
 ## Web Component Integration
 
-Admin functionality integrates through the configurator builder rather than requiring separate web component setup.
+Admin functionality is part of the same application as the configurator and needs no separate web component setup.
 
-### Configurator Builder Setup
+### Registering Admin Components
 
-In phx-cli projects, frontend entry is auto-generated in `.phoenix/`. Admin components are registered through `src/admin/components/`:
+The frontend entry is generated into `.phoenix/`, so a project never calls the configurator builder itself. Every file
+in `src/admin/components/` is picked up by its location and its default export is registered as admin components:
 
 ```typescript
 // src/admin/components/admin-components.tsx
-import { configuratorBuilder } from '.phoenix/frontend.js'
-import { customAdminOptics } from './optics.js'
-import { NotAuthenticatedPage } from '../pages/NotAuthenticatedPage.js'
-
-const config = configuratorBuilder
-  .withComponentOptics(customConfiguratorComponents)
-  .withAdminComponentOptics(customAdminOptics) // Register admin components
-  .buildConfig({
-    deploymentId: phx.runtimeConfig.DEPLOYMENT_ID,
-    persistence: {
-      type: 'server',
-      serverUrl: phx.runtimeConfig.SERVER_URL,
-    },
-    ui: {
-      notAuthenticatedPage: <NotAuthenticatedPage />, // Show when user not authenticated
-    },
-    // ... other config
-  })
+// ... customAdminOptics as defined in the example above
 
-phx.frontend.mountApplication(config)
+export default customAdminOptics
 ```
 
-Admin component files go in `src/admin/components/` and are automatically discovered by phx-cli.
+The page shown to a user who is not authenticated is an element. Create it with
+`phx.frontend.createNotAuthenticatedPage(...)` in a file under `src/elements/`.
 
 ### Built-in Admin Integration
 
 Phoenix automatically provides admin functionality when:
 
-1. Admin components are registered via `withAdminComponentOptics()`
+1. Admin components are default-exported from files in `src/admin/components/`
 2. Admin configuration exists in `phoenix.config.ts`
 3. User has admin session token
 

package/dist/docs/phoenix/localization.mdx

@@ -116,28 +116,9 @@ After running `pnpm lingui:compile`, your custom translations will override the
 - Adapt translations for your target audience
 - Maintain consistency with your existing product language
 
-**Frontend integration**:
-
-```typescript
-import { configuratorBuilder } from 'project-domain'
-import { createI18n } from 'project-i18n'
-
-const i18n = createI18n()
-
-export const config = configuratorBuilder
-  .withComponentOptics(customComponents)
-  .withPresets(presets)
-  .withI18n(i18n) // Register i18n service with configurator
-  .buildConfig({
-    features: {
-      availableLocales: ['en', 'de', 'cs'],
-    },
-    services: {
-      logger,
-    },
-    // ... other configuration
-  })
-```
+**Frontend integration**: the generated `.phoenix` code creates the i18n service from `.phoenix/i18n.ts` and registers
+it with the application, so there is nothing to wire by hand. The languages come from `availableLocales` in
+`spec/application.yaml`.
 
 ## Working with YAML Domain Specifications