@engenty/wizards-runtime 0.7.10 → 0.8.0

package/apps/runtime/dist/docs/dev/wizard-format/meta.json

@@ -0,0 +1,19 @@
+{
+  "title": "The wizard format",
+  "pages": [
+    "index",
+    "validate",
+    "wizard-file",
+    "---Steps---",
+    "pages-and-fields",
+    "agent-steps",
+    "generate-steps",
+    "views-and-widgets",
+    "film-steps",
+    "review-and-result",
+    "---Across steps---",
+    "templates",
+    "branches",
+    "lists-and-connections"
+  ]
+}

package/apps/runtime/dist/docs/dev/wizard-format/pages-and-fields.md

@@ -0,0 +1,102 @@
+---
+title: Pages and fields
+description: A page step and its fields, the field kinds, and fields that show only when they fit.
+version: 0.7.10
+---
+
+A `page` step asks the person. It holds at least one field, and a good page has at most five.
+`cta` is the button’s label.
+
+```json
+{
+  "id": "about", "type": "page", "title": "What is it about?", "cta": "Write it",
+  "fields": [
+    { "id": "topic", "label": "Topic", "kind": "textarea", "required": true,
+      "placeholder": "e.g. We open our new studio on Friday", "help": "For the first line" },
+    { "id": "tone", "label": "Tone", "kind": "select",
+      "options": ["Casual", "Professional"], "default": "Casual" }
+  ]
+}
+```
+
+A field’s `id` is unique in the whole wizard, because later steps read the answer by it. Every
+field has a `label` and a `kind`, and may have `required`, `placeholder`, `help` and `default`.
+
+## Field kinds
+
+| Kind | What the person gives | Keys of its own |
+|---|---|---|
+| `text`, `textarea` | A line, or a few paragraphs | `scan` (text): fill it from a QR code or barcode |
+| `number`, `date`, `email`, `url` | A number, a date, an address, a link | |
+| `select`, `multiselect` | One or several of `options` | `optionsFrom`, `cards` |
+| `toggle` | Yes or no | |
+| `color` | A colour | |
+| `image` | Photos, taken or uploaded | `multiple`, `min`, `max` (up to 30) |
+| `file` | Documents, photos, recordings | `multiple`, `min`, `max`, `camera`, `video`, `listen` |
+| `items` | Line items with totals | `columns`, `vat`, `currency` |
+| `location` | Where they are, or an address they type | |
+| `audio` | A voice note of up to 5 minutes, written down before the next step | |
+| `signature` | A signature drawn with the finger | |
+| `slot` | One appointment time, shown by day | `options` or `optionsFrom`, as ISO 8601 date-times |
+| `connection` | Connects one of their accounts | `connection`: the id of a wizard connection |
+| `list` | Checks and corrects a stored list | `list`: the id of a wizard list |
+
+## Line items
+
+An `items` field takes positions and computes the totals itself:
+
+```json
+{ "id": "positions", "label": "Positions", "kind": "items", "currency": "EUR",
+  "vat": { "rate": 20 },
+  "columns": [
+    { "id": "what", "label": "Service", "kind": "text" },
+    { "id": "hours", "label": "Hours", "kind": "number" },
+    { "id": "rate", "label": "Rate", "kind": "money" }
+  ] }
+```
+
+A row’s amount is the product of its `number` and `money` columns. `vat.field` reads the rate
+from another field instead. Documents take the table with its totals from `{{positions}}`. See
+[Templates](./templates.md).
+
+## Answers from earlier steps
+
+- `prefill` (`"steps.<id>.<key>"`): what the field starts with. An `items` field takes a table
+  whose columns are its column ids, and the person corrects the rows.
+- `optionsFrom`: the choices of a `select`, `multiselect` or `slot` come from earlier data. It
+  names a list output (`steps.<id>.<key>`), a column of a table output
+  (`steps.<id>.<key>.<column>`) or a column of a stored list (`lists.<id>.<column>`). `options`
+  stand in while that data is empty.
+- `cards`: with `optionsFrom` naming a table output, each row is a card. Its keys name the
+  table’s columns: `label`, `value` (default: the label), `image`, `subtitle`, `meta` and `link`.
+
+## Fields that show only when they fit
+
+`when` shows a field only while a condition holds. It reads a field of the same page, decided as
+the person types, or anything known before the page:
+
+```json
+{ "id": "company", "label": "Company", "kind": "text",
+  "when": { "field": "customerType", "op": "equals", "value": "Business" } }
+```
+
+A hidden field is not asked and not kept. Its template is empty. Conditions are described on
+[Branches and loops](./branches.md#conditions).
+
+Where no rule on one field can say it, a decision picks the fields as the run reaches the page:
+
+- `ask` on a field: a statement. The field shows when the decision finds it true of the run,
+  for example “The complaint is about a damaged article”.
+- `groups` on the page and `group` on fields: of a group’s fields the decision shows one. With
+  `optional`, it may show none.
+
+```json
+"groups": [{ "id": "reach", "instructions": "How should we reach the person?" }],
+"fields": [
+  { "id": "phone", "label": "Phone", "kind": "text", "group": "reach" },
+  { "id": "mail", "label": "Email", "kind": "email", "group": "reach" }
+]
+```
+
+A page with decided fields holds up to 12 fields and shows at most 5. A field has `ask` or
+`group`, not both.

package/apps/runtime/dist/docs/dev/wizard-format/review-and-result.md

@@ -0,0 +1,64 @@
+---
+title: Review and result
+description: A review step shows earlier results to check, the result step ends the run with its downloads.
+version: 0.7.10
+---
+
+## Review
+
+A `review` step shows what earlier steps made. The person accepts it, changes it or asks for a
+new version.
+
+```json
+{
+  "id": "check", "type": "review", "title": "Does this work?",
+  "show": ["post", "visual"], "edit": true, "regenerate": true
+}
+```
+
+| Key | What it does |
+|---|---|
+| `show` | The step ids whose results are shown, or `lists.<id>` for a stored list |
+| `edit` | The person may change text results directly |
+| `regenerate` | The person may ask for a new version, with a note |
+
+A shown list is edited in place. A list with `check` goes row by row on a split screen. See
+[Lists and connections](./lists-and-connections.md#lists).
+
+Put a review before anything expensive, such as video, and before anything written elsewhere,
+such as a mail or a CRM.
+
+## Result
+
+The `result` step is always the last. It shows `message` and offers the downloads.
+
+```json
+{
+  "id": "done", "type": "result", "title": "Ready to post",
+  "message": "Copy the text and download the image.",
+  "deliverables": [
+    { "from": "post", "label": "Post", "formats": ["txt", "md"] },
+    { "from": "visual", "label": "Image", "formats": ["png"] }
+  ]
+}
+```
+
+Each deliverable names a step id or `lists.<id>` in `from`, an optional `label` and its
+`formats`.
+
+## Formats
+
+| From | Formats |
+|---|---|
+| `generate` image | `png` |
+| `generate` video | `mp4`, `zip` for several results |
+| `generate` voice | `mp3` |
+| `generate` document | `pdf`, `docx`, `html`, `md`, `png` |
+| `generate` dashboard | `html`, `pdf`, `png` |
+| `widget` | `html`, `png`, `pdf`, `json`, and `mp4` when the widget has a timeline |
+| `widget` with `video` | `mp4`, `png` |
+| `film` | `mp4` |
+| `agent` with `text` or `markdown` | `md`, `txt`, `docx`, `pdf`, `html` |
+| `agent` with `json` | `json`, `csv`, `xlsx` (a sheet per table), `md`, and `pdf` with a `schema` |
+| `agent`, any format | `zip`: the files the step kept |
+| `lists.<id>` | `xlsx`, `csv`, `json`, `md`, and `zip` for a list with `check.file` |

package/apps/runtime/dist/docs/dev/wizard-format/templates.md

@@ -0,0 +1,57 @@
+---
+title: Templates
+description: How instructions, prompts and briefs read answers, earlier results, the space and stored lists.
+version: 0.7.10
+---
+
+Instructions, prompts and briefs are templates. `{{…}}` is filled in when the step runs:
+
+```text
+Write a post for X on {{topic}}. Tone: {{tone}}. Use these facts: {{steps.research}}
+```
+
+A template may only name fields asked and steps run earlier. `wizards validate` says when one
+does not.
+
+## What a template reads
+
+| Template | What it gives |
+|---|---|
+| `{{fieldId}}` | The answer to a field |
+| `{{steps.stepId}}` | A step’s whole result |
+| `{{steps.stepId.key}}` | One key of a `json` step’s result |
+| `{{lists.listId}}` | A stored list as a table, as it is when the step starts |
+| `{{today}}` | Today’s date |
+| `{{brand.name}}`, `{{brand.about}}`, `{{brand.colors}}` | The space’s brand |
+| `{{facts.key}}`, `{{facts}}` | One fact of the space, such as its address or VAT ID, or all of them |
+
+Every AI step already knows the brand and the facts. Name one only where the text must carry it.
+
+## Fields with more than one value
+
+| Template | What it gives |
+|---|---|
+| `{{itemsField}}` | The line items as a table with net, VAT and total |
+| `{{itemsField.net}}`, `.vat`, `.gross` | One of the totals |
+| `{{fileField}}` | The names of the uploads |
+| `{{field.speech}}` | A `file` field with `listen`: what is said, piece by piece with times |
+| `{{audioField}}`, `{{audioField.seconds}}` | What the person said, and how long |
+| `{{locationField}}` | The address with its position, for example “Herrengasse 16, Graz (47.07071, 15.43950, ±12 m)” |
+| `.lat`, `.lng`, `.accuracy`, `.label`, `.map` | One part of a location, `.map` a map link |
+| `{{signatureField}}` | The picture as `asset://ID`, for `<img src="asset://ID">` in a document |
+
+Documents take `{{itemsField}}` as it is. The runner computes the totals, never a model.
+
+## Inside a step with `each`
+
+| Template | What it gives |
+|---|---|
+| `{{item.column}}` | One column of the current entry |
+| `{{index}}` | The number of the entry |
+| `{{count}}` | How many entries there are |
+
+## References outside templates
+
+Other keys name the same things without braces: `prefill`, `optionsFrom`, `each`, a widget’s or
+surface’s `data` and a condition’s `field`. They take `fieldId`, `steps.<id>`, `steps.<id>.<key>`
+and `lists.<id>`, as each key’s page says.

package/apps/runtime/dist/docs/dev/wizard-format/validate.md

@@ -0,0 +1,63 @@
+---
+title: JSON Schema and validation
+description: The JSON Schema for your editor, and wizards validate for everything a schema cannot say.
+version: 0.7.10
+---
+
+## JSON Schema
+
+| For | Schema |
+|---|---|
+| A definition | [`https://engenty.ai/schema/v1/wizard.json`](https://engenty.ai/schema/v1/wizard.json) |
+| `wizard.json` in a package | [`https://engenty.ai/schema/v1/wizard-package.json`](https://engenty.ai/schema/v1/wizard-package.json) |
+
+Put the address under `"$schema"`, and editors such as VS Code complete keys and mark mistakes
+as you type. The studio’s export writes it into every `wizard.json`.
+
+The schemas are written from the code that reads wizards, so they match it. They are stricter
+in one way: a key the app does not know is an error. The app would drop such a key without a
+word.
+
+## `wizards validate`
+
+```bash
+wizards validate invoice.wizard
+```
+
+It checks a wizard the way the studio’s import does, without a running studio and without an
+account. It also checks what a JSON Schema cannot say: unique ids, steps and fields that refer
+to each other, templates that name answers that exist by then, and files in the workspace.
+
+It takes any number of paths:
+
+| Path | Read as |
+|---|---|
+| `invoice.wizard` | A package |
+| `invoice/` or `invoice/wizard.json` | An unpacked package, its workspace under `invoice/files/` |
+| `invoice.json` | A definition on its own, or a `wizard.json` |
+
+```text
+✗ invoice.json 2 issues
+  The last step must be a result step.
+  "{{nope}}" refers to a field that is not asked before "g".
+```
+
+A wizard without issues gets a ✓ with its number of steps and files. `--json` prints the
+results as JSON. The exit code is `0` when every wizard is fine, `1` when one has issues and `2`
+when no path was given.
+
+## In CI
+
+```bash
+npx wizards validate wizards/*.wizard
+```
+
+`npx wizards` installs engenty wizards into `~/.engenty/wizards` first, the first time. To check
+without an install, on Node.js 24.11 or newer, run the runtime from npm directly:
+
+```bash
+npx -p @engenty/wizards-runtime wizards validate wizards/*.wizard
+```
+
+What belongs to a space is checked only on import. See
+[What the import takes](./wizard-file.md#what-the-import-takes).

package/apps/runtime/dist/docs/dev/wizard-format/views-and-widgets.md

@@ -0,0 +1,103 @@
+---
+title: Views and widgets
+description: Surfaces built from the catalog, a view of an agent step's result, nested output, and HTML widgets.
+version: 0.7.10
+---
+
+A result can show as a view instead of a plain table. There are three ways:
+
+| Way | What it is | Costs per run |
+|---|---|---|
+| A `surface` step | A view built from the surface catalog, written once | Nothing |
+| `output.surface` on an agent step | The same, bound to that step’s own result | Nothing |
+| A `widget` step | An HTML app in the wizard’s workspace, written once | Nothing |
+
+Choose a surface for facts, a list of results, key figures or a chart. Choose a widget for what
+the catalog cannot show, such as a map or an animation.
+
+## Surfaces
+
+A surface is a flat array of components. The one with id `root` is drawn, and containers list
+their children by id. A prop is a value, or `{ "path": "/key/…" }` into the data.
+
+```json
+{
+  "id": "show", "type": "surface", "title": "Your offers",
+  "data": { "offers": "steps.research.offers" },
+  "components": [
+    { "id": "root", "component": "Column", "children": ["head", "list"] },
+    { "id": "head", "component": "Text", "text": "Three offers for you", "variant": "lead" },
+    { "id": "list", "component": "List", "children": { "path": "/offers", "componentId": "row" } },
+    { "id": "row", "component": "Row", "title": { "path": "name" }, "meta": { "path": "price" } }
+  ]
+}
+```
+
+`data` maps keys to what the surface reads: a field id, `steps.<id>`, `steps.<id>.<key>`,
+`lists.<id>`, `brand.name` or `today`.
+
+| Components | For |
+|---|---|
+| `Column`, `Grid`, `Tabs`, `Fold`, `Group` | Layout: stacks, tiles, two to four views, details on a tap, entries under a heading per value |
+| `Text`, `Callout`, `Badge`, `DetailGrid`, `Metric` | Words, a tip or warning, a label, facts, a key figure |
+| `Card`, `List`, `Row`, `Link` | Things: one card per thing, rows, an entry that opens in a sheet |
+| `Chips`, `Checklist`, `Steps` | Short things, things to get or do, ordered work |
+| `Table`, `BarChart`, `LineChart`, `DonutChart` | Figures compared across columns, charts |
+| `Image`, `Actions`, `Button` | A picture, buttons that make the result again or open it |
+
+`candidates` replaces `components` when the view should change per run. Each candidate is a piece
+with a `description`, and a decision picks the pieces that fit: no chart when there is nothing to
+chart. `group` and `groups` work as on [pages](./pages-and-fields.md#fields-that-show-only-when-they-fit),
+and `required` pieces always show.
+
+The MCP tool `get_authoring_guide` lists every component with its props.
+
+## A view of an agent step’s result
+
+An agent step with `output.format` `json` can carry its own view in `output.surface`, bound to
+its keys by path. Reviews and the result show it in place of a table. `output.surface: true` has
+a model compose a view on every run instead, which costs a model call.
+
+For nested data, `output.schema` replaces `output.fields`. Its root is an object:
+
+```json
+"schema": { "kind": "object", "label": "Menu plan", "fields": {
+  "days": { "kind": "list", "label": "Days", "of": { "kind": "object", "label": "Day", "fields": {
+    "label": { "kind": "text", "label": "Day" },
+    "recipe": { "kind": "ref", "label": "Recipe", "to": "recipes" } } } },
+  "recipes": { "kind": "list", "label": "Recipes", "of": { "kind": "object", "label": "Recipe", "fields": {
+    "id": { "kind": "text", "label": "ID" },
+    "minutes": { "kind": "number", "label": "Time", "unit": "min" } } } } } }
+```
+
+Kinds are `text` (with `long` for paragraphs), `number` (with `unit`), `yesno` (with `yes` and
+`no`, the words people read), `choice`, `ref` (the id of an entry of a top-level list) and `list`.
+Objects nest at most four deep, with a hundred keys in all. Labels are in the wizard’s language.
+The view is checked against the schema.
+
+## Widgets
+
+A `widget` step shows an HTML page from the wizard’s workspace. It is written once, and every run
+only brings new data.
+
+```json
+{
+  "id": "map", "type": "widget", "title": "The route",
+  "entry": "route/index.html", "sample": "route/sample.json",
+  "data": { "stops": "steps.plan.stops" },
+  "size": { "width": 1280, "height": 720 }
+}
+```
+
+| Key | What it does |
+|---|---|
+| `entry` | The workspace path of the HTML |
+| `data` | What the page gets as `wizard.data`: key → a field id, `steps.<id>`, `steps.<id>.<key>`, `brand.name` or `today` |
+| `sample` | Example data in the same shape, for previews before any run |
+| `layout` | `fixed` (the default): drawn at `size` and scaled to the page. `page`: part of the page, as tall as its content |
+| `size` | The design size, 200 to 3840 px. The default is 1280 × 720. PNG, PDF and MP4 render at it |
+| `video` | The result is a film: the timeline is rendered to an MP4 with sound |
+
+The page loads nothing from the network when it runs. Libraries and reference data are files in
+the workspace. It talks to the runner through `window.wizard`: `data`, `brand`, `ready()`,
+`timeline()`, `state` and `save()`, among others.

package/apps/runtime/dist/docs/dev/wizard-format/wizard-file.md

@@ -0,0 +1,147 @@
+---
+title: The .wizard file
+description: The zip a wizard travels in, its folders and manifest, how to make one by hand, and what the import does with it.
+version: 0.7.10
+---
+
+A `.wizard` file is a zip with the wizard’s definition and its workspace. The studio exports
+one, imports one back, and `wizards validate` checks one. Its media type is
+`application/vnd.engenty.wizard+zip`. The file is named after the wizard’s title, such as
+`create-an-invoice.wizard`.
+
+## What is in the zip
+
+```text
+create-an-invoice.wizard
+├── wizard.json                 the manifest, with the definition in it
+└── files/                      the wizard's workspace
+    ├── invoice/
+    │   ├── index.html          a widget step's entry
+    │   ├── app.js
+    │   └── sample.json         its example data
+    ├── lib/
+    │   └── chart.min.js        libraries the widgets load
+    ├── prices.csv              reference data AI steps read
+    ├── kits/explainer.zip      a film step's style kit
+    ├── skills/brand/SKILL.md   a skill package a film step reads
+    └── knowledge/              only in a website package
+        └── services/pricing.md
+```
+
+| Path | What it holds |
+|---|---|
+| `wizard.json` | The manifest. See [The manifest](#the-manifest) |
+| `files/` | The workspace: every file the wizard’s steps name by path |
+| `files/knowledge/` | The space’s Knowledge pages, only when the export was asked for them. See [Knowledge](#knowledge) |
+
+Only `wizard.json` is required. A wizard without widgets, kits or files has an empty `files/`
+or none.
+
+## The workspace
+
+The paths under `files/` are the paths the definition uses. A widget step with
+`"entry": "invoice/index.html"` reads `files/invoice/index.html`, and a film step with
+`"kit": "kits/explainer.zip"` reads `files/kits/explainer.zip`. Apart from `knowledge/`, no
+folder has a fixed meaning. The ones above are what the studio and its assistant write.
+
+| Limit | Value |
+|---|---|
+| Files | 200 |
+| One file | 5 MB |
+| All files | 25 MB |
+| The whole zip | 30 MB, with room for the manifest |
+| A path | 200 characters: letters, digits, `_`, `-` and `.`, with `/` between folders |
+
+A path starts with a letter, a digit, `_` or `-`. So hidden files such as `.env` and paths with
+`..` are not allowed. The import refuses a file that breaks a limit, and names it.
+
+## The manifest
+
+```json
+{
+  "$schema": "https://engenty.ai/schema/v1/wizard-package.json",
+  "format": "engenty-wizard",
+  "version": 1,
+  "exportedAt": "2026-10-18T09:12:00.000Z",
+  "definition": { "version": 1, "title": "Create an invoice", "steps": [ … ] },
+  "connectors": [
+    { "id": "billomat", "name": "Billomat", "domain": "billomat.com", "sourceKind": "openapi" }
+  ],
+  "mcpServers": [{ "id": "notion", "name": "Notion" }],
+  "knowledge": { "pages": 12, "truncated": false }
+}
+```
+
+| Key | What it holds |
+|---|---|
+| `$schema` | The JSON Schema for editors. The app does not read it |
+| `format` | Always `engenty-wizard`. It tells a manifest from a bare definition |
+| `version` | The manifest’s version, `1` |
+| `exportedAt` | When the file was made |
+| `definition` | The wizard. See [The wizard format](./index.md) |
+| `connectors` | Imported connectors the wizard’s connections name: `id`, `name`, `domain` and `sourceKind` (`openapi` or `mcp`), at most 50 |
+| `mcpServers` | The space’s connected systems its agent steps name: `id` and `name`, at most 10 |
+| `knowledge` | Only with Knowledge: how many pages, and whether the cap left some out |
+
+`connectors` and `mcpServers` hold names, never addresses, headers or credentials. They let the
+import tell you what the space you import into still needs.
+
+## Knowledge
+
+A website runs a wizard without its space. For that, the share dialog’s website package has
+“Take the knowledge along”. The space’s Knowledge pages then come along as Markdown, one file per
+page, at their path under `files/knowledge/`:
+
+```markdown
+---
+title: "Pricing"
+path: pages/services/pricing
+---
+
+Our hourly rate is …
+```
+
+A page is cut after 60,000 characters. The pages stop at about 2 MB in all, and `truncated` in the
+manifest then says so.
+
+## What stays out
+
+A `.wizard` file holds the wizard, not what it collected or what the space owns:
+
+- runs, results and uploads
+- the rows of its lists and the accounts people connected
+- the space’s brand, facts and Knowledge, unless Knowledge was asked for
+- the addresses and credentials of connectors and connected systems
+- translations and the wizard’s published versions
+
+The studio’s export holds the draft. The website package and the export over the API hold the
+published version.
+
+## Making one by hand
+
+Zip a folder that holds `wizard.json` and `files/`:
+
+```bash
+cd create-an-invoice && zip -r ../create-an-invoice.wizard wizard.json files
+```
+
+The zip may also hold that folder itself, as a zip made in the Finder does. The import takes the
+`wizard.json` closest to the top, and the `files/` beside it. It leaves out folders, `__MACOSX/`
+and `.DS_Store`.
+
+`wizards validate` reads the unpacked folder as it is, without zipping it. See
+[JSON Schema and validation](./validate.md).
+
+## What the import does
+
+The import takes a `.wizard` file, a `wizard.json` on its own, or a definition on its own. A JSON
+file without `"format": "engenty-wizard"` is read as a definition.
+
+1. It checks the zip against the limits before it unpacks anything.
+2. It checks the definition and that every path it names is in the workspace.
+3. It makes a new wizard in the space: a draft, not published, with the workspace’s files.
+4. It tells you which connectors and connected systems the space still lacks.
+
+What belongs to the space is checked only here, because only the space has it: its connectors
+and their actions, its connected systems and its plugins’ tools. A manifest of a newer version
+is refused, with a note that the file comes from a newer version of engenty wizards.

package/apps/runtime/dist/docs/user/run.md

@@ -1,7 +1,7 @@
 ---
 title: Run a wizard
 description: What you see when you open a wizard's link, on a computer or a phone.
-version: 0.5.0
+version: 0.7.11
 ---
 
 ## From the link to the result
@@ -90,9 +90,26 @@ everything” deletes it. Anything nobody used for 400 days is deleted by itself
 
 ## Share a result
 
-“Share” on the result page makes a link to the result. You can copy it, send it by email or hand
-it to another app. When you ran the wizard over its link, the result and its link are kept for 7
-days. “Withdraw link” ends the link earlier.
+“Share” on the result page opens the ways to pass the result on. “Link” makes a link to the
+result: copy it, send it by email or hand it to another app. When you ran the wizard over its
+link, the result and its link are kept for 7 days. “Withdraw link” ends the link earlier.
+
+The other tiles send or publish the result itself. Each one walks you through its steps: the
+account it sends with (“Account”), what goes along and where it goes (“What & where”), then
+“Send”. What happens shows in the same window, and “Recent” lists what was sent before. An
+account you connect is kept for your next run, encrypted. “What this wizard remembers” lists it.
+
+| Tile | Does | Needs |
+|---|---|---|
+| “Email” | Sends the files you pick as attachments to one or more addresses | Your mailbox: Gmail, Outlook or any mailbox over SMTP. Where the server sends from an address of its own, no account |
+| Google Drive, OneDrive, S3 | Saves the files into a folder, which is created if it doesn’t exist yet | The account |
+| “Slack” | Posts your message with the link to the result in a channel | Your Slack account |
+| A connected service | An AI agent does what you describe in the service, with its actions, and asks before every change | The account, and a few minutes |
+| “Website” | The wizard opens the site in its browser, and an AI agent posts there what you describe. You sign in yourself, and it asks for your leave before anything goes public | A few minutes. LinkedIn, X, Facebook, Instagram and Meta Ads are ready as presets |
+
+Which tiles a result offers is the wizard’s choice, see [The result](./steps.md#the-result).
+Without one, every tile that needs no AI agent is there for everyone with the link. The agent
+tiles are there for the wizard’s owner in the studio, as they spend the wizard’s credits.
 
 Media made by a model carries an “AI-generated” label. Whoever publishes it has to label it as
 AI-generated. The file already carries the marking.

package/apps/runtime/dist/docs/user/steps.md

@@ -1,7 +1,7 @@
 ---
 title: Steps
 description: What a wizard is made of – pages, AI steps, generated media, widgets, reviews and the result.
-version: 0.5.0
+version: 0.7.11
 ---
 
 A wizard runs its steps from top to bottom. The last step is always the result.
@@ -179,6 +179,31 @@ Each entry of the result page names a step and the formats the person can downlo
 | AI step, collected files | ZIP |
 | List | Excel, CSV, JSON, Markdown; ZIP with the files its rows name |
 
+Under “Send & publish” the step says where a person can send or publish the result with one
+button, besides the link and the downloads (see [Share a result](./run.md#share-a-result)). Each
+target is a row with a switch and its state: “Ready”, “AI agent · only you”, or “Not set up”.
+A sentence above the rows says what visitors get and what only you get.
+
+| Label | Means |
+|---|---|
+| “Default” | Every target that is set up and needs no AI agent. Targets with an agent only you get |
+| “Own list” | You switched a target off, prefilled one or added one: only the targets switched on, in this order. An agent target then runs for everyone with the link, on your credits |
+| “Off” | Every target switched off: the result has only the link and the downloads |
+
+“Reset” brings the default back. Targets that are not set up on this server are listed under
+“not set up”, with “Set up” to the connectors.
+
+The arrow on a row opens its form: the name on the result page and what each field starts with.
+“Insert” puts a placeholder where the cursor is: an answer, a written result or the brand name.
+In the wizard file they read `{{email}}`, `{{steps.offer}}` and `{{brand.name}}`.
+
+While the result step is chosen, the studio shows its result page beside the flow, filled from
+the last test run. “Visitor” and “You” switch between what each of them gets. A target opens to
+its form as the visitor sees it, with the test run’s answers in it; nothing is sent from there.
+On a tablet or a phone, “Result page” switches the view, and “See the result page” opens it from
+the step. The result node on the flow shows the targets too: filled for visitors, a ring for
+you only.
+
 ## Branches
 
 A step can send the run somewhere else when a condition holds: a field is or is not a value, is

package/apps/runtime/dist/docs/user/test-and-share.md

@@ -1,7 +1,7 @@
 ---
 title: Test and share
 description: Try the wizard, publish it, and hand out its link or put it on a website.
-version: 0.5.0
+version: 0.7.11
 ---
 
 ## Test
@@ -216,7 +216,8 @@ On WordPress the plugin writes this code for you, and its results show the page:
 
 On the result page, a person can share what they got as a link. The result of a run over the
 wizard’s link, and the link to it, are deleted after 7 days. The person can withdraw the link
-earlier.
+earlier. “Share” also sends the result on – by email, into a cloud folder, to Slack or onto a
+website: see [Share a result](./run.md#share-a-result).
 
 ## Move a wizard